<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="content_v2.html">Content API for Shopping</a> . <a href="content_v2.liasettings.html">liasettings</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#custombatch">custombatch(body, dryRun=None)</a></code></p>
<p class="firstline">Retrieves and/or updates the LIA settings of multiple accounts in a single request.</p>
<p class="toc_element">
  <code><a href="#get">get(merchantId, accountId)</a></code></p>
<p class="firstline">Retrieves the LIA settings of the account.</p>
<p class="toc_element">
  <code><a href="#getaccessiblegmbaccounts">getaccessiblegmbaccounts(merchantId, accountId)</a></code></p>
<p class="firstline">Retrieves the list of accessible Google My Business accounts.</p>
<p class="toc_element">
  <code><a href="#list">list(merchantId, pageToken=None, maxResults=None)</a></code></p>
<p class="firstline">Lists the LIA settings of the sub-accounts in your Merchant Center account.</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="#listposdataproviders">listposdataproviders()</a></code></p>
<p class="firstline">Retrieves the list of POS data providers that have active settings for the all eiligible countries.</p>
<p class="toc_element">
  <code><a href="#patch">patch(merchantId, accountId, body, dryRun=None)</a></code></p>
<p class="firstline">Updates the LIA settings of the account. This method supports patch semantics.</p>
<p class="toc_element">
  <code><a href="#requestgmbaccess">requestgmbaccess(merchantId, accountId, gmbEmail)</a></code></p>
<p class="firstline">Requests access to a specified Google My Business account.</p>
<p class="toc_element">
  <code><a href="#requestinventoryverification">requestinventoryverification(merchantId, accountId, country)</a></code></p>
<p class="firstline">Requests inventory validation for the specified country.</p>
<p class="toc_element">
  <code><a href="#setinventoryverificationcontact">setinventoryverificationcontact(merchantId, accountId, contactEmail, contactName, country, language)</a></code></p>
<p class="firstline">Sets the inventory verification contract for the specified country.</p>
<p class="toc_element">
  <code><a href="#setposdataprovider">setposdataprovider(merchantId, accountId, country, posDataProviderId=None, posExternalAccountId=None)</a></code></p>
<p class="firstline">Sets the POS data provider for the specified country.</p>
<p class="toc_element">
  <code><a href="#update">update(merchantId, accountId, body, dryRun=None)</a></code></p>
<p class="firstline">Updates the LIA settings of the account.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="custombatch">custombatch(body, dryRun=None)</code>
  <pre>Retrieves and/or updates the LIA settings of multiple accounts in a single request.

Args:
  body: object, The request body. (required)
    The object takes the form of:

{
    "entries": [ # The request entries to be processed in the batch.
      {
        "contactEmail": "A String", # Inventory validation contact email. Required only for SetInventoryValidationContact.
        "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS provider.
        "liaSettings": { # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role. # The account Lia settings to update. Only defined if the method is update.
          "countrySettings": [ # The LIA settings for each country.
            {
              "about": { # The settings for the About page.
                "status": "A String", # The status of the verification process for the About page.
                "url": "A String", # The URL for the About page.
              },
              "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
              "onDisplayToOrder": { # LIA "On Display To Order" settings.
                "status": "A String", # The status of the ?On display to order? feature.
                "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
              },
              "country": "A String", # CLDR country code (e.g. "US").
              "storePickupActive": True or False, # The status of the "Store pickup" feature.
              "posDataProvider": { # The POS data provider linked with this country.
                "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
                "posDataProviderId": "A String", # The ID of the POS data provider.
              },
              "inventory": { # LIA inventory verification settings.
                "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
                "status": "A String", # The status of the inventory verification process.
                "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
                "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
              },
            },
          ],
          "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
          "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
        },
        "gmbEmail": "A String", # The GMB account. Required only for RequestGmbAccess.
        "country": "A String", # The country code. Required only for RequestInventoryVerification.
        "method": "A String",
        "batchId": 42, # An entry ID, unique within the batch request.
        "contactName": "A String", # Inventory validation contact name. Required only for SetInventoryValidationContact.
        "posDataProviderId": "A String", # The ID of POS data provider. Required only for SetPosProvider.
        "merchantId": "A String", # The ID of the managing account.
        "accountId": "A String", # The ID of the account for which to get/update account shipping settings.
      },
    ],
  }

  dryRun: boolean, Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

