<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="cloudchannel_v1.html">Cloud Channel API</a> . <a href="cloudchannel_v1.accounts.html">accounts</a> . <a href="cloudchannel_v1.accounts.channelPartnerLinks.html">channelPartnerLinks</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="cloudchannel_v1.accounts.channelPartnerLinks.customers.html">customers()</a></code>
</p>
<p class="firstline">Returns the customers Resource.</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">Initiates a channel partner link between a distributor and a reseller, or between resellers in an n-tier reseller channel. Invited partners need to follow the invite_link_uri provided in the response to accept. After accepting the invitation, a link is set up between the two parties. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: Required request parameters are missing or invalid. * ALREADY_EXISTS: The ChannelPartnerLink sent in the request already exists. * NOT_FOUND: No Cloud Identity customer exists for provided domain. * INTERNAL: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. * UNKNOWN: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. Return value: The new ChannelPartnerLink resource.</p>
<p class="toc_element">
  <code><a href="#get">get(name, view=None, x__xgafv=None)</a></code></p>
<p class="firstline">Returns a requested ChannelPartnerLink resource. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: Required request parameters are missing or invalid. * NOT_FOUND: ChannelPartnerLink resource not found because of an invalid channel partner link name. Return value: The ChannelPartnerLink resource.</p>
<p class="toc_element">
  <code><a href="#list">list(parent, pageSize=None, pageToken=None, view=None, x__xgafv=None)</a></code></p>
<p class="firstline">List ChannelPartnerLinks belonging to a distributor. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: Required request parameters are missing or invalid. Return value: The list of the distributor account's ChannelPartnerLink resources.</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, x__xgafv=None)</a></code></p>
<p class="firstline">Updates a channel partner link. Distributors call this method to change a link's status. For example, to suspend a partner link. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: * Required request parameters are missing or invalid. * Link state cannot change from invited to active or suspended. * Cannot send reseller_cloud_identity_id, invite_url, or name in update mask. * NOT_FOUND: ChannelPartnerLink resource not found. * INTERNAL: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. * UNKNOWN: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. Return value: The updated ChannelPartnerLink resource.</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>Initiates a channel partner link between a distributor and a reseller, or between resellers in an n-tier reseller channel. Invited partners need to follow the invite_link_uri provided in the response to accept. After accepting the invitation, a link is set up between the two parties. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: Required request parameters are missing or invalid. * ALREADY_EXISTS: The ChannelPartnerLink sent in the request already exists. * NOT_FOUND: No Cloud Identity customer exists for provided domain. * INTERNAL: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. * UNKNOWN: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. Return value: The new ChannelPartnerLink resource.

Args:
  parent: string, Required. Create a channel partner link for the provided reseller account&#x27;s resource name. Parent uses the format: accounts/{account_id} (required)
  body: object, The request body.
    The object takes the form of:

{ # Entity representing a link between distributors and their indirect resellers in an n-tier resale channel.
  &quot;channelPartnerCloudIdentityInfo&quot;: { # Cloud Identity information for the Cloud Channel Customer. # Output only. Cloud Identity info of the channel partner (IR).
    &quot;adminConsoleUri&quot;: &quot;A String&quot;, # Output only. URI of Customer&#x27;s Admin console dashboard.
    &quot;alternateEmail&quot;: &quot;A String&quot;, # The alternate email.
    &quot;customerType&quot;: &quot;A String&quot;, # CustomerType indicates verification type needed for using services.
    &quot;eduData&quot;: { # Required Edu Attributes # Edu information about the customer.
      &quot;instituteSize&quot;: &quot;A String&quot;, # Size of the institute.
      &quot;instituteType&quot;: &quot;A String&quot;, # Designated institute type of customer.
      &quot;website&quot;: &quot;A String&quot;, # Web address for the edu customer&#x27;s institution.
    },
    &quot;isDomainVerified&quot;: True or False, # Output only. Whether the domain is verified. This field is not returned for a Customer&#x27;s cloud_identity_info resource. Partners can use the domains.get() method of the Workspace SDK&#x27;s Directory API, or listen to the PRIMARY_DOMAIN_VERIFIED Pub/Sub event in to track domain verification of their resolve Workspace customers.
    &quot;languageCode&quot;: &quot;A String&quot;, # Language code.
    &quot;phoneNumber&quot;: &quot;A String&quot;, # Phone number associated with the Cloud Identity.
    &quot;primaryDomain&quot;: &quot;A String&quot;, # Output only. The primary domain name.
  },
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is created.
  &quot;inviteLinkUri&quot;: &quot;A String&quot;, # Output only. URI of the web page where partner accepts the link invitation.
  &quot;linkState&quot;: &quot;A String&quot;, # Required. State of the channel partner link.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name for the channel partner link, in the format accounts/{account_id}/channelPartnerLinks/{id}.
  &quot;publicId&quot;: &quot;A String&quot;, # Output only. Public identifier that a customer must use to generate a transfer token to move to this distributor-reseller combination.
  &quot;resellerCloudIdentityId&quot;: &quot;A String&quot;, # Required. Cloud Identity ID of the linked reseller.
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is updated.
}

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

