<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="dfareporting_v2_5beta1.html">DCM/DFA Reporting And Trafficking API</a> . <a href="dfareporting_v2_5beta1.advertiserGroups.html">advertiserGroups</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#delete">delete(profileId, id)</a></code></p>
<p class="firstline">Deletes an existing advertiser group.</p>
<p class="toc_element">
  <code><a href="#get">get(profileId, id)</a></code></p>
<p class="firstline">Gets one advertiser group by ID.</p>
<p class="toc_element">
  <code><a href="#insert">insert(profileId, body)</a></code></p>
<p class="firstline">Inserts a new advertiser group.</p>
<p class="toc_element">
  <code><a href="#list">list(profileId, searchString=None, pageToken=None, sortField=None, ids=None, maxResults=None, sortOrder=None)</a></code></p>
<p class="firstline">Retrieves a list of advertiser groups, possibly filtered. This method supports paging.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(profileId, id, body)</a></code></p>
<p class="firstline">Updates an existing advertiser group. This method supports patch semantics.</p>
<p class="toc_element">
  <code><a href="#update">update(profileId, body)</a></code></p>
<p class="firstline">Updates an existing advertiser group.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="delete">delete(profileId, id)</code>
  <pre>Deletes an existing advertiser group.

Args:
  profileId: string, User profile ID associated with this request. (required)
  id: string, Advertiser group ID. (required)
</pre>
</div>

<div class="method">
    <code class="details" id="get">get(profileId, id)</code>
  <pre>Gets one advertiser group by ID.

Args:
  profileId: string, User profile ID associated with this request. (required)
  id: string, Advertiser group ID. (required)

Returns:
  An object of the form:

    { # Groups advertisers together so that reports can be generated for the entire group at once.
      "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
      "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
      "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
      "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
    }</pre>
</div>

<div class="method">
    <code class="details" id="insert">insert(profileId, body)</code>
  <pre>Inserts a new advertiser group.

Args:
  profileId: string, User profile ID associated with this request. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Groups advertisers together so that reports can be generated for the entire group at once.
    "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
    "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
    "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
    "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
  }


Returns:
  An object of the form:

    { # Groups advertisers together so that reports can be generated for the entire group at once.
      "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
      "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
      "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
      "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
    }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(profileId, searchString=None, pageToken=None, sortField=None, ids=None, maxResults=None, sortOrder=None)</code>
  <pre>Retrieves a list of advertiser groups, possibly filtered. This method supports paging.

Args:
  profileId: string, User profile ID associated with this request. (required)
  searchString: string, Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "advertiser*2015" will return objects with names like "advertiser group June 2015", "advertiser group April 2015", or simply "advertiser group 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "advertisergroup" will match objects with name "my advertisergroup", "advertisergroup 2015", or simply "advertisergroup".
  pageToken: string, Value of the nextPageToken from the previous result page.
  sortField: string, Field by which to sort the list.
    Allowed values
      ID - 
      NAME - 
  ids: string, Select only advertiser groups with these IDs. (repeated)
  maxResults: integer, Maximum number of results to return.
  sortOrder: string, Order of sorted results, default is ASCENDING.
    Allowed values
      ASCENDING - 
      DESCENDING - 

Returns:
  An object of the form:

    { # Advertiser Group List Response
    "nextPageToken": "A String", # Pagination token to be used for the next list operation.
    "kind": "dfareporting#advertiserGroupsListResponse", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroupsListResponse".
    "advertiserGroups": [ # Advertiser group collection.
      { # Groups advertisers together so that reports can be generated for the entire group at once.
          "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
          "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
          "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
          "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
        },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call 'execute()' on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(profileId, id, body)</code>
  <pre>Updates an existing advertiser group. This method supports patch semantics.

Args:
  profileId: string, User profile ID associated with this request. (required)
  id: string, Advertiser group ID. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Groups advertisers together so that reports can be generated for the entire group at once.
    "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
    "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
    "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
    "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
  }


Returns:
  An object of the form:

    { # Groups advertisers together so that reports can be generated for the entire group at once.
      "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
      "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
      "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
      "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
    }</pre>
</div>

<div class="method">
    <code class="details" id="update">update(profileId, body)</code>
  <pre>Updates an existing advertiser group.

Args:
  profileId: string, User profile ID associated with this request. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Groups advertisers together so that reports can be generated for the entire group at once.
    "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
    "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
    "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
    "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
  }


Returns:
  An object of the form:

    { # Groups advertisers together so that reports can be generated for the entire group at once.
      "kind": "dfareporting#advertiserGroup", # Identifies what kind of resource this is. Value: the fixed string "dfareporting#advertiserGroup".
      "id": "A String", # ID of this advertiser group. This is a read-only, auto-generated field.
      "name": "A String", # Name of this advertiser group. This is a required field and must be less than 256 characters long and unique among advertiser groups of the same account.
      "accountId": "A String", # Account ID of this advertiser group. This is a read-only field that can be left blank.
    }</pre>
</div>

</body></html>