Returns:
  An object of the form:

    {
    "kind": "content#liasettingsCustomBatchResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsCustomBatchResponse".
    "entries": [ # The result of the execution of the batch requests.
      {
        "kind": "content#liasettingsCustomBatchResponseEntry", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsCustomBatchResponseEntry".
        "errors": { # A list of errors returned by a failed batch entry. # A list of errors defined if, and only if, the request failed.
          "message": "A String", # The message of the first error in errors.
          "code": 42, # The HTTP status of the first error in errors.
          "errors": [ # A list of errors.
            { # An error returned by the API.
              "reason": "A String", # The error code.
              "domain": "A String", # The domain of the error.
              "message": "A String", # A description of the error.
            },
          ],
        },
        "gmbAccounts": { # The the list of accessible GMB accounts.
          "gmbAccounts": [ # A list of GMB accounts which are available to the merchant.
            {
              "listingCount": "A String", # Number of listings under this account.
              "type": "A String", # The type of the GMB account (User or Business).
              "email": "A String", # The email which identifies the GMB account.
              "name": "A String", # The name of the GMB account.
            },
          ],
          "accountId": "A String", # The ID of the account.
        },
        "batchId": 42, # The ID of the request entry to which this entry responds.
        "posDataProviders": [ # The list of POS data providers.
          {
            "country": "A String", # Country code.
            "posDataProviders": [ # A list of POS data providers.
              {
                "fullName": "A String", # The full name of this POS data Provider.
                "displayName": "A String", # The display name of Pos data Provider.
                "providerId": "A String", # The ID of the account.
              },
            ],
          },
        ],
        "liaSettings": { # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role. # The retrieved or updated Lia settings.
          "countrySettings": [ # The LIA settings for each country.
            {
              "about": { # The settings for the About page.
                "status": "A String", # The status of the verification process for the About page.
                "url": "A String", # The URL for the About page.
              },
              "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
              "onDisplayToOrder": { # LIA "On Display To Order" settings.
                "status": "A String", # The status of the ?On display to order? feature.
                "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
              },
              "country": "A String", # CLDR country code (e.g. "US").
              "storePickupActive": True or False, # The status of the "Store pickup" feature.
              "posDataProvider": { # The POS data provider linked with this country.
                "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
                "posDataProviderId": "A String", # The ID of the POS data provider.
              },
              "inventory": { # LIA inventory verification settings.
                "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
                "status": "A String", # The status of the inventory verification process.
                "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
                "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
              },
            },
          ],
          "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
          "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
        },
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(merchantId, accountId)</code>
  <pre>Retrieves the LIA settings of the account.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account for which to get or update LIA settings. (required)

Returns:
  An object of the form:

    { # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
    "countrySettings": [ # The LIA settings for each country.
      {
        "about": { # The settings for the About page.
          "status": "A String", # The status of the verification process for the About page.
          "url": "A String", # The URL for the About page.
        },
        "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
        "onDisplayToOrder": { # LIA "On Display To Order" settings.
          "status": "A String", # The status of the ?On display to order? feature.
          "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
        },
        "country": "A String", # CLDR country code (e.g. "US").
        "storePickupActive": True or False, # The status of the "Store pickup" feature.
        "posDataProvider": { # The POS data provider linked with this country.
          "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
          "posDataProviderId": "A String", # The ID of the POS data provider.
        },
        "inventory": { # LIA inventory verification settings.
          "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
          "status": "A String", # The status of the inventory verification process.
          "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
          "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
        },
      },
    ],
    "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
    "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
  }</pre>
</div>

<div class="method">
    <code class="details" id="getaccessiblegmbaccounts">getaccessiblegmbaccounts(merchantId, accountId)</code>
  <pre>Retrieves the list of accessible Google My Business accounts.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account for which to retrieve accessible Google My Business accounts. (required)

Returns:
  An object of the form:

    {
    "gmbAccounts": [ # A list of GMB accounts which are available to the merchant.
      {
        "listingCount": "A String", # Number of listings under this account.
        "type": "A String", # The type of the GMB account (User or Business).
        "email": "A String", # The email which identifies the GMB account.
        "name": "A String", # The name of the GMB account.
      },
    ],
    "kind": "content#liasettingsGetAccessibleGmbAccountsResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsGetAccessibleGmbAccountsResponse".
    "accountId": "A String", # The ID of the account.
  }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(merchantId, pageToken=None, maxResults=None)</code>
  <pre>Lists the LIA settings of the sub-accounts in your Merchant Center account.

Args:
  merchantId: string, The ID of the managing account. This must be a multi-client account. (required)
  pageToken: string, The token returned by the previous request.
  maxResults: integer, The maximum number of LIA settings to return in the response, used for paging.

Returns:
  An object of the form:

    {
    "nextPageToken": "A String", # The token for the retrieval of the next page of LIA settings.
    "kind": "content#liasettingsListResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsListResponse".
    "resources": [
      { # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
        "countrySettings": [ # The LIA settings for each country.
          {
            "about": { # The settings for the About page.
              "status": "A String", # The status of the verification process for the About page.
              "url": "A String", # The URL for the About page.
            },
            "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
            "onDisplayToOrder": { # LIA "On Display To Order" settings.
              "status": "A String", # The status of the ?On display to order? feature.
              "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
            },
            "country": "A String", # CLDR country code (e.g. "US").
            "storePickupActive": True or False, # The status of the "Store pickup" feature.
            "posDataProvider": { # The POS data provider linked with this country.
              "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
              "posDataProviderId": "A String", # The ID of the POS data provider.
            },
            "inventory": { # LIA inventory verification settings.
              "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
              "status": "A String", # The status of the inventory verification process.
              "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
              "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
            },
          },
        ],
        "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
        "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
      },
    ],
  }</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="listposdataproviders">listposdataproviders()</code>
  <pre>Retrieves the list of POS data providers that have active settings for the all eiligible countries.

Args:

Returns:
  An object of the form:

    {
    "kind": "content#liasettingsListPosDataProvidersResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsListPosDataProvidersResponse".
    "posDataProviders": [ # The list of POS data providers for each eligible country
      {
        "country": "A String", # Country code.
        "posDataProviders": [ # A list of POS data providers.
          {
            "fullName": "A String", # The full name of this POS data Provider.
            "displayName": "A String", # The display name of Pos data Provider.
            "providerId": "A String", # The ID of the account.
          },
        ],
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(merchantId, accountId, body, dryRun=None)</code>
  <pre>Updates the LIA settings of the account. This method supports patch semantics.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account for which to get or update LIA settings. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
  "countrySettings": [ # The LIA settings for each country.
    {
      "about": { # The settings for the About page.
        "status": "A String", # The status of the verification process for the About page.
        "url": "A String", # The URL for the About page.
      },
      "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
      "onDisplayToOrder": { # LIA "On Display To Order" settings.
        "status": "A String", # The status of the ?On display to order? feature.
        "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
      },
      "country": "A String", # CLDR country code (e.g. "US").
      "storePickupActive": True or False, # The status of the "Store pickup" feature.
      "posDataProvider": { # The POS data provider linked with this country.
        "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
        "posDataProviderId": "A String", # The ID of the POS data provider.
      },
      "inventory": { # LIA inventory verification settings.
        "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
        "status": "A String", # The status of the inventory verification process.
        "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
        "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
      },
    },
  ],
  "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
  "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
}

  dryRun: boolean, Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

Returns:
  An object of the form:

    { # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
    "countrySettings": [ # The LIA settings for each country.
      {
        "about": { # The settings for the About page.
          "status": "A String", # The status of the verification process for the About page.
          "url": "A String", # The URL for the About page.
        },
        "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
        "onDisplayToOrder": { # LIA "On Display To Order" settings.
          "status": "A String", # The status of the ?On display to order? feature.
          "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
        },
        "country": "A String", # CLDR country code (e.g. "US").
        "storePickupActive": True or False, # The status of the "Store pickup" feature.
        "posDataProvider": { # The POS data provider linked with this country.
          "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
          "posDataProviderId": "A String", # The ID of the POS data provider.
        },
        "inventory": { # LIA inventory verification settings.
          "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
          "status": "A String", # The status of the inventory verification process.
          "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
          "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
        },
      },
    ],
    "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
    "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
  }</pre>
</div>

<div class="method">
    <code class="details" id="requestgmbaccess">requestgmbaccess(merchantId, accountId, gmbEmail)</code>
  <pre>Requests access to a specified Google My Business account.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account for which GMB access is requested. (required)
  gmbEmail: string, The email of the Google My Business account. (required)

Returns:
  An object of the form:

    {
    "kind": "content#liasettingsRequestGmbAccessResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsRequestGmbAccessResponse".
  }</pre>
</div>

<div class="method">
    <code class="details" id="requestinventoryverification">requestinventoryverification(merchantId, accountId, country)</code>
  <pre>Requests inventory validation for the specified country.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account that manages the order. This cannot be a multi-client account. (required)
  country: string, The country for which inventory validation is requested. (required)

Returns:
  An object of the form:

    {
    "kind": "content#liasettingsRequestInventoryVerificationResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsRequestInventoryVerificationResponse".
  }</pre>
</div>

<div class="method">
    <code class="details" id="setinventoryverificationcontact">setinventoryverificationcontact(merchantId, accountId, contactEmail, contactName, country, language)</code>
  <pre>Sets the inventory verification contract for the specified country.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account that manages the order. This cannot be a multi-client account. (required)
  contactEmail: string, The email of the inventory verification contact. (required)
  contactName: string, The name of the inventory verification contact. (required)
  country: string, The country for which inventory verification is requested. (required)
  language: string, The language for which inventory verification is requested. (required)

Returns:
  An object of the form:

    {
    "kind": "content#liasettingsSetInventoryVerificationContactResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsSetInventoryVerificationContactResponse".
  }</pre>
</div>

<div class="method">
    <code class="details" id="setposdataprovider">setposdataprovider(merchantId, accountId, country, posDataProviderId=None, posExternalAccountId=None)</code>
  <pre>Sets the POS data provider for the specified country.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account for which to retrieve accessible Google My Business accounts. (required)
  country: string, The country for which the POS data provider is selected. (required)
  posDataProviderId: string, The ID of POS data provider.
  posExternalAccountId: string, The account ID by which this merchant is known to the POS data provider.

Returns:
  An object of the form:

    {
    "kind": "content#liasettingsSetPosDataProviderResponse", # Identifies what kind of resource this is. Value: the fixed string "content#liasettingsSetPosDataProviderResponse".
  }</pre>
</div>

<div class="method">
    <code class="details" id="update">update(merchantId, accountId, body, dryRun=None)</code>
  <pre>Updates the LIA settings of the account.

Args:
  merchantId: string, The ID of the managing account. If this parameter is not the same as accountId, then this account must be a multi-client account and accountId must be the ID of a sub-account of this account. (required)
  accountId: string, The ID of the account for which to get or update LIA settings. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
  "countrySettings": [ # The LIA settings for each country.
    {
      "about": { # The settings for the About page.
        "status": "A String", # The status of the verification process for the About page.
        "url": "A String", # The URL for the About page.
      },
      "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
      "onDisplayToOrder": { # LIA "On Display To Order" settings.
        "status": "A String", # The status of the ?On display to order? feature.
        "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
      },
      "country": "A String", # CLDR country code (e.g. "US").
      "storePickupActive": True or False, # The status of the "Store pickup" feature.
      "posDataProvider": { # The POS data provider linked with this country.
        "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
        "posDataProviderId": "A String", # The ID of the POS data provider.
      },
      "inventory": { # LIA inventory verification settings.
        "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
        "status": "A String", # The status of the inventory verification process.
        "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
        "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
      },
    },
  ],
  "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
  "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
}

  dryRun: boolean, Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

Returns:
  An object of the form:

    { # Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
    "countrySettings": [ # The LIA settings for each country.
      {
        "about": { # The settings for the About page.
          "status": "A String", # The status of the verification process for the About page.
          "url": "A String", # The URL for the About page.
        },
        "hostedLocalStorefrontActive": True or False, # The status of the "Merchant hosted local storefront" feature.
        "onDisplayToOrder": { # LIA "On Display To Order" settings.
          "status": "A String", # The status of the ?On display to order? feature.
          "shippingCostPolicyUrl": "A String", # Shipping cost and policy URL.
        },
        "country": "A String", # CLDR country code (e.g. "US").
        "storePickupActive": True or False, # The status of the "Store pickup" feature.
        "posDataProvider": { # The POS data provider linked with this country.
          "posExternalAccountId": "A String", # The account ID by which this merchant is known to the POS data provider.
          "posDataProviderId": "A String", # The ID of the POS data provider.
        },
        "inventory": { # LIA inventory verification settings.
          "inventoryVerificationContactEmail": "A String", # The email of the contact for the inventory verification process.
          "status": "A String", # The status of the inventory verification process.
          "inventoryVerificationContactStatus": "A String", # The status of the verification contact.
          "inventoryVerificationContactName": "A String", # The name of the contact for the inventory verification process.
        },
      },
    ],
    "kind": "content#liaSettings", # Identifies what kind of resource this is. Value: the fixed string "content#liaSettings".
    "accountId": "A String", # The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
  }</pre>
</div>

</body></html>