Returns:
  An object of the form:

    { # Entity representing a link between distributors and their indirect resellers in an n-tier resale channel.
  &quot;channelPartnerCloudIdentityInfo&quot;: { # Cloud Identity information for the Cloud Channel Customer. # Output only. Cloud Identity info of the channel partner (IR).
    &quot;adminConsoleUri&quot;: &quot;A String&quot;, # Output only. URI of Customer&#x27;s Admin console dashboard.
    &quot;alternateEmail&quot;: &quot;A String&quot;, # The alternate email.
    &quot;customerType&quot;: &quot;A String&quot;, # CustomerType indicates verification type needed for using services.
    &quot;eduData&quot;: { # Required Edu Attributes # Edu information about the customer.
      &quot;instituteSize&quot;: &quot;A String&quot;, # Size of the institute.
      &quot;instituteType&quot;: &quot;A String&quot;, # Designated institute type of customer.
      &quot;website&quot;: &quot;A String&quot;, # Web address for the edu customer&#x27;s institution.
    },
    &quot;isDomainVerified&quot;: True or False, # Output only. Whether the domain is verified. This field is not returned for a Customer&#x27;s cloud_identity_info resource. Partners can use the domains.get() method of the Workspace SDK&#x27;s Directory API, or listen to the PRIMARY_DOMAIN_VERIFIED Pub/Sub event in to track domain verification of their resolve Workspace customers.
    &quot;languageCode&quot;: &quot;A String&quot;, # Language code.
    &quot;phoneNumber&quot;: &quot;A String&quot;, # Phone number associated with the Cloud Identity.
    &quot;primaryDomain&quot;: &quot;A String&quot;, # Output only. The primary domain name.
  },
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is created.
  &quot;inviteLinkUri&quot;: &quot;A String&quot;, # Output only. URI of the web page where partner accepts the link invitation.
  &quot;linkState&quot;: &quot;A String&quot;, # Required. State of the channel partner link.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name for the channel partner link, in the format accounts/{account_id}/channelPartnerLinks/{id}.
  &quot;publicId&quot;: &quot;A String&quot;, # Output only. Public identifier that a customer must use to generate a transfer token to move to this distributor-reseller combination.
  &quot;resellerCloudIdentityId&quot;: &quot;A String&quot;, # Required. Cloud Identity ID of the linked reseller.
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is updated.
}</pre>
</div>

<div class="method">
    <code class="details" id="get">get(name, view=None, x__xgafv=None)</code>
  <pre>Returns a requested ChannelPartnerLink resource. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: Required request parameters are missing or invalid. * NOT_FOUND: ChannelPartnerLink resource not found because of an invalid channel partner link name. Return value: The ChannelPartnerLink resource.

