<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="analyticsadmin_v1alpha.html">Google Analytics Admin API</a> . <a href="analyticsadmin_v1alpha.properties.html">properties</a> . <a href="analyticsadmin_v1alpha.properties.iosAppDataStreams.html">iosAppDataStreams</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#close">close()</a></code></p>
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
  <code><a href="#create">create(parent, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Creates an iOS app data stream with the specified location and attributes.</p>
<p class="toc_element">
  <code><a href="#delete">delete(name, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes an iOS app stream on a property.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Lookup for a single IosAppDataStream Throws "Target not found" if no such iOS app data stream found, or if the caller does not have permissions to access it.</p>
<p class="toc_element">
  <code><a href="#list">list(parent, pageToken=None, pageSize=None, x__xgafv=None)</a></code></p>
<p class="firstline">Returns child iOS app data streams under the specified parent property. iOS app data streams will be excluded if the caller does not have access. Returns an empty list if no relevant iOS app data streams are found.</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(name, body=None, updateMask=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates an iOS app stream on a property.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="create">create(parent, body=None, x__xgafv=None)</code>
  <pre>Creates an iOS app data stream with the specified location and attributes.

Args:
  parent: string, Required. The parent resource where this ios app data stream will be created. Format: properties/123 (required)
  body: object, The request body.
    The object takes the form of:

{ # A resource message representing a Google Analytics IOS app stream.
    &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this stream was originally created.
    &quot;firebaseAppId&quot;: &quot;A String&quot;, # Output only. ID of the corresponding iOS app in Firebase, if any. This ID can change if the iOS app is deleted and recreated.
    &quot;bundleId&quot;: &quot;A String&quot;, # Required. Immutable. The Apple App Store Bundle ID for the app Example: &quot;com.example.myiosapp&quot;
    &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when stream payload fields were last updated.
    &quot;displayName&quot;: &quot;A String&quot;, # Human-readable display name for the Data Stream. The max allowed display name length is 255 UTF-16 code units.
    &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot;
  }

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A resource message representing a Google Analytics IOS app stream.
      &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this stream was originally created.
      &quot;firebaseAppId&quot;: &quot;A String&quot;, # Output only. ID of the corresponding iOS app in Firebase, if any. This ID can change if the iOS app is deleted and recreated.
      &quot;bundleId&quot;: &quot;A String&quot;, # Required. Immutable. The Apple App Store Bundle ID for the app Example: &quot;com.example.myiosapp&quot;
      &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when stream payload fields were last updated.
      &quot;displayName&quot;: &quot;A String&quot;, # Human-readable display name for the Data Stream. The max allowed display name length is 255 UTF-16 code units.
      &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot;
    }</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, x__xgafv=None)</code>
  <pre>Deletes an iOS app stream on a property.

Args:
  name: string, Required. The name of the iOS app data stream to delete. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/123/iosAppDataStreams/456&quot; (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.
  }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(name, x__xgafv=None)</code>
  <pre>Lookup for a single IosAppDataStream Throws &quot;Target not found&quot; if no such iOS app data stream found, or if the caller does not have permissions to access it.

Args:
  name: string, Required. The name of the iOS app data stream to lookup. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/123/iosAppDataStreams/456&quot; (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A resource message representing a Google Analytics IOS app stream.
      &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this stream was originally created.
      &quot;firebaseAppId&quot;: &quot;A String&quot;, # Output only. ID of the corresponding iOS app in Firebase, if any. This ID can change if the iOS app is deleted and recreated.
      &quot;bundleId&quot;: &quot;A String&quot;, # Required. Immutable. The Apple App Store Bundle ID for the app Example: &quot;com.example.myiosapp&quot;
      &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when stream payload fields were last updated.
      &quot;displayName&quot;: &quot;A String&quot;, # Human-readable display name for the Data Stream. The max allowed display name length is 255 UTF-16 code units.
      &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot;
    }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(parent, pageToken=None, pageSize=None, x__xgafv=None)</code>
  <pre>Returns child iOS app data streams under the specified parent property. iOS app data streams will be excluded if the caller does not have access. Returns an empty list if no relevant iOS app data streams are found.

Args:
  parent: string, Required. The name of the parent property. For example, to list results of app streams under the property with Id 123: &quot;properties/123&quot; (required)
  pageToken: string, A page token, received from a previous `ListIosAppDataStreams` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListIosAppDataStreams` must match the call that provided the page token.
  pageSize: integer, The maximum number of resources to return. If unspecified, at most 50 resources will be returned. The maximum value is 200; (higher values will be coerced to the maximum)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Request message for ListIosAppDataStreams RPC.
    &quot;nextPageToken&quot;: &quot;A String&quot;, # A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
    &quot;iosAppDataStreams&quot;: [ # Results that matched the filter criteria and were accessible to the caller.
      { # A resource message representing a Google Analytics IOS app stream.
          &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this stream was originally created.
          &quot;firebaseAppId&quot;: &quot;A String&quot;, # Output only. ID of the corresponding iOS app in Firebase, if any. This ID can change if the iOS app is deleted and recreated.
          &quot;bundleId&quot;: &quot;A String&quot;, # Required. Immutable. The Apple App Store Bundle ID for the app Example: &quot;com.example.myiosapp&quot;
          &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when stream payload fields were last updated.
          &quot;displayName&quot;: &quot;A String&quot;, # Human-readable display name for the Data Stream. The max allowed display name length is 255 UTF-16 code units.
          &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot;
        },
    ],
  }</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 &#x27;execute()&#x27; 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(name, body=None, updateMask=None, x__xgafv=None)</code>
  <pre>Updates an iOS app stream on a property.

Args:
  name: string, Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot; (required)
  body: object, The request body.
    The object takes the form of:

{ # A resource message representing a Google Analytics IOS app stream.
    &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this stream was originally created.
    &quot;firebaseAppId&quot;: &quot;A String&quot;, # Output only. ID of the corresponding iOS app in Firebase, if any. This ID can change if the iOS app is deleted and recreated.
    &quot;bundleId&quot;: &quot;A String&quot;, # Required. Immutable. The Apple App Store Bundle ID for the app Example: &quot;com.example.myiosapp&quot;
    &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when stream payload fields were last updated.
    &quot;displayName&quot;: &quot;A String&quot;, # Human-readable display name for the Data Stream. The max allowed display name length is 255 UTF-16 code units.
    &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot;
  }

  updateMask: string, The list of fields to be updated. Omitted fields will not be updated.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A resource message representing a Google Analytics IOS app stream.
      &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this stream was originally created.
      &quot;firebaseAppId&quot;: &quot;A String&quot;, # Output only. ID of the corresponding iOS app in Firebase, if any. This ID can change if the iOS app is deleted and recreated.
      &quot;bundleId&quot;: &quot;A String&quot;, # Required. Immutable. The Apple App Store Bundle ID for the app Example: &quot;com.example.myiosapp&quot;
      &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when stream payload fields were last updated.
      &quot;displayName&quot;: &quot;A String&quot;, # Human-readable display name for the Data Stream. The max allowed display name length is 255 UTF-16 code units.
      &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this Data Stream. Format: properties/{property_id}/iosAppDataStreams/{stream_id} Example: &quot;properties/1000/iosAppDataStreams/2000&quot;
    }</pre>
</div>

</body></html>