<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.displayVideo360AdvertiserLinkProposals.html">displayVideo360AdvertiserLinkProposals</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#approve">approve(name, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Approves a DisplayVideo360AdvertiserLinkProposal. The DisplayVideo360AdvertiserLinkProposal will be deleted and a new DisplayVideo360AdvertiserLink will be created.</p>
<p class="toc_element">
  <code><a href="#cancel">cancel(name, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Cancels a DisplayVideo360AdvertiserLinkProposal. Cancelling can mean either: - Declining a proposal initiated from Display & Video 360 - Withdrawing a proposal initiated from Google Analytics After being cancelled, a proposal will eventually be deleted automatically.</p>
<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 a DisplayVideo360AdvertiserLinkProposal.</p>
<p class="toc_element">
  <code><a href="#delete">delete(name, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes a DisplayVideo360AdvertiserLinkProposal on a property. This can only be used on cancelled proposals.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Lookup for a single DisplayVideo360AdvertiserLinkProposal.</p>
<p class="toc_element">
  <code><a href="#list">list(parent, pageSize=None, pageToken=None, x__xgafv=None)</a></code></p>
<p class="firstline">Lists DisplayVideo360AdvertiserLinkProposals on a property.</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>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="approve">approve(name, body=None, x__xgafv=None)</code>
  <pre>Approves a DisplayVideo360AdvertiserLinkProposal. The DisplayVideo360AdvertiserLinkProposal will be deleted and a new DisplayVideo360AdvertiserLink will be created.

Args:
  name: string, Required. The name of the DisplayVideo360AdvertiserLinkProposal to approve. Example format: properties/1234/displayVideo360AdvertiserLinkProposals/5678 (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for ApproveDisplayVideo360AdvertiserLinkProposal RPC.
}

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

Returns:
  An object of the form:

    { # Response message for ApproveDisplayVideo360AdvertiserLinkProposal RPC.
  &quot;displayVideo360AdvertiserLink&quot;: { # A link between a GA4 property and a Display &amp; Video 360 advertiser. # The DisplayVideo360AdvertiserLink created as a result of approving the proposal.
    &quot;adsPersonalizationEnabled&quot;: True or False, # Enables personalized advertising features with this integration. If this field is not set on create/update, it will be defaulted to true.
    &quot;advertiserDisplayName&quot;: &quot;A String&quot;, # Output only. The display name of the Display &amp; Video 360 Advertiser.
    &quot;advertiserId&quot;: &quot;A String&quot;, # Immutable. The Display &amp; Video 360 Advertiser&#x27;s advertiser ID.
    &quot;campaignDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of campaign data from Display &amp; Video 360 into the GA4 property. After link creation, this can only be updated from the Display &amp; Video 360 product. If this field is not set on create, it will be defaulted to true.
    &quot;costDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of cost data from Display &amp; Video 360 into the GA4 property. This can only be enabled if campaign_data_sharing_enabled is enabled. After link creation, this can only be updated from the Display &amp; Video 360 product. If this field is not set on create, it will be defaulted to true.
    &quot;name&quot;: &quot;A String&quot;, # Output only. The resource name for this DisplayVideo360AdvertiserLink resource. Format: properties/{propertyId}/displayVideo360AdvertiserLinks/{linkId} Note: linkId is not the Display &amp; Video 360 Advertiser ID
  },
}</pre>
</div>

<div class="method">
    <code class="details" id="cancel">cancel(name, body=None, x__xgafv=None)</code>
  <pre>Cancels a DisplayVideo360AdvertiserLinkProposal. Cancelling can mean either: - Declining a proposal initiated from Display &amp; Video 360 - Withdrawing a proposal initiated from Google Analytics After being cancelled, a proposal will eventually be deleted automatically.

Args:
  name: string, Required. The name of the DisplayVideo360AdvertiserLinkProposal to cancel. Example format: properties/1234/displayVideo360AdvertiserLinkProposals/5678 (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for CancelDisplayVideo360AdvertiserLinkProposal RPC.
}

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

Returns:
  An object of the form:

    { # A proposal for a link between a GA4 property and a Display &amp; Video 360 advertiser. A proposal is converted to a DisplayVideo360AdvertiserLink once approved. Google Analytics admins approve inbound proposals while Display &amp; Video 360 admins approve outbound proposals.
  &quot;adsPersonalizationEnabled&quot;: True or False, # Immutable. Enables personalized advertising features with this integration. If this field is not set on create, it will be defaulted to true.
  &quot;advertiserDisplayName&quot;: &quot;A String&quot;, # Output only. The display name of the Display &amp; Video Advertiser. Only populated for proposals that originated from Display &amp; Video 360.
  &quot;advertiserId&quot;: &quot;A String&quot;, # Immutable. The Display &amp; Video 360 Advertiser&#x27;s advertiser ID.
  &quot;campaignDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of campaign data from Display &amp; Video 360. If this field is not set on create, it will be defaulted to true.
  &quot;costDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of cost data from Display &amp; Video 360. This can only be enabled if campaign_data_sharing_enabled is enabled. If this field is not set on create, it will be defaulted to true.
  &quot;linkProposalStatusDetails&quot;: { # Status information for a link proposal. # Output only. The status information for this link proposal.
    &quot;linkProposalInitiatingProduct&quot;: &quot;A String&quot;, # Output only. The source of this proposal.
    &quot;linkProposalState&quot;: &quot;A String&quot;, # Output only. The state of this proposal.
    &quot;requestorEmail&quot;: &quot;A String&quot;, # Output only. The email address of the user that proposed this linkage.
  },
  &quot;name&quot;: &quot;A String&quot;, # Output only. The resource name for this DisplayVideo360AdvertiserLinkProposal resource. Format: properties/{propertyId}/displayVideo360AdvertiserLinkProposals/{proposalId} Note: proposalId is not the Display &amp; Video 360 Advertiser ID
  &quot;validationEmail&quot;: &quot;A String&quot;, # Input only. On a proposal being sent to Display &amp; Video 360, this field must be set to the email address of an admin on the target advertiser. This is used to verify that the Google Analytics admin is aware of at least one admin on the Display &amp; Video 360 Advertiser. This does not restrict approval of the proposal to a single user. Any admin on the Display &amp; Video 360 Advertiser may approve the proposal.
}</pre>
</div>

<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 a DisplayVideo360AdvertiserLinkProposal.

Args:
  parent: string, Required. Example format: properties/1234 (required)
  body: object, The request body.
    The object takes the form of:

{ # A proposal for a link between a GA4 property and a Display &amp; Video 360 advertiser. A proposal is converted to a DisplayVideo360AdvertiserLink once approved. Google Analytics admins approve inbound proposals while Display &amp; Video 360 admins approve outbound proposals.
  &quot;adsPersonalizationEnabled&quot;: True or False, # Immutable. Enables personalized advertising features with this integration. If this field is not set on create, it will be defaulted to true.
  &quot;advertiserDisplayName&quot;: &quot;A String&quot;, # Output only. The display name of the Display &amp; Video Advertiser. Only populated for proposals that originated from Display &amp; Video 360.
  &quot;advertiserId&quot;: &quot;A String&quot;, # Immutable. The Display &amp; Video 360 Advertiser&#x27;s advertiser ID.
  &quot;campaignDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of campaign data from Display &amp; Video 360. If this field is not set on create, it will be defaulted to true.
  &quot;costDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of cost data from Display &amp; Video 360. This can only be enabled if campaign_data_sharing_enabled is enabled. If this field is not set on create, it will be defaulted to true.
  &quot;linkProposalStatusDetails&quot;: { # Status information for a link proposal. # Output only. The status information for this link proposal.
    &quot;linkProposalInitiatingProduct&quot;: &quot;A String&quot;, # Output only. The source of this proposal.
    &quot;linkProposalState&quot;: &quot;A String&quot;, # Output only. The state of this proposal.
    &quot;requestorEmail&quot;: &quot;A String&quot;, # Output only. The email address of the user that proposed this linkage.
  },
  &quot;name&quot;: &quot;A String&quot;, # Output only. The resource name for this DisplayVideo360AdvertiserLinkProposal resource. Format: properties/{propertyId}/displayVideo360AdvertiserLinkProposals/{proposalId} Note: proposalId is not the Display &amp; Video 360 Advertiser ID
  &quot;validationEmail&quot;: &quot;A String&quot;, # Input only. On a proposal being sent to Display &amp; Video 360, this field must be set to the email address of an admin on the target advertiser. This is used to verify that the Google Analytics admin is aware of at least one admin on the Display &amp; Video 360 Advertiser. This does not restrict approval of the proposal to a single user. Any admin on the Display &amp; Video 360 Advertiser may approve the proposal.
}

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

Returns:
  An object of the form:

    { # A proposal for a link between a GA4 property and a Display &amp; Video 360 advertiser. A proposal is converted to a DisplayVideo360AdvertiserLink once approved. Google Analytics admins approve inbound proposals while Display &amp; Video 360 admins approve outbound proposals.
  &quot;adsPersonalizationEnabled&quot;: True or False, # Immutable. Enables personalized advertising features with this integration. If this field is not set on create, it will be defaulted to true.
  &quot;advertiserDisplayName&quot;: &quot;A String&quot;, # Output only. The display name of the Display &amp; Video Advertiser. Only populated for proposals that originated from Display &amp; Video 360.
  &quot;advertiserId&quot;: &quot;A String&quot;, # Immutable. The Display &amp; Video 360 Advertiser&#x27;s advertiser ID.
  &quot;campaignDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of campaign data from Display &amp; Video 360. If this field is not set on create, it will be defaulted to true.
  &quot;costDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of cost data from Display &amp; Video 360. This can only be enabled if campaign_data_sharing_enabled is enabled. If this field is not set on create, it will be defaulted to true.
  &quot;linkProposalStatusDetails&quot;: { # Status information for a link proposal. # Output only. The status information for this link proposal.
    &quot;linkProposalInitiatingProduct&quot;: &quot;A String&quot;, # Output only. The source of this proposal.
    &quot;linkProposalState&quot;: &quot;A String&quot;, # Output only. The state of this proposal.
    &quot;requestorEmail&quot;: &quot;A String&quot;, # Output only. The email address of the user that proposed this linkage.
  },
  &quot;name&quot;: &quot;A String&quot;, # Output only. The resource name for this DisplayVideo360AdvertiserLinkProposal resource. Format: properties/{propertyId}/displayVideo360AdvertiserLinkProposals/{proposalId} Note: proposalId is not the Display &amp; Video 360 Advertiser ID
  &quot;validationEmail&quot;: &quot;A String&quot;, # Input only. On a proposal being sent to Display &amp; Video 360, this field must be set to the email address of an admin on the target advertiser. This is used to verify that the Google Analytics admin is aware of at least one admin on the Display &amp; Video 360 Advertiser. This does not restrict approval of the proposal to a single user. Any admin on the Display &amp; Video 360 Advertiser may approve the proposal.
}</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, x__xgafv=None)</code>
  <pre>Deletes a DisplayVideo360AdvertiserLinkProposal on a property. This can only be used on cancelled proposals.

Args:
  name: string, Required. The name of the DisplayVideo360AdvertiserLinkProposal to delete. Example format: properties/1234/displayVideo360AdvertiserLinkProposals/5678 (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 DisplayVideo360AdvertiserLinkProposal.

Args:
  name: string, Required. The name of the DisplayVideo360AdvertiserLinkProposal to get. Example format: properties/1234/displayVideo360AdvertiserLinkProposals/5678 (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A proposal for a link between a GA4 property and a Display &amp; Video 360 advertiser. A proposal is converted to a DisplayVideo360AdvertiserLink once approved. Google Analytics admins approve inbound proposals while Display &amp; Video 360 admins approve outbound proposals.
  &quot;adsPersonalizationEnabled&quot;: True or False, # Immutable. Enables personalized advertising features with this integration. If this field is not set on create, it will be defaulted to true.
  &quot;advertiserDisplayName&quot;: &quot;A String&quot;, # Output only. The display name of the Display &amp; Video Advertiser. Only populated for proposals that originated from Display &amp; Video 360.
  &quot;advertiserId&quot;: &quot;A String&quot;, # Immutable. The Display &amp; Video 360 Advertiser&#x27;s advertiser ID.
  &quot;campaignDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of campaign data from Display &amp; Video 360. If this field is not set on create, it will be defaulted to true.
  &quot;costDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of cost data from Display &amp; Video 360. This can only be enabled if campaign_data_sharing_enabled is enabled. If this field is not set on create, it will be defaulted to true.
  &quot;linkProposalStatusDetails&quot;: { # Status information for a link proposal. # Output only. The status information for this link proposal.
    &quot;linkProposalInitiatingProduct&quot;: &quot;A String&quot;, # Output only. The source of this proposal.
    &quot;linkProposalState&quot;: &quot;A String&quot;, # Output only. The state of this proposal.
    &quot;requestorEmail&quot;: &quot;A String&quot;, # Output only. The email address of the user that proposed this linkage.
  },
  &quot;name&quot;: &quot;A String&quot;, # Output only. The resource name for this DisplayVideo360AdvertiserLinkProposal resource. Format: properties/{propertyId}/displayVideo360AdvertiserLinkProposals/{proposalId} Note: proposalId is not the Display &amp; Video 360 Advertiser ID
  &quot;validationEmail&quot;: &quot;A String&quot;, # Input only. On a proposal being sent to Display &amp; Video 360, this field must be set to the email address of an admin on the target advertiser. This is used to verify that the Google Analytics admin is aware of at least one admin on the Display &amp; Video 360 Advertiser. This does not restrict approval of the proposal to a single user. Any admin on the Display &amp; Video 360 Advertiser may approve the proposal.
}</pre>
</div>

<div class="method">
    <code class="details" id="list">list(parent, pageSize=None, pageToken=None, x__xgafv=None)</code>
  <pre>Lists DisplayVideo360AdvertiserLinkProposals on a property.

Args:
  parent: string, Required. Example format: properties/1234 (required)
  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).
  pageToken: string, A page token, received from a previous `ListDisplayVideo360AdvertiserLinkProposals` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListDisplayVideo360AdvertiserLinkProposals` must match the call that provided the page token.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response message for ListDisplayVideo360AdvertiserLinkProposals RPC.
  &quot;displayVideo360AdvertiserLinkProposals&quot;: [ # List of DisplayVideo360AdvertiserLinkProposals.
    { # A proposal for a link between a GA4 property and a Display &amp; Video 360 advertiser. A proposal is converted to a DisplayVideo360AdvertiserLink once approved. Google Analytics admins approve inbound proposals while Display &amp; Video 360 admins approve outbound proposals.
      &quot;adsPersonalizationEnabled&quot;: True or False, # Immutable. Enables personalized advertising features with this integration. If this field is not set on create, it will be defaulted to true.
      &quot;advertiserDisplayName&quot;: &quot;A String&quot;, # Output only. The display name of the Display &amp; Video Advertiser. Only populated for proposals that originated from Display &amp; Video 360.
      &quot;advertiserId&quot;: &quot;A String&quot;, # Immutable. The Display &amp; Video 360 Advertiser&#x27;s advertiser ID.
      &quot;campaignDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of campaign data from Display &amp; Video 360. If this field is not set on create, it will be defaulted to true.
      &quot;costDataSharingEnabled&quot;: True or False, # Immutable. Enables the import of cost data from Display &amp; Video 360. This can only be enabled if campaign_data_sharing_enabled is enabled. If this field is not set on create, it will be defaulted to true.
      &quot;linkProposalStatusDetails&quot;: { # Status information for a link proposal. # Output only. The status information for this link proposal.
        &quot;linkProposalInitiatingProduct&quot;: &quot;A String&quot;, # Output only. The source of this proposal.
        &quot;linkProposalState&quot;: &quot;A String&quot;, # Output only. The state of this proposal.
        &quot;requestorEmail&quot;: &quot;A String&quot;, # Output only. The email address of the user that proposed this linkage.
      },
      &quot;name&quot;: &quot;A String&quot;, # Output only. The resource name for this DisplayVideo360AdvertiserLinkProposal resource. Format: properties/{propertyId}/displayVideo360AdvertiserLinkProposals/{proposalId} Note: proposalId is not the Display &amp; Video 360 Advertiser ID
      &quot;validationEmail&quot;: &quot;A String&quot;, # Input only. On a proposal being sent to Display &amp; Video 360, this field must be set to the email address of an admin on the target advertiser. This is used to verify that the Google Analytics admin is aware of at least one admin on the Display &amp; Video 360 Advertiser. This does not restrict approval of the proposal to a single user. Any admin on the Display &amp; Video 360 Advertiser may approve the proposal.
    },
  ],
  &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.
}</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>

</body></html>