Args:
  name: string, Required. The resource name of the channel partner link to retrieve. Name uses the format: accounts/{account_id}/channelPartnerLinks/{id} where {id} is the Cloud Identity ID of the partner. (required)
  view: string, Optional. The level of granularity the ChannelPartnerLink will display.
    Allowed values
      UNSPECIFIED - The default / unset value. The API will default to the BASIC view.
      BASIC - Includes all fields except the ChannelPartnerLink.channel_partner_cloud_identity_info.
      FULL - Includes all fields.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Entity representing a link between distributors and their indirect resellers in an n-tier resale channel.
  &quot;channelPartnerCloudIdentityInfo&quot;: { # Cloud Identity information for the Cloud Channel Customer. # Output only. Cloud Identity info of the channel partner (IR).
    &quot;adminConsoleUri&quot;: &quot;A String&quot;, # Output only. URI of Customer&#x27;s Admin console dashboard.
    &quot;alternateEmail&quot;: &quot;A String&quot;, # The alternate email.
    &quot;customerType&quot;: &quot;A String&quot;, # CustomerType indicates verification type needed for using services.
    &quot;eduData&quot;: { # Required Edu Attributes # Edu information about the customer.
      &quot;instituteSize&quot;: &quot;A String&quot;, # Size of the institute.
      &quot;instituteType&quot;: &quot;A String&quot;, # Designated institute type of customer.
      &quot;website&quot;: &quot;A String&quot;, # Web address for the edu customer&#x27;s institution.
    },
    &quot;isDomainVerified&quot;: True or False, # Output only. Whether the domain is verified. This field is not returned for a Customer&#x27;s cloud_identity_info resource. Partners can use the domains.get() method of the Workspace SDK&#x27;s Directory API, or listen to the PRIMARY_DOMAIN_VERIFIED Pub/Sub event in to track domain verification of their resolve Workspace customers.
    &quot;languageCode&quot;: &quot;A String&quot;, # Language code.
    &quot;phoneNumber&quot;: &quot;A String&quot;, # Phone number associated with the Cloud Identity.
    &quot;primaryDomain&quot;: &quot;A String&quot;, # Output only. The primary domain name.
  },
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is created.
  &quot;inviteLinkUri&quot;: &quot;A String&quot;, # Output only. URI of the web page where partner accepts the link invitation.
  &quot;linkState&quot;: &quot;A String&quot;, # Required. State of the channel partner link.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name for the channel partner link, in the format accounts/{account_id}/channelPartnerLinks/{id}.
  &quot;publicId&quot;: &quot;A String&quot;, # Output only. Public identifier that a customer must use to generate a transfer token to move to this distributor-reseller combination.
  &quot;resellerCloudIdentityId&quot;: &quot;A String&quot;, # Required. Cloud Identity ID of the linked reseller.
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is updated.
}</pre>
</div>

<div class="method">
    <code class="details" id="list">list(parent, pageSize=None, pageToken=None, view=None, x__xgafv=None)</code>
  <pre>List ChannelPartnerLinks belonging to a distributor. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: Required request parameters are missing or invalid. Return value: The list of the distributor account&#x27;s ChannelPartnerLink resources.

Args:
  parent: string, Required. The resource name of the reseller account for listing channel partner links. Parent uses the format: accounts/{account_id} (required)
  pageSize: integer, Optional. Requested page size. Server might return fewer results than requested. If unspecified, server will pick a default size (25). The maximum value is 200; the server will coerce values above 200.
  pageToken: string, Optional. A token for a page of results other than the first page. Obtained using ListChannelPartnerLinksResponse.next_page_token of the previous CloudChannelService.ListChannelPartnerLinks call.
  view: string, Optional. The level of granularity the ChannelPartnerLink will display.
    Allowed values
      UNSPECIFIED - The default / unset value. The API will default to the BASIC view.
      BASIC - Includes all fields except the ChannelPartnerLink.channel_partner_cloud_identity_info.
      FULL - Includes all fields.
  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 CloudChannelService.ListChannelPartnerLinks.
  &quot;channelPartnerLinks&quot;: [ # The Channel partner links for a reseller.
    { # Entity representing a link between distributors and their indirect resellers in an n-tier resale channel.
      &quot;channelPartnerCloudIdentityInfo&quot;: { # Cloud Identity information for the Cloud Channel Customer. # Output only. Cloud Identity info of the channel partner (IR).
        &quot;adminConsoleUri&quot;: &quot;A String&quot;, # Output only. URI of Customer&#x27;s Admin console dashboard.
        &quot;alternateEmail&quot;: &quot;A String&quot;, # The alternate email.
        &quot;customerType&quot;: &quot;A String&quot;, # CustomerType indicates verification type needed for using services.
        &quot;eduData&quot;: { # Required Edu Attributes # Edu information about the customer.
          &quot;instituteSize&quot;: &quot;A String&quot;, # Size of the institute.
          &quot;instituteType&quot;: &quot;A String&quot;, # Designated institute type of customer.
          &quot;website&quot;: &quot;A String&quot;, # Web address for the edu customer&#x27;s institution.
        },
        &quot;isDomainVerified&quot;: True or False, # Output only. Whether the domain is verified. This field is not returned for a Customer&#x27;s cloud_identity_info resource. Partners can use the domains.get() method of the Workspace SDK&#x27;s Directory API, or listen to the PRIMARY_DOMAIN_VERIFIED Pub/Sub event in to track domain verification of their resolve Workspace customers.
        &quot;languageCode&quot;: &quot;A String&quot;, # Language code.
        &quot;phoneNumber&quot;: &quot;A String&quot;, # Phone number associated with the Cloud Identity.
        &quot;primaryDomain&quot;: &quot;A String&quot;, # Output only. The primary domain name.
      },
      &quot;createTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is created.
      &quot;inviteLinkUri&quot;: &quot;A String&quot;, # Output only. URI of the web page where partner accepts the link invitation.
      &quot;linkState&quot;: &quot;A String&quot;, # Required. State of the channel partner link.
      &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name for the channel partner link, in the format accounts/{account_id}/channelPartnerLinks/{id}.
      &quot;publicId&quot;: &quot;A String&quot;, # Output only. Public identifier that a customer must use to generate a transfer token to move to this distributor-reseller combination.
      &quot;resellerCloudIdentityId&quot;: &quot;A String&quot;, # Required. Cloud Identity ID of the linked reseller.
      &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is updated.
    },
  ],
  &quot;nextPageToken&quot;: &quot;A String&quot;, # A token to retrieve the next page of results. Pass to ListChannelPartnerLinksRequest.page_token to obtain that page.
}</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, x__xgafv=None)</code>
  <pre>Updates a channel partner link. Distributors call this method to change a link&#x27;s status. For example, to suspend a partner link. You must be a distributor to call this method. Possible error codes: * PERMISSION_DENIED: The reseller account making the request is different from the reseller account in the API request. * INVALID_ARGUMENT: * Required request parameters are missing or invalid. * Link state cannot change from invited to active or suspended. * Cannot send reseller_cloud_identity_id, invite_url, or name in update mask. * NOT_FOUND: ChannelPartnerLink resource not found. * INTERNAL: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. * UNKNOWN: Any non-user error related to a technical issue in the backend. Contact Cloud Channel support. Return value: The updated ChannelPartnerLink resource.

Args:
  name: string, Required. The resource name of the channel partner link to cancel. Name uses the format: accounts/{account_id}/channelPartnerLinks/{id} where {id} is the Cloud Identity ID of the partner. (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for CloudChannelService.UpdateChannelPartnerLink
  &quot;channelPartnerLink&quot;: { # Entity representing a link between distributors and their indirect resellers in an n-tier resale channel. # Required. The channel partner link to update. Only channel_partner_link.link_state is allowed for updates.
    &quot;channelPartnerCloudIdentityInfo&quot;: { # Cloud Identity information for the Cloud Channel Customer. # Output only. Cloud Identity info of the channel partner (IR).
      &quot;adminConsoleUri&quot;: &quot;A String&quot;, # Output only. URI of Customer&#x27;s Admin console dashboard.
      &quot;alternateEmail&quot;: &quot;A String&quot;, # The alternate email.
      &quot;customerType&quot;: &quot;A String&quot;, # CustomerType indicates verification type needed for using services.
      &quot;eduData&quot;: { # Required Edu Attributes # Edu information about the customer.
        &quot;instituteSize&quot;: &quot;A String&quot;, # Size of the institute.
        &quot;instituteType&quot;: &quot;A String&quot;, # Designated institute type of customer.
        &quot;website&quot;: &quot;A String&quot;, # Web address for the edu customer&#x27;s institution.
      },
      &quot;isDomainVerified&quot;: True or False, # Output only. Whether the domain is verified. This field is not returned for a Customer&#x27;s cloud_identity_info resource. Partners can use the domains.get() method of the Workspace SDK&#x27;s Directory API, or listen to the PRIMARY_DOMAIN_VERIFIED Pub/Sub event in to track domain verification of their resolve Workspace customers.
      &quot;languageCode&quot;: &quot;A String&quot;, # Language code.
      &quot;phoneNumber&quot;: &quot;A String&quot;, # Phone number associated with the Cloud Identity.
      &quot;primaryDomain&quot;: &quot;A String&quot;, # Output only. The primary domain name.
    },
    &quot;createTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is created.
    &quot;inviteLinkUri&quot;: &quot;A String&quot;, # Output only. URI of the web page where partner accepts the link invitation.
    &quot;linkState&quot;: &quot;A String&quot;, # Required. State of the channel partner link.
    &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name for the channel partner link, in the format accounts/{account_id}/channelPartnerLinks/{id}.
    &quot;publicId&quot;: &quot;A String&quot;, # Output only. Public identifier that a customer must use to generate a transfer token to move to this distributor-reseller combination.
    &quot;resellerCloudIdentityId&quot;: &quot;A String&quot;, # Required. Cloud Identity ID of the linked reseller.
    &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is updated.
  },
  &quot;updateMask&quot;: &quot;A String&quot;, # Required. The update mask that applies to the resource. The only allowable value for an update mask is channel_partner_link.link_state.
}

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

Returns:
  An object of the form:

    { # Entity representing a link between distributors and their indirect resellers in an n-tier resale channel.
  &quot;channelPartnerCloudIdentityInfo&quot;: { # Cloud Identity information for the Cloud Channel Customer. # Output only. Cloud Identity info of the channel partner (IR).
    &quot;adminConsoleUri&quot;: &quot;A String&quot;, # Output only. URI of Customer&#x27;s Admin console dashboard.
    &quot;alternateEmail&quot;: &quot;A String&quot;, # The alternate email.
    &quot;customerType&quot;: &quot;A String&quot;, # CustomerType indicates verification type needed for using services.
    &quot;eduData&quot;: { # Required Edu Attributes # Edu information about the customer.
      &quot;instituteSize&quot;: &quot;A String&quot;, # Size of the institute.
      &quot;instituteType&quot;: &quot;A String&quot;, # Designated institute type of customer.
      &quot;website&quot;: &quot;A String&quot;, # Web address for the edu customer&#x27;s institution.
    },
    &quot;isDomainVerified&quot;: True or False, # Output only. Whether the domain is verified. This field is not returned for a Customer&#x27;s cloud_identity_info resource. Partners can use the domains.get() method of the Workspace SDK&#x27;s Directory API, or listen to the PRIMARY_DOMAIN_VERIFIED Pub/Sub event in to track domain verification of their resolve Workspace customers.
    &quot;languageCode&quot;: &quot;A String&quot;, # Language code.
    &quot;phoneNumber&quot;: &quot;A String&quot;, # Phone number associated with the Cloud Identity.
    &quot;primaryDomain&quot;: &quot;A String&quot;, # Output only. The primary domain name.
  },
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is created.
  &quot;inviteLinkUri&quot;: &quot;A String&quot;, # Output only. URI of the web page where partner accepts the link invitation.
  &quot;linkState&quot;: &quot;A String&quot;, # Required. State of the channel partner link.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name for the channel partner link, in the format accounts/{account_id}/channelPartnerLinks/{id}.
  &quot;publicId&quot;: &quot;A String&quot;, # Output only. Public identifier that a customer must use to generate a transfer token to move to this distributor-reseller combination.
  &quot;resellerCloudIdentityId&quot;: &quot;A String&quot;, # Required. Cloud Identity ID of the linked reseller.
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Timestamp of when the channel partner link is updated.
}</pre>
</div>

</body></html>