/// <reference types="node" />
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace content_v2_1 {
    export interface Options extends GlobalOptions {
        version: 'v2.1';
    }
    interface StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
        /**
         * V1 error format.
         */
        '$.xgafv'?: string;
        /**
         * OAuth access token.
         */
        access_token?: string;
        /**
         * Data format for response.
         */
        alt?: string;
        /**
         * JSONP
         */
        callback?: string;
        /**
         * Selector specifying which fields to include in a partial response.
         */
        fields?: string;
        /**
         * API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
         */
        key?: string;
        /**
         * OAuth 2.0 token for the current user.
         */
        oauth_token?: string;
        /**
         * Returns response with indentations and line breaks.
         */
        prettyPrint?: boolean;
        /**
         * Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
         */
        quotaUser?: string;
        /**
         * Legacy upload protocol for media (e.g. "media", "multipart").
         */
        uploadType?: string;
        /**
         * Upload protocol for media (e.g. "raw", "multipart").
         */
        upload_protocol?: string;
    }
    /**
     * Content API for Shopping
     *
     * Manage your product listings and accounts for Google Shopping
     *
     * @example
     * ```js
     * const {google} = require('googleapis');
     * const content = google.content('v2.1');
     * ```
     */
    export class Content {
        context: APIRequestContext;
        accounts: Resource$Accounts;
        accountstatuses: Resource$Accountstatuses;
        accounttax: Resource$Accounttax;
        buyongoogleprograms: Resource$Buyongoogleprograms;
        collections: Resource$Collections;
        collectionstatuses: Resource$Collectionstatuses;
        csses: Resource$Csses;
        datafeeds: Resource$Datafeeds;
        datafeedstatuses: Resource$Datafeedstatuses;
        liasettings: Resource$Liasettings;
        localinventory: Resource$Localinventory;
        orderinvoices: Resource$Orderinvoices;
        orderreports: Resource$Orderreports;
        orderreturns: Resource$Orderreturns;
        orders: Resource$Orders;
        ordertrackingsignals: Resource$Ordertrackingsignals;
        pos: Resource$Pos;
        products: Resource$Products;
        productstatuses: Resource$Productstatuses;
        pubsubnotificationsettings: Resource$Pubsubnotificationsettings;
        regionalinventory: Resource$Regionalinventory;
        regions: Resource$Regions;
        reports: Resource$Reports;
        repricingrules: Resource$Repricingrules;
        returnaddress: Resource$Returnaddress;
        returnpolicy: Resource$Returnpolicy;
        returnpolicyonline: Resource$Returnpolicyonline;
        settlementreports: Resource$Settlementreports;
        settlementtransactions: Resource$Settlementtransactions;
        shippingsettings: Resource$Shippingsettings;
        constructor(options: GlobalOptions, google?: GoogleConfigurable);
    }
    /**
     * Account data. After the creation of a new account it may take a few minutes before it is fully operational. The methods delete, insert, and update require the admin role.
     */
    export interface Schema$Account {
        /**
         * Linked Ads accounts that are active or pending approval. To create a new link request, add a new link with status `active` to the list. It will remain in a `pending` state until approved or rejected either in the Ads interface or through the AdWords API. To delete an active link, or to cancel a link request, remove it from the list.
         */
        adsLinks?: Schema$AccountAdsLink[];
        /**
         * Indicates whether the merchant sells adult content.
         */
        adultContent?: boolean | null;
        /**
         * Automatically created label IDs that are assigned to the account by CSS Center.
         */
        automaticLabelIds?: string[] | null;
        /**
         * The business information of the account.
         */
        businessInformation?: Schema$AccountBusinessInformation;
        /**
         * ID of CSS the account belongs to.
         */
        cssId?: string | null;
        /**
         * The GMB account which is linked or in the process of being linked with the Merchant Center account.
         */
        googleMyBusinessLink?: Schema$AccountGoogleMyBusinessLink;
        /**
         * Required for update. Merchant Center account ID.
         */
        id?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#account`"
         */
        kind?: string | null;
        /**
         * Manually created label IDs that are assigned to the account by CSS.
         */
        labelIds?: string[] | null;
        /**
         * Required. Display name for the account.
         */
        name?: string | null;
        /**
         * Client-specific, locally-unique, internal ID for the child account.
         */
        sellerId?: string | null;
        /**
         * Users with access to the account. Every account (except for subaccounts) must have at least one admin user.
         */
        users?: Schema$AccountUser[];
        /**
         * The merchant's website.
         */
        websiteUrl?: string | null;
        /**
         * Linked YouTube channels that are active or pending approval. To create a new link request, add a new link with status `active` to the list. It will remain in a `pending` state until approved or rejected in the YT Creator Studio interface. To delete an active link, or to cancel a link request, remove it from the list.
         */
        youtubeChannelLinks?: Schema$AccountYouTubeChannelLink[];
    }
    export interface Schema$AccountAddress {
        /**
         * CLDR country code (e.g. "US"). This value cannot be set for a sub-account of an MCA. All MCA sub-accounts inherit the country of their parent MCA.
         */
        country?: string | null;
        /**
         * City, town or commune. May also include dependent localities or sublocalities (e.g. neighborhoods or suburbs).
         */
        locality?: string | null;
        /**
         * Postal code or ZIP (e.g. "94043").
         */
        postalCode?: string | null;
        /**
         * Top-level administrative subdivision of the country. For example, a state like California ("CA") or a province like Quebec ("QC").
         */
        region?: string | null;
        /**
         * Street-level part of the address.
         */
        streetAddress?: string | null;
    }
    export interface Schema$AccountAdsLink {
        /**
         * Customer ID of the Ads account.
         */
        adsId?: string | null;
        /**
         * Status of the link between this Merchant Center account and the Ads account. Upon retrieval, it represents the actual status of the link and can be either `active` if it was approved in Google Ads or `pending` if it's pending approval. Upon insertion, it represents the *intended* status of the link. Re-uploading a link with status `active` when it's still pending or with status `pending` when it's already active will have no effect: the status will remain unchanged. Re-uploading a link with deprecated status `inactive` is equivalent to not submitting the link at all and will delete the link if it was active or cancel the link request if it was pending. Acceptable values are: - "`active`" - "`pending`"
         */
        status?: string | null;
    }
    export interface Schema$AccountBusinessInformation {
        /**
         * The address of the business.
         */
        address?: Schema$AccountAddress;
        /**
         * The customer service information of the business.
         */
        customerService?: Schema$AccountCustomerService;
        /**
         * The phone number of the business.
         */
        phoneNumber?: string | null;
    }
    /**
     * Credentials allowing Google to call a partner's API on behalf of a merchant.
     */
    export interface Schema$AccountCredentials {
        /**
         * An OAuth access token.
         */
        accessToken?: string | null;
        /**
         * The amount of time, in seconds, after which the access token is no longer valid.
         */
        expiresIn?: string | null;
        /**
         * Indicates to Google how Google should use these OAuth tokens.
         */
        purpose?: string | null;
    }
    export interface Schema$AccountCustomerService {
        /**
         * Customer service email.
         */
        email?: string | null;
        /**
         * Customer service phone number.
         */
        phoneNumber?: string | null;
        /**
         * Customer service URL.
         */
        url?: string | null;
    }
    export interface Schema$AccountGoogleMyBusinessLink {
        /**
         * The ID of the GMB account. If this is provided, then `gmbEmail` is ignored. The value of this field should match the `accountId` used by the GMB API.
         */
        gmbAccountId?: string | null;
        /**
         * The GMB email address of which a specific account within a GMB account. A sample account within a GMB account could be a business account with set of locations, managed under the GMB account.
         */
        gmbEmail?: string | null;
        /**
         * Status of the link between this Merchant Center account and the GMB account. Acceptable values are: - "`active`" - "`pending`"
         */
        status?: string | null;
    }
    export interface Schema$AccountIdentifier {
        /**
         * The aggregator ID, set for aggregators and subaccounts (in that case, it represents the aggregator of the subaccount).
         */
        aggregatorId?: string | null;
        /**
         * The merchant account ID, set for individual accounts and subaccounts.
         */
        merchantId?: string | null;
    }
    /**
     * Label assigned by CSS domain or CSS group to one of its sub-accounts.
     */
    export interface Schema$AccountLabel {
        /**
         * Immutable. The ID of account this label belongs to.
         */
        accountId?: string | null;
        /**
         * The description of this label.
         */
        description?: string | null;
        /**
         * Output only. The ID of the label.
         */
        labelId?: string | null;
        /**
         * Output only. The type of this label.
         */
        labelType?: string | null;
        /**
         * The display name of this label.
         */
        name?: string | null;
    }
    /**
     *  The return carrier information. This service is designed for merchants enrolled in the Buy on Google program.
     */
    export interface Schema$AccountReturnCarrier {
        /**
         * Output only. Immutable. The Google-provided unique carrier ID, used to update the resource.
         */
        carrierAccountId?: string | null;
        /**
         * Name of the carrier account.
         */
        carrierAccountName?: string | null;
        /**
         * Number of the carrier account.
         */
        carrierAccountNumber?: string | null;
        /**
         * The carrier code enum. Accepts the values FEDEX or UPS.
         */
        carrierCode?: string | null;
    }
    export interface Schema$AccountsAuthInfoResponse {
        /**
         * The account identifiers corresponding to the authenticated user. - For an individual account: only the merchant ID is defined - For an aggregator: only the aggregator ID is defined - For a subaccount of an MCA: both the merchant ID and the aggregator ID are defined.
         */
        accountIdentifiers?: Schema$AccountIdentifier[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsAuthInfoResponse".
         */
        kind?: string | null;
    }
    export interface Schema$AccountsClaimWebsiteResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsClaimWebsiteResponse".
         */
        kind?: string | null;
    }
    export interface Schema$AccountsCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$AccountsCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch accounts request.
     */
    export interface Schema$AccountsCustomBatchRequestEntry {
        /**
         * The account to create or update. Only defined if the method is `insert` or `update`.
         */
        account?: Schema$Account;
        /**
         * The ID of the targeted account. Only defined if the method is not `insert`.
         */
        accountId?: string | null;
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * Whether the account should be deleted if the account has offers. Only applicable if the method is `delete`.
         */
        force?: boolean | null;
        /**
         * Label IDs for the 'updatelabels' request.
         */
        labelIds?: string[] | null;
        /**
         * Details about the `link` request.
         */
        linkRequest?: Schema$AccountsCustomBatchRequestEntryLinkRequest;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`claimWebsite`" - "`delete`" - "`get`" - "`insert`" - "`link`" - "`update`"
         */
        method?: string | null;
        /**
         * Only applicable if the method is `claimwebsite`. Indicates whether or not to take the claim from another account in case there is a conflict.
         */
        overwrite?: boolean | null;
        /**
         * Controls which fields are visible. Only applicable if the method is 'get'.
         */
        view?: string | null;
    }
    export interface Schema$AccountsCustomBatchRequestEntryLinkRequest {
        /**
         * Action to perform for this link. The `"request"` action is only available to select merchants. Acceptable values are: - "`approve`" - "`remove`" - "`request`"
         */
        action?: string | null;
        /**
         * The ID of the linked account.
         */
        linkedAccountId?: string | null;
        /**
         * Type of the link between the two accounts. Acceptable values are: - "`channelPartner`" - "`eCommercePlatform`" - "`paymentServiceProvider`"
         */
        linkType?: string | null;
        /**
         * Provided services. Acceptable values are: - "`shoppingAdsProductManagement`" - "`shoppingActionsProductManagement`" - "`shoppingActionsOrderManagement`" - "`paymentProcessing`"
         */
        services?: string[] | null;
    }
    export interface Schema$AccountsCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$AccountsCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch accounts response.
     */
    export interface Schema$AccountsCustomBatchResponseEntry {
        /**
         * The retrieved, created, or updated account. Not defined if the method was `delete`, `claimwebsite` or `link`.
         */
        account?: Schema$Account;
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#accountsCustomBatchResponseEntry`"
         */
        kind?: string | null;
    }
    export interface Schema$AccountsLinkRequest {
        /**
         * Action to perform for this link. The `"request"` action is only available to select merchants. Acceptable values are: - "`approve`" - "`remove`" - "`request`"
         */
        action?: string | null;
        /**
         * The ID of the linked account.
         */
        linkedAccountId?: string | null;
        /**
         * Type of the link between the two accounts. Acceptable values are: - "`channelPartner`" - "`eCommercePlatform`" - "`paymentServiceProvider`"
         */
        linkType?: string | null;
        /**
         * Additional information required for `paymentServiceProvider` link type.
         */
        paymentServiceProviderLinkInfo?: Schema$PaymentServiceProviderLinkInfo;
        /**
         *  Acceptable values are: - "`shoppingAdsProductManagement`" - "`shoppingActionsProductManagement`" - "`shoppingActionsOrderManagement`" - "`paymentProcessing`"
         */
        services?: string[] | null;
    }
    export interface Schema$AccountsLinkResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsLinkResponse".
         */
        kind?: string | null;
    }
    export interface Schema$AccountsListLinksResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsListLinksResponse".
         */
        kind?: string | null;
        /**
         * The list of available links.
         */
        links?: Schema$LinkedAccount[];
        /**
         * The token for the retrieval of the next page of links.
         */
        nextPageToken?: string | null;
    }
    export interface Schema$AccountsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of accounts.
         */
        nextPageToken?: string | null;
        resources?: Schema$Account[];
    }
    /**
     * The status of an account, i.e., information about its products, which is computed offline and not returned immediately at insertion time.
     */
    export interface Schema$AccountStatus {
        /**
         * The ID of the account for which the status is reported.
         */
        accountId?: string | null;
        /**
         * A list of account level issues.
         */
        accountLevelIssues?: Schema$AccountStatusAccountLevelIssue[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#accountStatus`"
         */
        kind?: string | null;
        /**
         * List of product-related data by channel, destination, and country. Data in this field may be delayed by up to 30 minutes.
         */
        products?: Schema$AccountStatusProducts[];
        /**
         * Whether the account's website is claimed or not.
         */
        websiteClaimed?: boolean | null;
    }
    export interface Schema$AccountStatusAccountLevelIssue {
        /**
         * Country for which this issue is reported.
         */
        country?: string | null;
        /**
         * The destination the issue applies to. If this field is empty then the issue applies to all available destinations.
         */
        destination?: string | null;
        /**
         * Additional details about the issue.
         */
        detail?: string | null;
        /**
         * The URL of a web page to help resolving this issue.
         */
        documentation?: string | null;
        /**
         * Issue identifier.
         */
        id?: string | null;
        /**
         * Severity of the issue. Acceptable values are: - "`critical`" - "`error`" - "`suggestion`"
         */
        severity?: string | null;
        /**
         * Short description of the issue.
         */
        title?: string | null;
    }
    export interface Schema$AccountstatusesCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$AccountstatusesCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch accountstatuses request.
     */
    export interface Schema$AccountstatusesCustomBatchRequestEntry {
        /**
         * The ID of the (sub-)account whose status to get.
         */
        accountId?: string | null;
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         */
        destinations?: string[] | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`get`"
         */
        method?: string | null;
    }
    export interface Schema$AccountstatusesCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$AccountstatusesCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountstatusesCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch accountstatuses response.
     */
    export interface Schema$AccountstatusesCustomBatchResponseEntry {
        /**
         * The requested account status. Defined if and only if the request was successful.
         */
        accountStatus?: Schema$AccountStatus;
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
    }
    export interface Schema$AccountstatusesListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountstatusesListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of account statuses.
         */
        nextPageToken?: string | null;
        resources?: Schema$AccountStatus[];
    }
    export interface Schema$AccountStatusItemLevelIssue {
        /**
         * The attribute's name, if the issue is caused by a single attribute.
         */
        attributeName?: string | null;
        /**
         * The error code of the issue.
         */
        code?: string | null;
        /**
         * A short issue description in English.
         */
        description?: string | null;
        /**
         * A detailed issue description in English.
         */
        detail?: string | null;
        /**
         * The URL of a web page to help with resolving this issue.
         */
        documentation?: string | null;
        /**
         * Number of items with this issue.
         */
        numItems?: string | null;
        /**
         * Whether the issue can be resolved by the merchant.
         */
        resolution?: string | null;
        /**
         * How this issue affects serving of the offer.
         */
        servability?: string | null;
    }
    export interface Schema$AccountStatusProducts {
        /**
         * The channel the data applies to. Acceptable values are: - "`local`" - "`online`"
         */
        channel?: string | null;
        /**
         * The country the data applies to.
         */
        country?: string | null;
        /**
         * The destination the data applies to.
         */
        destination?: string | null;
        /**
         * List of item-level issues.
         */
        itemLevelIssues?: Schema$AccountStatusItemLevelIssue[];
        /**
         * Aggregated product statistics.
         */
        statistics?: Schema$AccountStatusStatistics;
    }
    export interface Schema$AccountStatusStatistics {
        /**
         * Number of active offers.
         */
        active?: string | null;
        /**
         * Number of disapproved offers.
         */
        disapproved?: string | null;
        /**
         * Number of expiring offers.
         */
        expiring?: string | null;
        /**
         * Number of pending offers.
         */
        pending?: string | null;
    }
    export interface Schema$AccountsUpdateLabelsRequest {
        /**
         * The IDs of labels that should be assigned to the account.
         */
        labelIds?: string[] | null;
    }
    export interface Schema$AccountsUpdateLabelsResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountsUpdateLabelsResponse".
         */
        kind?: string | null;
    }
    /**
     * The tax settings of a merchant account. All methods require the admin role.
     */
    export interface Schema$AccountTax {
        /**
         * Required. The ID of the account to which these account tax settings belong.
         */
        accountId?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accountTax".
         */
        kind?: string | null;
        /**
         * Tax rules. Updating the tax rules will enable US taxes (not reversible). Defining no rules is equivalent to not charging tax at all.
         */
        rules?: Schema$AccountTaxTaxRule[];
    }
    export interface Schema$AccounttaxCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$AccounttaxCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch accounttax request.
     */
    export interface Schema$AccounttaxCustomBatchRequestEntry {
        /**
         * The ID of the account for which to get/update account tax settings.
         */
        accountId?: string | null;
        /**
         * The account tax settings to update. Only defined if the method is `update`.
         */
        accountTax?: Schema$AccountTax;
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`get`" - "`update`"
         */
        method?: string | null;
    }
    export interface Schema$AccounttaxCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$AccounttaxCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accounttaxCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch accounttax response.
     */
    export interface Schema$AccounttaxCustomBatchResponseEntry {
        /**
         * The retrieved or updated account tax settings.
         */
        accountTax?: Schema$AccountTax;
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#accounttaxCustomBatchResponseEntry`"
         */
        kind?: string | null;
    }
    export interface Schema$AccounttaxListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#accounttaxListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of account tax settings.
         */
        nextPageToken?: string | null;
        resources?: Schema$AccountTax[];
    }
    /**
     * Tax calculation rule to apply in a state or province (USA only).
     */
    export interface Schema$AccountTaxTaxRule {
        /**
         * Country code in which tax is applicable.
         */
        country?: string | null;
        /**
         * Required. State (or province) is which the tax is applicable, described by its location ID (also called criteria ID).
         */
        locationId?: string | null;
        /**
         * Explicit tax rate in percent, represented as a floating point number without the percentage character. Must not be negative.
         */
        ratePercent?: string | null;
        /**
         * If true, shipping charges are also taxed.
         */
        shippingTaxed?: boolean | null;
        /**
         * Whether the tax rate is taken from a global tax table or specified explicitly.
         */
        useGlobalRate?: boolean | null;
    }
    export interface Schema$AccountUser {
        /**
         * Whether user is an admin.
         */
        admin?: boolean | null;
        /**
         * User's email address.
         */
        emailAddress?: string | null;
        /**
         * Whether user is an order manager.
         */
        orderManager?: boolean | null;
        /**
         * Whether user can access payment statements.
         */
        paymentsAnalyst?: boolean | null;
        /**
         * Whether user can manage payment settings.
         */
        paymentsManager?: boolean | null;
    }
    export interface Schema$AccountYouTubeChannelLink {
        /**
         * Channel ID.
         */
        channelId?: string | null;
        /**
         * Status of the link between this Merchant Center account and the YouTube channel. Upon retrieval, it represents the actual status of the link and can be either `active` if it was approved in YT Creator Studio or `pending` if it's pending approval. Upon insertion, it represents the *intended* status of the link. Re-uploading a link with status `active` when it's still pending or with status `pending` when it's already active will have no effect: the status will remain unchanged. Re-uploading a link with deprecated status `inactive` is equivalent to not submitting the link at all and will delete the link if it was active or cancel the link request if it was pending.
         */
        status?: string | null;
    }
    /**
     * Request message for the ActivateProgram method.
     */
    export interface Schema$ActivateBuyOnGoogleProgramRequest {
    }
    export interface Schema$Amount {
        /**
         * [required] The pre-tax or post-tax price depending on the location of the order.
         */
        priceAmount?: Schema$Price;
        /**
         * [required] Tax value.
         */
        taxAmount?: Schema$Price;
    }
    export interface Schema$BusinessDayConfig {
        /**
         * Regular business days. May not be empty.
         */
        businessDays?: string[] | null;
    }
    /**
     * Response message for the GetProgramStatus method.
     */
    export interface Schema$BuyOnGoogleProgramStatus {
        /**
         * The customer service pending email.
         */
        customerServicePendingEmail?: string | null;
        /**
         * The customer service verified email.
         */
        customerServiceVerifiedEmail?: string | null;
        /**
         * The current participation stage for the program.
         */
        participationStage?: string | null;
    }
    export interface Schema$CarrierRate {
        /**
         * Carrier service, such as `"UPS"` or `"Fedex"`. The list of supported carriers can be retrieved via the `getSupportedCarriers` method. Required.
         */
        carrierName?: string | null;
        /**
         * Carrier service, such as `"ground"` or `"2 days"`. The list of supported services for a carrier can be retrieved via the `getSupportedCarriers` method. Required.
         */
        carrierService?: string | null;
        /**
         * Additive shipping rate modifier. Can be negative. For example `{ "value": "1", "currency" : "USD" \}` adds $1 to the rate, `{ "value": "-3", "currency" : "USD" \}` removes $3 from the rate. Optional.
         */
        flatAdjustment?: Schema$Price;
        /**
         * Name of the carrier rate. Must be unique per rate group. Required.
         */
        name?: string | null;
        /**
         * Shipping origin for this carrier rate. Required.
         */
        originPostalCode?: string | null;
        /**
         * Multiplicative shipping rate modifier as a number in decimal notation. Can be negative. For example `"5.4"` increases the rate by 5.4%, `"-3"` decreases the rate by 3%. Optional.
         */
        percentageAdjustment?: string | null;
    }
    export interface Schema$CarriersCarrier {
        /**
         * The CLDR country code of the carrier (e.g., "US"). Always present.
         */
        country?: string | null;
        /**
         * A list of services supported for EDD (Estimated Delivery Date) calculation. This is the list of valid values for WarehouseBasedDeliveryTime.carrierService.
         */
        eddServices?: string[] | null;
        /**
         * The name of the carrier (e.g., `"UPS"`). Always present.
         */
        name?: string | null;
        /**
         * A list of supported services (e.g., `"ground"`) for that carrier. Contains at least one service. This is the list of valid values for CarrierRate.carrierService.
         */
        services?: string[] | null;
    }
    /**
     * The collection message.
     */
    export interface Schema$Collection {
        /**
         * Label that you assign to a collection to help organize bidding and reporting in Shopping campaigns. [Custom label](https://support.google.com/merchants/answer/9674217)
         */
        customLabel0?: string | null;
        /**
         * Label that you assign to a collection to help organize bidding and reporting in Shopping campaigns.
         */
        customLabel1?: string | null;
        /**
         * Label that you assign to a collection to help organize bidding and reporting in Shopping campaigns.
         */
        customLabel2?: string | null;
        /**
         * Label that you assign to a collection to help organize bidding and reporting in Shopping campaigns.
         */
        customLabel3?: string | null;
        /**
         * Label that you assign to a collection to help organize bidding and reporting in Shopping campaigns.
         */
        customLabel4?: string | null;
        /**
         * This identifies one or more products associated with the collection. Used as a lookup to the corresponding product ID in your product feeds. Provide a maximum of 100 featuredProduct (for collections). Provide up to 10 featuredProduct (for Shoppable Images only) with ID and X and Y coordinates. [featured_product attribute](https://support.google.com/merchants/answer/9703736)
         */
        featuredProduct?: Schema$CollectionFeaturedProduct[];
        /**
         * Your collection's name. [headline attribute](https://support.google.com/merchants/answer/9673580)
         */
        headline?: string[] | null;
        /**
         * Required. The REST ID of the collection. Content API methods that operate on collections take this as their collectionId parameter. The REST ID for a collection is of the form collectionId. [id attribute](https://support.google.com/merchants/answer/9649290)
         */
        id?: string | null;
        /**
         * The URL of a collection’s image. [image_link attribute](https://support.google.com/merchants/answer/9703236)
         */
        imageLink?: string[] | null;
        /**
         * The language of a collection and the language of any featured products linked to the collection. [language attribute](https://support.google.com/merchants/answer/9673781)
         */
        language?: string | null;
        /**
         * A collection’s landing page. URL directly linking to your collection's page on your website. [link attribute](https://support.google.com/merchants/answer/9673983)
         */
        link?: string | null;
        /**
         * A collection’s mobile-optimized landing page when you have a different URL for mobile and desktop traffic. [mobile_link attribute](https://support.google.com/merchants/answer/9646123)
         */
        mobileLink?: string | null;
        /**
         * [product_country attribute](https://support.google.com/merchants/answer/9674155)
         */
        productCountry?: string | null;
    }
    /**
     * The message for FeaturedProduct. [FeaturedProduct](https://support.google.com/merchants/answer/9703736)
     */
    export interface Schema$CollectionFeaturedProduct {
        /**
         * The unique identifier for the product item.
         */
        offerId?: string | null;
        /**
         * Required. X-coordinate of the product callout on the Shoppable Image.
         */
        x?: number | null;
        /**
         * Required. Y-coordinate of the product callout on the Shoppable Image.
         */
        y?: number | null;
    }
    /**
     * The collectionstatus message.
     */
    export interface Schema$CollectionStatus {
        /**
         * A list of all issues associated with the collection.
         */
        collectionLevelIssuses?: Schema$CollectionStatusItemLevelIssue[];
        /**
         * Date on which the collection has been created in [ISO 8601](http://en.wikipedia.org/wiki/ISO_8601) format: Date, time, and offset, e.g. "2020-01-02T09:00:00+01:00" or "2020-01-02T09:00:00Z"
         */
        creationDate?: string | null;
        /**
         * The intended destinations for the collection.
         */
        destinationStatuses?: Schema$CollectionStatusDestinationStatus[];
        /**
         * Required. The ID of the collection for which status is reported.
         */
        id?: string | null;
        /**
         * Date on which the collection has been last updated in [ISO 8601](http://en.wikipedia.org/wiki/ISO_8601) format: Date, time, and offset, e.g. "2020-01-02T09:00:00+01:00" or "2020-01-02T09:00:00Z"
         */
        lastUpdateDate?: string | null;
    }
    /**
     * Destination status message.
     */
    export interface Schema$CollectionStatusDestinationStatus {
        /**
         * The name of the destination
         */
        destination?: string | null;
        /**
         * The status for the specified destination.
         */
        status?: string | null;
    }
    /**
     * Issue associated with the collection.
     */
    export interface Schema$CollectionStatusItemLevelIssue {
        /**
         * The attribute's name, if the issue is caused by a single attribute.
         */
        attributeName?: string | null;
        /**
         * The error code of the issue.
         */
        code?: string | null;
        /**
         * A short issue description in English.
         */
        description?: string | null;
        /**
         * The destination the issue applies to.
         */
        destination?: string | null;
        /**
         * A detailed issue description in English.
         */
        detail?: string | null;
        /**
         * The URL of a web page to help with resolving this issue.
         */
        documentation?: string | null;
        /**
         * Whether the issue can be resolved by the merchant.
         */
        resolution?: string | null;
        /**
         * How this issue affects the serving of the collection.
         */
        servability?: string | null;
    }
    /**
     * Information about CSS domain.
     */
    export interface Schema$Css {
        /**
         * Output only. Immutable. The CSS domain ID.
         */
        cssDomainId?: string | null;
        /**
         * Output only. Immutable. The ID of the CSS group this CSS domain is affiliated with. Only populated for CSS group users.
         */
        cssGroupId?: string | null;
        /**
         * Output only. Immutable. The CSS domain's display name, used when space is constrained.
         */
        displayName?: string | null;
        /**
         * Output only. Immutable. The CSS domain's full name.
         */
        fullName?: string | null;
        /**
         * Output only. Immutable. The CSS domain's homepage.
         */
        homepageUri?: string | null;
        /**
         * A list of label IDs that are assigned to this CSS domain by its CSS group. Only populated for CSS group users.
         */
        labelIds?: string[] | null;
    }
    export interface Schema$CustomAttribute {
        /**
         * Subattributes within this attribute group. Exactly one of value or groupValues must be provided.
         */
        groupValues?: Schema$CustomAttribute[];
        /**
         * The name of the attribute. Underscores will be replaced by spaces upon insertion.
         */
        name?: string | null;
        /**
         * The value of the attribute.
         */
        value?: string | null;
    }
    export interface Schema$CustomerReturnReason {
        /**
         * Description of the reason.
         */
        description?: string | null;
        /**
         * Code of the return reason. Acceptable values are: - "`betterPriceFound`" - "`changedMind`" - "`damagedOrDefectiveItem`" - "`didNotMatchDescription`" - "`doesNotFit`" - "`expiredItem`" - "`incorrectItemReceived`" - "`noLongerNeeded`" - "`notSpecified`" - "`orderedWrongItem`" - "`other`" - "`qualityNotExpected`" - "`receivedTooLate`" - "`undeliverable`"
         */
        reasonCode?: string | null;
    }
    export interface Schema$CutoffTime {
        /**
         * Hour of the cutoff time until which an order has to be placed to be processed in the same day. Required.
         */
        hour?: number | null;
        /**
         * Minute of the cutoff time until which an order has to be placed to be processed in the same day. Required.
         */
        minute?: number | null;
        /**
         * Timezone identifier for the cutoff time. A list of identifiers can be found in the AdWords API documentation. E.g. "Europe/Zurich". Required.
         */
        timezone?: string | null;
    }
    /**
     * Datafeed configuration data.
     */
    export interface Schema$Datafeed {
        /**
         * The two-letter ISO 639-1 language in which the attributes are defined in the data feed.
         */
        attributeLanguage?: string | null;
        /**
         * Required. The type of data feed. For product inventory feeds, only feeds for local stores, not online stores, are supported. Acceptable values are: - "`local products`" - "`product inventory`" - "`products`"
         */
        contentType?: string | null;
        /**
         * Fetch schedule for the feed file.
         */
        fetchSchedule?: Schema$DatafeedFetchSchedule;
        /**
         * Required. The filename of the feed. All feeds must have a unique file name.
         */
        fileName?: string | null;
        /**
         * Format of the feed file.
         */
        format?: Schema$DatafeedFormat;
        /**
         * Required for update. The ID of the data feed.
         */
        id?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#datafeed`"
         */
        kind?: string | null;
        /**
         * Required for insert. A descriptive name of the data feed.
         */
        name?: string | null;
        /**
         * The targets this feed should apply to (country, language, destinations).
         */
        targets?: Schema$DatafeedTarget[];
    }
    /**
     * The required fields vary based on the frequency of fetching. For a monthly fetch schedule, day_of_month and hour are required. For a weekly fetch schedule, weekday and hour are required. For a daily fetch schedule, only hour is required.
     */
    export interface Schema$DatafeedFetchSchedule {
        /**
         * The day of the month the feed file should be fetched (1-31).
         */
        dayOfMonth?: number | null;
        /**
         * The URL where the feed file can be fetched. Google Merchant Center will support automatic scheduled uploads using the HTTP, HTTPS, FTP, or SFTP protocols, so the value will need to be a valid link using one of those four protocols.
         */
        fetchUrl?: string | null;
        /**
         * The hour of the day the feed file should be fetched (0-23).
         */
        hour?: number | null;
        /**
         * The minute of the hour the feed file should be fetched (0-59). Read-only.
         */
        minuteOfHour?: number | null;
        /**
         * An optional password for fetch_url.
         */
        password?: string | null;
        /**
         * Whether the scheduled fetch is paused or not.
         */
        paused?: boolean | null;
        /**
         * Time zone used for schedule. UTC by default. E.g., "America/Los_Angeles".
         */
        timeZone?: string | null;
        /**
         * An optional user name for fetch_url.
         */
        username?: string | null;
        /**
         * The day of the week the feed file should be fetched. Acceptable values are: - "`monday`" - "`tuesday`" - "`wednesday`" - "`thursday`" - "`friday`" - "`saturday`" - "`sunday`"
         */
        weekday?: string | null;
    }
    export interface Schema$DatafeedFormat {
        /**
         * Delimiter for the separation of values in a delimiter-separated values feed. If not specified, the delimiter will be auto-detected. Ignored for non-DSV data feeds. Acceptable values are: - "`pipe`" - "`tab`" - "`tilde`"
         */
        columnDelimiter?: string | null;
        /**
         * Character encoding scheme of the data feed. If not specified, the encoding will be auto-detected. Acceptable values are: - "`latin-1`" - "`utf-16be`" - "`utf-16le`" - "`utf-8`" - "`windows-1252`"
         */
        fileEncoding?: string | null;
        /**
         * Specifies how double quotes are interpreted. If not specified, the mode will be auto-detected. Ignored for non-DSV data feeds. Acceptable values are: - "`normal character`" - "`value quoting`"
         */
        quotingMode?: string | null;
    }
    export interface Schema$DatafeedsCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$DatafeedsCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch datafeeds request.
     */
    export interface Schema$DatafeedsCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The data feed to insert.
         */
        datafeed?: Schema$Datafeed;
        /**
         * The ID of the data feed to get, delete or fetch.
         */
        datafeedId?: string | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`delete`" - "`fetchNow`" - "`get`" - "`insert`" - "`update`"
         */
        method?: string | null;
    }
    export interface Schema$DatafeedsCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$DatafeedsCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#datafeedsCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch datafeeds response.
     */
    export interface Schema$DatafeedsCustomBatchResponseEntry {
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * The requested data feed. Defined if and only if the request was successful.
         */
        datafeed?: Schema$Datafeed;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
    }
    export interface Schema$DatafeedsFetchNowResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#datafeedsFetchNowResponse".
         */
        kind?: string | null;
    }
    export interface Schema$DatafeedsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#datafeedsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of datafeeds.
         */
        nextPageToken?: string | null;
        resources?: Schema$Datafeed[];
    }
    /**
     * The status of a datafeed, i.e., the result of the last retrieval of the datafeed computed asynchronously when the feed processing is finished.
     */
    export interface Schema$DatafeedStatus {
        /**
         * The country for which the status is reported, represented as a CLDR territory code.
         */
        country?: string | null;
        /**
         * The ID of the feed for which the status is reported.
         */
        datafeedId?: string | null;
        /**
         * The list of errors occurring in the feed.
         */
        errors?: Schema$DatafeedStatusError[];
        /**
         * The number of items in the feed that were processed.
         */
        itemsTotal?: string | null;
        /**
         * The number of items in the feed that were valid.
         */
        itemsValid?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#datafeedStatus`"
         */
        kind?: string | null;
        /**
         * The two-letter ISO 639-1 language for which the status is reported.
         */
        language?: string | null;
        /**
         * The last date at which the feed was uploaded.
         */
        lastUploadDate?: string | null;
        /**
         * The processing status of the feed. Acceptable values are: - "`"`failure`": The feed could not be processed or all items had errors.`" - "`in progress`": The feed is being processed. - "`none`": The feed has not yet been processed. For example, a feed that has never been uploaded will have this processing status. - "`success`": The feed was processed successfully, though some items might have had errors.
         */
        processingStatus?: string | null;
        /**
         * The list of errors occurring in the feed.
         */
        warnings?: Schema$DatafeedStatusError[];
    }
    /**
     * An error occurring in the feed, like "invalid price".
     */
    export interface Schema$DatafeedStatusError {
        /**
         * The code of the error, e.g., "validation/invalid_value".
         */
        code?: string | null;
        /**
         * The number of occurrences of the error in the feed.
         */
        count?: string | null;
        /**
         * A list of example occurrences of the error, grouped by product.
         */
        examples?: Schema$DatafeedStatusExample[];
        /**
         * The error message, e.g., "Invalid price".
         */
        message?: string | null;
    }
    export interface Schema$DatafeedstatusesCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$DatafeedstatusesCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch datafeedstatuses request.
     */
    export interface Schema$DatafeedstatusesCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The country for which to get the datafeed status. If this parameter is provided then language must also be provided. Note that for multi-target datafeeds this parameter is required.
         */
        country?: string | null;
        /**
         * The ID of the data feed to get.
         */
        datafeedId?: string | null;
        /**
         * The language for which to get the datafeed status. If this parameter is provided then country must also be provided. Note that for multi-target datafeeds this parameter is required.
         */
        language?: string | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`get`"
         */
        method?: string | null;
    }
    export interface Schema$DatafeedstatusesCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$DatafeedstatusesCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#datafeedstatusesCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch datafeedstatuses response.
     */
    export interface Schema$DatafeedstatusesCustomBatchResponseEntry {
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * The requested data feed status. Defined if and only if the request was successful.
         */
        datafeedStatus?: Schema$DatafeedStatus;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
    }
    export interface Schema$DatafeedstatusesListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#datafeedstatusesListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of datafeed statuses.
         */
        nextPageToken?: string | null;
        resources?: Schema$DatafeedStatus[];
    }
    /**
     * An example occurrence for a particular error.
     */
    export interface Schema$DatafeedStatusExample {
        /**
         * The ID of the example item.
         */
        itemId?: string | null;
        /**
         * Line number in the data feed where the example is found.
         */
        lineNumber?: string | null;
        /**
         * The problematic value.
         */
        value?: string | null;
    }
    export interface Schema$DatafeedTarget {
        /**
         * The country where the items in the feed will be included in the search index, represented as a CLDR territory code.
         */
        country?: string | null;
        /**
         * The list of destinations to exclude for this target (corresponds to unchecked check boxes in Merchant Center).
         */
        excludedDestinations?: string[] | null;
        /**
         * The list of destinations to include for this target (corresponds to checked check boxes in Merchant Center). Default destinations are always included unless provided in `excludedDestinations`. List of supported destinations (if available to the account): - DisplayAds - Shopping - ShoppingActions - SurfacesAcrossGoogle
         */
        includedDestinations?: string[] | null;
        /**
         * The two-letter ISO 639-1 language of the items in the feed. Must be a valid language for `targets[].country`.
         */
        language?: string | null;
    }
    /**
     * Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values * A month and day value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`.
     */
    export interface Schema$Date {
        /**
         * Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
         */
        day?: number | null;
        /**
         * Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
         */
        month?: number | null;
        /**
         * Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.
         */
        year?: number | null;
    }
    /**
     * Represents civil time (or occasionally physical time). This type can represent a civil time in one of a few possible ways: * When utc_offset is set and time_zone is unset: a civil time on a calendar day with a particular offset from UTC. * When time_zone is set and utc_offset is unset: a civil time on a calendar day in a particular time zone. * When neither time_zone nor utc_offset is set: a civil time on a calendar day in local time. The date is relative to the Proleptic Gregorian Calendar. If year is 0, the DateTime is considered not to have a specific year. month and day must have valid, non-zero values. This type may also be used to represent a physical time if all the date and time fields are set and either case of the `time_offset` oneof is set. Consider using `Timestamp` message for physical time instead. If your use case also would like to store the user's timezone, that can be done in another field. This type is more flexible than some applications may want. Make sure to document and validate your application's limitations.
     */
    export interface Schema$DateTime {
        /**
         * Required. Day of month. Must be from 1 to 31 and valid for the year and month.
         */
        day?: number | null;
        /**
         * Required. Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
         */
        hours?: number | null;
        /**
         * Required. Minutes of hour of day. Must be from 0 to 59.
         */
        minutes?: number | null;
        /**
         * Required. Month of year. Must be from 1 to 12.
         */
        month?: number | null;
        /**
         * Required. Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
         */
        nanos?: number | null;
        /**
         * Required. Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
         */
        seconds?: number | null;
        /**
         * Time zone.
         */
        timeZone?: Schema$TimeZone;
        /**
         * UTC offset. Must be whole seconds, between -18 hours and +18 hours. For example, a UTC offset of -4:00 would be represented as { seconds: -14400 \}.
         */
        utcOffset?: string | null;
        /**
         * Optional. Year of date. Must be from 1 to 9999, or 0 if specifying a datetime without a year.
         */
        year?: number | null;
    }
    export interface Schema$DeliveryTime {
        /**
         * Business days cutoff time definition. If not configured the cutoff time will be defaulted to 8AM PST.
         */
        cutoffTime?: Schema$CutoffTime;
        /**
         * The business days during which orders can be handled. If not provided, Monday to Friday business days will be assumed.
         */
        handlingBusinessDayConfig?: Schema$BusinessDayConfig;
        /**
         * Holiday cutoff definitions. If configured, they specify order cutoff times for holiday-specific shipping.
         */
        holidayCutoffs?: Schema$HolidayCutoff[];
        /**
         * Maximum number of business days spent before an order is shipped. 0 means same day shipped, 1 means next day shipped. Must be greater than or equal to `minHandlingTimeInDays`.
         */
        maxHandlingTimeInDays?: number | null;
        /**
         * Maximum number of business days that is spent in transit. 0 means same day delivery, 1 means next day delivery. Must be greater than or equal to `minTransitTimeInDays`.
         */
        maxTransitTimeInDays?: number | null;
        /**
         * Minimum number of business days spent before an order is shipped. 0 means same day shipped, 1 means next day shipped.
         */
        minHandlingTimeInDays?: number | null;
        /**
         * Minimum number of business days that is spent in transit. 0 means same day delivery, 1 means next day delivery. Either `{min,max\}TransitTimeInDays` or `transitTimeTable` must be set, but not both.
         */
        minTransitTimeInDays?: number | null;
        /**
         * The business days during which orders can be in-transit. If not provided, Monday to Friday business days will be assumed.
         */
        transitBusinessDayConfig?: Schema$BusinessDayConfig;
        /**
         * Transit time table, number of business days spent in transit based on row and column dimensions. Either `{min,max\}TransitTimeInDays` or `transitTimeTable` can be set, but not both.
         */
        transitTimeTable?: Schema$TransitTable;
        /**
         * Indicates that the delivery time should be calculated per warehouse (shipping origin location) based on the settings of the selected carrier. When set, no other transit time related field in DeliveryTime should be set.
         */
        warehouseBasedDeliveryTimes?: Schema$WarehouseBasedDeliveryTime[];
    }
    /**
     * An error returned by the API.
     */
    export interface Schema$Error {
        /**
         * The domain of the error.
         */
        domain?: string | null;
        /**
         * A description of the error.
         */
        message?: string | null;
        /**
         * The error code.
         */
        reason?: string | null;
    }
    /**
     * A list of errors returned by a failed batch entry.
     */
    export interface Schema$Errors {
        /**
         * The HTTP status of the first error in `errors`.
         */
        code?: number | null;
        /**
         * A list of errors.
         */
        errors?: Schema$Error[];
        /**
         * The message of the first error in `errors`.
         */
        message?: string | null;
    }
    export interface Schema$GmbAccounts {
        /**
         * The ID of the Merchant Center account.
         */
        accountId?: string | null;
        /**
         * A list of GMB accounts which are available to the merchant.
         */
        gmbAccounts?: Schema$GmbAccountsGmbAccount[];
    }
    export interface Schema$GmbAccountsGmbAccount {
        /**
         * The email which identifies the GMB account.
         */
        email?: string | null;
        /**
         * Number of listings under this account.
         */
        listingCount?: string | null;
        /**
         * The name of the GMB account.
         */
        name?: string | null;
        /**
         * The type of the GMB account (User or Business).
         */
        type?: string | null;
    }
    /**
     * A non-empty list of row or column headers for a table. Exactly one of `prices`, `weights`, `numItems`, `postalCodeGroupNames`, or `location` must be set.
     */
    export interface Schema$Headers {
        /**
         * A list of location ID sets. Must be non-empty. Can only be set if all other fields are not set.
         */
        locations?: Schema$LocationIdSet[];
        /**
         * A list of inclusive number of items upper bounds. The last value can be `"infinity"`. For example `["10", "50", "infinity"]` represents the headers "<= 10 items", "<= 50 items", and "\> 50 items". Must be non-empty. Can only be set if all other fields are not set.
         */
        numberOfItems?: string[] | null;
        /**
         * A list of postal group names. The last value can be `"all other locations"`. Example: `["zone 1", "zone 2", "all other locations"]`. The referred postal code groups must match the delivery country of the service. Must be non-empty. Can only be set if all other fields are not set.
         */
        postalCodeGroupNames?: string[] | null;
        /**
         * A list of inclusive order price upper bounds. The last price's value can be `"infinity"`. For example `[{"value": "10", "currency": "USD"\}, {"value": "500", "currency": "USD"\}, {"value": "infinity", "currency": "USD"\}]` represents the headers "<= $10", "<= $500", and "\> $500". All prices within a service must have the same currency. Must be non-empty. Can only be set if all other fields are not set.
         */
        prices?: Schema$Price[];
        /**
         * A list of inclusive order weight upper bounds. The last weight's value can be `"infinity"`. For example `[{"value": "10", "unit": "kg"\}, {"value": "50", "unit": "kg"\}, {"value": "infinity", "unit": "kg"\}]` represents the headers "<= 10kg", "<= 50kg", and "\> 50kg". All weights within a service must have the same unit. Must be non-empty. Can only be set if all other fields are not set.
         */
        weights?: Schema$Weight[];
    }
    export interface Schema$HolidayCutoff {
        /**
         * Date of the order deadline, in ISO 8601 format. E.g. "2016-11-29" for 29th November 2016. Required.
         */
        deadlineDate?: string | null;
        /**
         * Hour of the day on the deadline date until which the order has to be placed to qualify for the delivery guarantee. Possible values are: 0 (midnight), 1, ..., 12 (noon), 13, ..., 23. Required.
         */
        deadlineHour?: number | null;
        /**
         * Timezone identifier for the deadline hour. A list of identifiers can be found in the AdWords API documentation. E.g. "Europe/Zurich". Required.
         */
        deadlineTimezone?: string | null;
        /**
         * Unique identifier for the holiday. Required.
         */
        holidayId?: string | null;
        /**
         * Date on which the deadline will become visible to consumers in ISO 8601 format. E.g. "2016-10-31" for 31st October 2016. Required.
         */
        visibleFromDate?: string | null;
    }
    export interface Schema$HolidaysHoliday {
        /**
         * The CLDR territory code of the country in which the holiday is available. E.g. "US", "DE", "GB". A holiday cutoff can only be configured in a shipping settings service with matching delivery country. Always present.
         */
        countryCode?: string | null;
        /**
         * Date of the holiday, in ISO 8601 format. E.g. "2016-12-25" for Christmas 2016. Always present.
         */
        date?: string | null;
        /**
         * Date on which the order has to arrive at the customer's, in ISO 8601 format. E.g. "2016-12-24" for 24th December 2016. Always present.
         */
        deliveryGuaranteeDate?: string | null;
        /**
         * Hour of the day in the delivery location's timezone on the guaranteed delivery date by which the order has to arrive at the customer's. Possible values are: 0 (midnight), 1, ..., 12 (noon), 13, ..., 23. Always present.
         */
        deliveryGuaranteeHour?: string | null;
        /**
         * Unique identifier for the holiday to be used when configuring holiday cutoffs. Always present.
         */
        id?: string | null;
        /**
         * The holiday type. Always present. Acceptable values are: - "`Christmas`" - "`Easter`" - "`Father's Day`" - "`Halloween`" - "`Independence Day (USA)`" - "`Mother's Day`" - "`Thanksgiving`" - "`Valentine's Day`"
         */
        type?: string | null;
    }
    /**
     * Map of inapplicability details.
     */
    export interface Schema$InapplicabilityDetails {
        /**
         * Count of this inapplicable reason code.
         */
        inapplicableCount?: string | null;
        /**
         * Reason code this rule was not applicable.
         */
        inapplicableReason?: string | null;
    }
    export interface Schema$Installment {
        /**
         * The amount the buyer has to pay per month.
         */
        amount?: Schema$Price;
        /**
         * The number of installments the buyer has to pay.
         */
        months?: string | null;
    }
    export interface Schema$InvoiceSummary {
        /**
         * Summary of the total amounts of the additional charges.
         */
        additionalChargeSummaries?: Schema$InvoiceSummaryAdditionalChargeSummary[];
        /**
         * [required] Total price for the product.
         */
        productTotal?: Schema$Amount;
    }
    export interface Schema$InvoiceSummaryAdditionalChargeSummary {
        /**
         * [required] Total additional charge for this type.
         */
        totalAmount?: Schema$Amount;
        /**
         * [required] Type of the additional charge. Acceptable values are: - "`shipping`"
         */
        type?: string | null;
    }
    /**
     * The IDs of labels that should be assigned to the CSS domain.
     */
    export interface Schema$LabelIds {
        /**
         * The list of label IDs.
         */
        labelIds?: string[] | null;
    }
    export interface Schema$LiaAboutPageSettings {
        /**
         * The status of the verification process for the About page. Acceptable values are: - "`active`" - "`inactive`" - "`pending`"
         */
        status?: string | null;
        /**
         * The URL for the About page.
         */
        url?: string | null;
    }
    export interface Schema$LiaCountrySettings {
        /**
         * The settings for the About page.
         */
        about?: Schema$LiaAboutPageSettings;
        /**
         * Required. CLDR country code (e.g. "US").
         */
        country?: string | null;
        /**
         * The status of the "Merchant hosted local storefront" feature.
         */
        hostedLocalStorefrontActive?: boolean | null;
        /**
         * LIA inventory verification settings.
         */
        inventory?: Schema$LiaInventorySettings;
        /**
         * LIA "On Display To Order" settings.
         */
        onDisplayToOrder?: Schema$LiaOnDisplayToOrderSettings;
        /**
         * The POS data provider linked with this country.
         */
        posDataProvider?: Schema$LiaPosDataProvider;
        /**
         * The status of the "Store pickup" feature.
         */
        storePickupActive?: boolean | null;
    }
    export interface Schema$LiaInventorySettings {
        /**
         * The email of the contact for the inventory verification process.
         */
        inventoryVerificationContactEmail?: string | null;
        /**
         * The name of the contact for the inventory verification process.
         */
        inventoryVerificationContactName?: string | null;
        /**
         * The status of the verification contact. Acceptable values are: - "`active`" - "`inactive`" - "`pending`"
         */
        inventoryVerificationContactStatus?: string | null;
        /**
         * The status of the inventory verification process. Acceptable values are: - "`active`" - "`inactive`" - "`pending`"
         */
        status?: string | null;
    }
    export interface Schema$LiaOnDisplayToOrderSettings {
        /**
         * Shipping cost and policy URL.
         */
        shippingCostPolicyUrl?: string | null;
        /**
         * The status of the ?On display to order? feature. Acceptable values are: - "`active`" - "`inactive`" - "`pending`"
         */
        status?: string | null;
    }
    export interface Schema$LiaPosDataProvider {
        /**
         * The ID of the POS data provider.
         */
        posDataProviderId?: string | null;
        /**
         * The account ID by which this merchant is known to the POS data provider.
         */
        posExternalAccountId?: string | null;
    }
    /**
     * Local Inventory ads (LIA) settings. All methods except listposdataproviders require the admin role.
     */
    export interface Schema$LiaSettings {
        /**
         * The ID of the account to which these LIA settings belong. Ignored upon update, always present in get request responses.
         */
        accountId?: string | null;
        /**
         * The LIA settings for each country.
         */
        countrySettings?: Schema$LiaCountrySettings[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#liaSettings`"
         */
        kind?: string | null;
    }
    export interface Schema$LiasettingsCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$LiasettingsCustomBatchRequestEntry[];
    }
    export interface Schema$LiasettingsCustomBatchRequestEntry {
        /**
         * The ID of the account for which to get/update account LIA settings.
         */
        accountId?: string | null;
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * Inventory validation contact email. Required only for SetInventoryValidationContact.
         */
        contactEmail?: string | null;
        /**
         * Inventory validation contact name. Required only for SetInventoryValidationContact.
         */
        contactName?: string | null;
        /**
         * The country code. Required only for RequestInventoryVerification.
         */
        country?: string | null;
        /**
         * The GMB account. Required only for RequestGmbAccess.
         */
        gmbEmail?: string | null;
        /**
         * The account Lia settings to update. Only defined if the method is `update`.
         */
        liaSettings?: Schema$LiaSettings;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`get`" - "`getAccessibleGmbAccounts`" - "`requestGmbAccess`" - "`requestInventoryVerification`" - "`setInventoryVerificationContact`" - "`update`"
         */
        method?: string | null;
        /**
         * The ID of POS data provider. Required only for SetPosProvider.
         */
        posDataProviderId?: string | null;
        /**
         * The account ID by which this merchant is known to the POS provider.
         */
        posExternalAccountId?: string | null;
    }
    export interface Schema$LiasettingsCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$LiasettingsCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsCustomBatchResponse".
         */
        kind?: string | null;
    }
    export interface Schema$LiasettingsCustomBatchResponseEntry {
        /**
         * The ID of the request entry to which this entry responds.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if, and only if, the request failed.
         */
        errors?: Schema$Errors;
        /**
         * The list of accessible GMB accounts.
         */
        gmbAccounts?: Schema$GmbAccounts;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#liasettingsCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The retrieved or updated Lia settings.
         */
        liaSettings?: Schema$LiaSettings;
        /**
         * The list of POS data providers.
         */
        posDataProviders?: Schema$PosDataProviders[];
    }
    export interface Schema$LiasettingsGetAccessibleGmbAccountsResponse {
        /**
         * The ID of the Merchant Center account.
         */
        accountId?: string | null;
        /**
         * A list of GMB accounts which are available to the merchant.
         */
        gmbAccounts?: Schema$GmbAccountsGmbAccount[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsGetAccessibleGmbAccountsResponse".
         */
        kind?: string | null;
    }
    export interface Schema$LiasettingsListPosDataProvidersResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsListPosDataProvidersResponse".
         */
        kind?: string | null;
        /**
         * The list of POS data providers for each eligible country
         */
        posDataProviders?: Schema$PosDataProviders[];
    }
    export interface Schema$LiasettingsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of LIA settings.
         */
        nextPageToken?: string | null;
        resources?: Schema$LiaSettings[];
    }
    export interface Schema$LiasettingsRequestGmbAccessResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsRequestGmbAccessResponse".
         */
        kind?: string | null;
    }
    export interface Schema$LiasettingsRequestInventoryVerificationResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsRequestInventoryVerificationResponse".
         */
        kind?: string | null;
    }
    export interface Schema$LiasettingsSetInventoryVerificationContactResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsSetInventoryVerificationContactResponse".
         */
        kind?: string | null;
    }
    export interface Schema$LiasettingsSetPosDataProviderResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#liasettingsSetPosDataProviderResponse".
         */
        kind?: string | null;
    }
    export interface Schema$LinkedAccount {
        /**
         * The ID of the linked account.
         */
        linkedAccountId?: string | null;
        /**
         * List of provided services.
         */
        services?: Schema$LinkService[];
    }
    export interface Schema$LinkService {
        /**
         * Service provided to or by the linked account. Acceptable values are: - "`shoppingActionsOrderManagement`" - "`shoppingActionsProductManagement`" - "`shoppingAdsProductManagement`" - "`paymentProcessing`"
         */
        service?: string | null;
        /**
         * Status of the link Acceptable values are: - "`active`" - "`inactive`" - "`pending`"
         */
        status?: string | null;
    }
    /**
     * Response message for the `ListAccountLabels` method.
     */
    export interface Schema$ListAccountLabelsResponse {
        /**
         * The labels from the specified account.
         */
        accountLabels?: Schema$AccountLabel[];
        /**
         * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
    }
    /**
     * Response for listing account return carriers.
     */
    export interface Schema$ListAccountReturnCarrierResponse {
        /**
         * List of all available account return carriers for the merchant.
         */
        accountReturnCarriers?: Schema$AccountReturnCarrier[];
    }
    /**
     * Response message for the ListCollections method.
     */
    export interface Schema$ListCollectionsResponse {
        /**
         * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
        /**
         * The collections listed.
         */
        resources?: Schema$Collection[];
    }
    /**
     * Response message for the ListCollectionStatuses method.
     */
    export interface Schema$ListCollectionStatusesResponse {
        /**
         * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
        /**
         * The collectionstatuses listed.
         */
        resources?: Schema$CollectionStatus[];
    }
    /**
     * The response message for the `ListCsses` method
     */
    export interface Schema$ListCssesResponse {
        /**
         * The CSS domains affiliated with the specified CSS group.
         */
        csses?: Schema$Css[];
        /**
         * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
    }
    /**
     * Response message for the `ListRegions` method.
     */
    export interface Schema$ListRegionsResponse {
        /**
         * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
        /**
         * The regions from the specified merchant.
         */
        regions?: Schema$Region[];
    }
    /**
     * Response message for the ListRepricingProductReports method.
     */
    export interface Schema$ListRepricingProductReportsResponse {
        /**
         * A token for retrieving the next page. Its absence means there is no subsequent page.
         */
        nextPageToken?: string | null;
        /**
         * Periodic reports for the given Repricing product.
         */
        repricingProductReports?: Schema$RepricingProductReport[];
    }
    /**
     * Response message for the ListRepricingRuleReports method.
     */
    export interface Schema$ListRepricingRuleReportsResponse {
        /**
         * A token for retrieving the next page. Its absence means there is no subsequent page.
         */
        nextPageToken?: string | null;
        /**
         * Daily reports for the given Repricing rule.
         */
        repricingRuleReports?: Schema$RepricingRuleReport[];
    }
    /**
     * Response message for the `ListRepricingRules` method.
     */
    export interface Schema$ListRepricingRulesResponse {
        /**
         * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
        /**
         * The rules from the specified merchant.
         */
        repricingRules?: Schema$RepricingRule[];
    }
    /**
     * Response message for the `ListReturnPolicyOnline` method.
     */
    export interface Schema$ListReturnPolicyOnlineResponse {
        /**
         * The retrieved return policies.
         */
        returnPolicies?: Schema$ReturnPolicyOnline[];
    }
    /**
     * Local inventory resource. For accepted attribute values, see the local product inventory feed specification.
     */
    export interface Schema$LocalInventory {
        /**
         * Availability of the product. For accepted attribute values, see the local product inventory feed specification.
         */
        availability?: string | null;
        /**
         * In-store product location.
         */
        instoreProductLocation?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#localInventory`"
         */
        kind?: string | null;
        /**
         * Supported pickup method for this offer. Unless the value is "not supported", this field must be submitted together with `pickupSla`. For accepted attribute values, see the local product inventory feed // specification.
         */
        pickupMethod?: string | null;
        /**
         * Expected date that an order will be ready for pickup relative to the order date. Must be submitted together with `pickupMethod`. For accepted attribute values, see the local product inventory feed specification.
         */
        pickupSla?: string | null;
        /**
         * Price of the product.
         */
        price?: Schema$Price;
        /**
         * Quantity of the product. Must be nonnegative.
         */
        quantity?: number | null;
        /**
         * Sale price of the product. Mandatory if `sale_price_effective_date` is defined.
         */
        salePrice?: Schema$Price;
        /**
         * A date range represented by a pair of ISO 8601 dates separated by a space, comma, or slash. Both dates may be specified as 'null' if undecided.
         */
        salePriceEffectiveDate?: string | null;
        /**
         * Required. Store code of this local inventory resource.
         */
        storeCode?: string | null;
    }
    export interface Schema$LocalinventoryCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$LocalinventoryCustomBatchRequestEntry[];
    }
    /**
     * Batch entry encoding a single local inventory update request.
     */
    export interface Schema$LocalinventoryCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * Local inventory of the product.
         */
        localInventory?: Schema$LocalInventory;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * Method of the batch request entry. Acceptable values are: - "`insert`"
         */
        method?: string | null;
        /**
         * The ID of the product for which to update local inventory.
         */
        productId?: string | null;
    }
    export interface Schema$LocalinventoryCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$LocalinventoryCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#localinventoryCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * Batch entry encoding a single local inventory update response.
     */
    export interface Schema$LocalinventoryCustomBatchResponseEntry {
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#localinventoryCustomBatchResponseEntry`"
         */
        kind?: string | null;
    }
    export interface Schema$LocationIdSet {
        /**
         * A non-empty list of location IDs. They must all be of the same location type (e.g., state).
         */
        locationIds?: string[] | null;
    }
    export interface Schema$LoyaltyPoints {
        /**
         * Name of loyalty points program. It is recommended to limit the name to 12 full-width characters or 24 Roman characters.
         */
        name?: string | null;
        /**
         * The retailer's loyalty points in absolute value.
         */
        pointsValue?: string | null;
        /**
         * The ratio of a point when converted to currency. Google assumes currency based on Merchant Center settings. If ratio is left out, it defaults to 1.0.
         */
        ratio?: number | null;
    }
    /**
     * Order return. Production access (all methods) requires the order manager role. Sandbox access does not.
     */
    export interface Schema$MerchantOrderReturn {
        /**
         * The date of creation of the return, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * Merchant defined order ID.
         */
        merchantOrderId?: string | null;
        /**
         * Google order ID.
         */
        orderId?: string | null;
        /**
         * Order return ID generated by Google.
         */
        orderReturnId?: string | null;
        /**
         * Items of the return.
         */
        returnItems?: Schema$MerchantOrderReturnItem[];
        /**
         * Information about shipping costs.
         */
        returnPricingInfo?: Schema$ReturnPricingInfo;
        /**
         * Shipments of the return.
         */
        returnShipments?: Schema$ReturnShipment[];
    }
    export interface Schema$MerchantOrderReturnItem {
        /**
         * The reason that the customer chooses to return an item.
         */
        customerReturnReason?: Schema$CustomerReturnReason;
        /**
         * Product level item ID. If the returned items are of the same product, they will have the same ID.
         */
        itemId?: string | null;
        /**
         * The reason that the merchant chose to reject an item return.
         */
        merchantRejectionReason?: Schema$MerchantRejectionReason;
        /**
         * The reason that merchant chooses to accept a return item.
         */
        merchantReturnReason?: Schema$RefundReason;
        /**
         * Product data from the time of the order placement.
         */
        product?: Schema$OrderLineItemProduct;
        /**
         * Maximum amount that can be refunded for this return item.
         */
        refundableAmount?: Schema$MonetaryAmount;
        /**
         * Unit level ID for the return item. Different units of the same product will have different IDs.
         */
        returnItemId?: string | null;
        /**
         * IDs of the return shipments that this return item belongs to.
         */
        returnShipmentIds?: string[] | null;
        /**
         * ID of the original shipment group. Provided for shipments with invoice support.
         */
        shipmentGroupId?: string | null;
        /**
         * ID of the shipment unit assigned by the merchant. Provided for shipments with invoice support.
         */
        shipmentUnitId?: string | null;
        /**
         * State of the item. Acceptable values are: - "`canceled`" - "`new`" - "`received`" - "`refunded`" - "`rejected`"
         */
        state?: string | null;
    }
    export interface Schema$MerchantRejectionReason {
        /**
         * Description of the reason.
         */
        description?: string | null;
        /**
         * Code of the rejection reason.
         */
        reasonCode?: string | null;
    }
    /**
     * Performance metrics. Values are only set for metrics requested explicitly in the request's search query.
     */
    export interface Schema$Metrics {
        /**
         * Average order size - the average number of items in an order. **This metric cannot be segmented by product dimensions.**
         */
        aos?: number | null;
        /**
         * Average order value - the average value (total price of items) of all placed orders. The currency of the returned value is stored in the currency_code segment. If this metric is selected, 'segments.currency_code' is automatically added to the SELECT clause in the search query (unless it is explicitly selected by the user) and the currency_code segment is populated in the response. **This metric cannot be segmented by product dimensions.**
         */
        aovMicros?: number | null;
        /**
         * Number of clicks.
         */
        clicks?: string | null;
        /**
         * Click-through rate - the number of clicks merchant's products receive (clicks) divided by the number of times the products are shown (impressions).
         */
        ctr?: number | null;
        /**
         * Average number of days between an order being placed and the order being fully shipped, reported on the last shipment date. **This metric cannot be segmented by product dimensions.**
         */
        daysToShip?: number | null;
        /**
         * Number of times merchant's products are shown.
         */
        impressions?: string | null;
        /**
         * Average number of days between an item being ordered and the item being
         */
        itemDaysToShip?: number | null;
        /**
         * Percentage of shipped items in relation to all finalized items (shipped or rejected by the merchant; unshipped items are not taken into account), reported on the order date. Item fill rate is lowered by merchant rejections.
         */
        itemFillRate?: number | null;
        /**
         * Number of ordered items. Excludes customer cancellations that happened within 30 minutes of placing the order.
         */
        orderedItems?: string | null;
        /**
         * Total price of ordered items. Excludes shipping, taxes (US only), and customer cancellations that happened within 30 minutes of placing the order. The currency of the returned value is stored in the currency_code segment. If this metric is selected, 'segments.currency_code' is automatically added to the SELECT clause in the search query (unless it is explicitly selected by the user) and the currency_code segment is populated in the response.
         */
        orderedItemSalesMicros?: string | null;
        /**
         * Number of placed orders. Excludes customer cancellations that happened within 30 minutes of placing the order. **This metric cannot be segmented by product dimensions.**
         */
        orders?: string | null;
        /**
         * Number of ordered items canceled by the merchant, reported on the order date.
         */
        rejectedItems?: string | null;
        /**
         * Number of ordered items sent back for return, reported on the date when the merchant accepted the return.
         */
        returnedItems?: string | null;
        /**
         * Total price of returned items divided by the total price of shipped items, reported on the order date. If this metric is selected, 'segments.currency_code' is automatically added to the SELECT clause in the search query (unless it is explicitly selected by the user) and the currency_code segment is populated in the response.
         */
        returnRate?: number | null;
        /**
         * Total price of ordered items sent back for return, reported on the date when the merchant accepted the return. The currency of the returned value is stored in the currency_code segment. If this metric is selected, 'segments.currency_code' is automatically added to the SELECT clause in the search query (unless it is explicitly selected by the user) and the currency_code segment is populated in the response.
         */
        returnsMicros?: string | null;
        /**
         * Number of shipped items, reported on the shipment date.
         */
        shippedItems?: string | null;
        /**
         * Total price of shipped items, reported on the order date. Excludes shipping and taxes (US only). The currency of the returned value is stored in the currency_code segment. If this metric is selected, 'segments.currency_code' is automatically added to the SELECT clause in the search query (unless it is explicitly selected by the user) and the currency_code segment is populated in the response.
         */
        shippedItemSalesMicros?: string | null;
        /**
         * Number of fully shipped orders, reported on the last shipment date. **This metric cannot be segmented by product dimensions.**
         */
        shippedOrders?: string | null;
        /**
         * Number of ordered items not shipped up until the end of the queried day. If a multi-day period is specified in the search query, the returned value is the average number of unshipped items over the days in the queried period.
         */
        unshippedItems?: number | null;
        /**
         * Number of orders not shipped or partially shipped up until the end of the queried day. If a multi-day period is specified in the search query, the returned value is the average number of unshipped orders over the days in the queried period. **This metric cannot be segmented by product dimensions.**
         */
        unshippedOrders?: number | null;
    }
    export interface Schema$MinimumOrderValueTable {
        storeCodeSetWithMovs?: Schema$MinimumOrderValueTableStoreCodeSetWithMov[];
    }
    /**
     * A list of store code sets sharing the same minimum order value. At least two sets are required and the last one must be empty, which signifies 'MOV for all other stores'. Each store code can only appear once across all the sets. All prices within a service must have the same currency.
     */
    export interface Schema$MinimumOrderValueTableStoreCodeSetWithMov {
        /**
         * A list of unique store codes or empty for the catch all.
         */
        storeCodes?: string[] | null;
        /**
         * The minimum order value for the given stores.
         */
        value?: Schema$Price;
    }
    export interface Schema$MonetaryAmount {
        /**
         * The pre-tax or post-tax price depends on the location of the order. - For countries (e.g. US) where price attribute excludes tax, this field corresponds to the pre-tax value. - For coutries (e.g. France) where price attribute includes tax, this field corresponds to the post-tax value .
         */
        priceAmount?: Schema$Price;
        /**
         * Tax value, present only for countries where price attribute excludes tax (e.g. US). No tax is referenced as 0 value with the corresponding `currency`.
         */
        taxAmount?: Schema$Price;
    }
    /**
     * Request message for the OnboardProgram method.
     */
    export interface Schema$OnboardBuyOnGoogleProgramRequest {
        /**
         * The customer service email.
         */
        customerServiceEmail?: string | null;
    }
    /**
     * Order. Production access (all methods) requires the order manager role. Sandbox access does not.
     */
    export interface Schema$Order {
        /**
         * Whether the order was acknowledged.
         */
        acknowledged?: boolean | null;
        /**
         * List of key-value pairs that are attached to a given order.
         */
        annotations?: Schema$OrderOrderAnnotation[];
        /**
         * The billing address.
         */
        billingAddress?: Schema$OrderAddress;
        /**
         * The details of the customer who placed the order.
         */
        customer?: Schema$OrderCustomer;
        /**
         * Delivery details for shipments of type `delivery`.
         */
        deliveryDetails?: Schema$OrderDeliveryDetails;
        /**
         * The REST ID of the order. Globally unique.
         */
        id?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#order`"
         */
        kind?: string | null;
        /**
         * Line items that are ordered.
         */
        lineItems?: Schema$OrderLineItem[];
        merchantId?: string | null;
        /**
         * Merchant-provided ID of the order.
         */
        merchantOrderId?: string | null;
        /**
         * The net amount for the order (price part). For example, if an order was originally for $100 and a refund was issued for $20, the net amount will be $80.
         */
        netPriceAmount?: Schema$Price;
        /**
         * The net amount for the order (tax part). Note that in certain cases due to taxable base adjustment `netTaxAmount` might not match to a sum of tax field across all lineItems and refunds.
         */
        netTaxAmount?: Schema$Price;
        /**
         * The status of the payment. Acceptable values are: - "`paymentCaptured`" - "`paymentRejected`" - "`paymentSecured`" - "`pendingAuthorization`"
         */
        paymentStatus?: string | null;
        /**
         * Pickup details for shipments of type `pickup`.
         */
        pickupDetails?: Schema$OrderPickupDetails;
        /**
         * The date when the order was placed, in ISO 8601 format.
         */
        placedDate?: string | null;
        /**
         * Promotions associated with the order. To determine which promotions apply to which products, check the `Promotions[].appliedItems[].lineItemId` field against the `LineItems[].id` field for each promotion. If a promotion is applied to more than 1 offerId, divide the discount value by the number of affected offers to determine how much discount to apply to each offerId. Examples: 1. To calculate price paid by the customer for a single line item including the discount: For each promotion, subtract the `LineItems[].adjustments[].priceAdjustment.value` amount from the `LineItems[].Price.value`. 2. To calculate price paid by the customer for a single line item including the discount in case of multiple quantity: For each promotion, divide the `LineItems[].adjustments[].priceAdjustment.value` by the quantity of products then subtract the resulting value from the `LineItems[].Product.Price.value` for each quantity item. Only 1 promotion can be applied to an offerId in a given order. To refund an item which had a promotion applied to it, make sure to refund the amount after first subtracting the promotion discount from the item price. More details about the program are here.
         */
        promotions?: Schema$OrderPromotion[];
        /**
         * Refunds for the order.
         */
        refunds?: Schema$OrderRefund[];
        /**
         * Shipments of the order.
         */
        shipments?: Schema$OrderShipment[];
        /**
         * The total cost of shipping for all items.
         */
        shippingCost?: Schema$Price;
        /**
         * The tax for the total shipping cost.
         */
        shippingCostTax?: Schema$Price;
        /**
         * The status of the order. Acceptable values are: - "`canceled`" - "`delivered`" - "`inProgress`" - "`partiallyDelivered`" - "`partiallyReturned`" - "`partiallyShipped`" - "`pendingShipment`" - "`returned`" - "`shipped`"
         */
        status?: string | null;
        /**
         * The party responsible for collecting and remitting taxes. Acceptable values are: - "`marketplaceFacilitator`" - "`merchant`"
         */
        taxCollector?: string | null;
    }
    export interface Schema$OrderAddress {
        /**
         * CLDR country code (e.g. "US").
         */
        country?: string | null;
        /**
         * Strings representing the lines of the printed label for mailing the order, for example: John Smith 1600 Amphitheatre Parkway Mountain View, CA, 94043 United States
         */
        fullAddress?: string[] | null;
        /**
         * Whether the address is a post office box.
         */
        isPostOfficeBox?: boolean | null;
        /**
         * City, town or commune. May also include dependent localities or sublocalities (e.g. neighborhoods or suburbs).
         */
        locality?: string | null;
        /**
         * Postal Code or ZIP (e.g. "94043").
         */
        postalCode?: string | null;
        /**
         * Name of the recipient.
         */
        recipientName?: string | null;
        /**
         * Top-level administrative subdivision of the country. For example, a state like California ("CA") or a province like Quebec ("QC").
         */
        region?: string | null;
        /**
         * Street-level part of the address.
         */
        streetAddress?: string[] | null;
    }
    export interface Schema$OrderCancellation {
        /**
         * The actor that created the cancellation. Acceptable values are: - "`customer`" - "`googleBot`" - "`googleCustomerService`" - "`googlePayments`" - "`googleSabre`" - "`merchant`"
         */
        actor?: string | null;
        /**
         * Date on which the cancellation has been created, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * The quantity that was canceled.
         */
        quantity?: number | null;
        /**
         * The reason for the cancellation. Orders that are canceled with a noInventory reason will lead to the removal of the product from Buy on Google until you make an update to that product. This will not affect your Shopping ads. Acceptable values are: - "`autoPostInternal`" - "`autoPostInvalidBillingAddress`" - "`autoPostNoInventory`" - "`autoPostPriceError`" - "`autoPostUndeliverableShippingAddress`" - "`couponAbuse`" - "`customerCanceled`" - "`customerInitiatedCancel`" - "`customerSupportRequested`" - "`failToPushOrderGoogleError`" - "`failToPushOrderMerchantError`" - "`failToPushOrderMerchantFulfillmentError`" - "`failToPushOrderToMerchant`" - "`failToPushOrderToMerchantOutOfStock`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`merchantDidNotShipOnTime`" - "`noInventory`" - "`orderTimeout`" - "`other`" - "`paymentAbuse`" - "`paymentDeclined`" - "`priceError`" - "`returnRefundAbuse`" - "`shippingPriceError`" - "`taxError`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrderCustomer {
        /**
         * Full name of the customer.
         */
        fullName?: string | null;
        /**
         * Email address for the merchant to send value-added tax or invoice documentation of the order. Only the last document sent is made available to the customer. For more information, see About automated VAT invoicing for Buy on Google.
         */
        invoiceReceivingEmail?: string | null;
        /**
         * Loyalty program information.
         */
        loyaltyInfo?: Schema$OrderCustomerLoyaltyInfo;
        /**
         * Customer's marketing preferences. Contains the marketing opt-in information that is current at the time that the merchant call. User preference selections can change from one order to the next so preferences must be checked with every order.
         */
        marketingRightsInfo?: Schema$OrderCustomerMarketingRightsInfo;
    }
    export interface Schema$OrderCustomerLoyaltyInfo {
        /**
         * The loyalty card/membership number.
         */
        loyaltyNumber?: string | null;
        /**
         * Name of card/membership holder, this field will be populated when
         */
        name?: string | null;
    }
    export interface Schema$OrderCustomerMarketingRightsInfo {
        /**
         * Last known customer selection regarding marketing preferences. In certain cases this selection might not be known, so this field would be empty. If a customer selected `granted` in their most recent order, they can be subscribed to marketing emails. Customers who have chosen `denied` must not be subscribed, or must be unsubscribed if already opted-in. Acceptable values are: - "`denied`" - "`granted`"
         */
        explicitMarketingPreference?: string | null;
        /**
         * Timestamp when last time marketing preference was updated. Could be empty, if user wasn't offered a selection yet.
         */
        lastUpdatedTimestamp?: string | null;
        /**
         * Email address that can be used for marketing purposes. The field may be empty even if `explicitMarketingPreference` is 'granted'. This happens when retrieving an old order from the customer who deleted their account.
         */
        marketingEmailAddress?: string | null;
    }
    export interface Schema$OrderDeliveryDetails {
        /**
         * The delivery address
         */
        address?: Schema$OrderAddress;
        /**
         * The phone number of the person receiving the delivery.
         */
        phoneNumber?: string | null;
    }
    export interface Schema$OrderinvoicesCreateChargeInvoiceRequest {
        /**
         * [required] The ID of the invoice.
         */
        invoiceId?: string | null;
        /**
         * [required] Invoice summary.
         */
        invoiceSummary?: Schema$InvoiceSummary;
        /**
         * [required] Invoice details per line item.
         */
        lineItemInvoices?: Schema$ShipmentInvoiceLineItemInvoice[];
        /**
         * [required] The ID of the operation, unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * [required] ID of the shipment group. It is assigned by the merchant in the `shipLineItems` method and is used to group multiple line items that have the same kind of shipping charges.
         */
        shipmentGroupId?: string | null;
    }
    export interface Schema$OrderinvoicesCreateChargeInvoiceResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderinvoicesCreateChargeInvoiceResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrderinvoicesCreateRefundInvoiceRequest {
        /**
         * [required] The ID of the invoice.
         */
        invoiceId?: string | null;
        /**
         * [required] The ID of the operation, unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * Option to create a refund-only invoice. Exactly one of `refundOnlyOption` or `returnOption` must be provided.
         */
        refundOnlyOption?: Schema$OrderinvoicesCustomBatchRequestEntryCreateRefundInvoiceRefundOption;
        /**
         * Option to create an invoice for a refund and mark all items within the invoice as returned. Exactly one of `refundOnlyOption` or `returnOption` must be provided.
         */
        returnOption?: Schema$OrderinvoicesCustomBatchRequestEntryCreateRefundInvoiceReturnOption;
        /**
         * Invoice details for different shipment groups.
         */
        shipmentInvoices?: Schema$ShipmentInvoice[];
    }
    export interface Schema$OrderinvoicesCreateRefundInvoiceResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderinvoicesCreateRefundInvoiceResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrderinvoicesCustomBatchRequestEntryCreateRefundInvoiceRefundOption {
        /**
         * Optional description of the refund reason.
         */
        description?: string | null;
        /**
         * [required] Reason for the refund. Acceptable values are: - "`adjustment`" - "`autoPostInternal`" - "`autoPostInvalidBillingAddress`" - "`autoPostNoInventory`" - "`autoPostPriceError`" - "`autoPostUndeliverableShippingAddress`" - "`couponAbuse`" - "`courtesyAdjustment`" - "`customerCanceled`" - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`customerSupportRequested`" - "`deliveredLateByCarrier`" - "`deliveredTooLate`" - "`expiredItem`" - "`failToPushOrderGoogleError`" - "`failToPushOrderMerchantError`" - "`failToPushOrderMerchantFulfillmentError`" - "`failToPushOrderToMerchant`" - "`failToPushOrderToMerchantOutOfStock`" - "`feeAdjustment`" - "`invalidCoupon`" - "`lateShipmentCredit`" - "`malformedShippingAddress`" - "`merchantDidNotShipOnTime`" - "`noInventory`" - "`orderTimeout`" - "`other`" - "`paymentAbuse`" - "`paymentDeclined`" - "`priceAdjustment`" - "`priceError`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`promoReallocation`" - "`qualityNotAsExpected`" - "`returnRefundAbuse`" - "`shippingCostAdjustment`" - "`shippingPriceError`" - "`taxAdjustment`" - "`taxError`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reason?: string | null;
    }
    export interface Schema$OrderinvoicesCustomBatchRequestEntryCreateRefundInvoiceReturnOption {
        /**
         * Optional description of the return reason.
         */
        description?: string | null;
        /**
         * [required] Reason for the return. Acceptable values are: - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`deliveredTooLate`" - "`expiredItem`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`other`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`qualityNotAsExpected`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reason?: string | null;
    }
    export interface Schema$OrderLineItem {
        /**
         * Price and tax adjustments applied on the line item.
         */
        adjustments?: Schema$OrderLineItemAdjustment[];
        /**
         * Annotations that are attached to the line item.
         */
        annotations?: Schema$OrderMerchantProvidedAnnotation[];
        /**
         * Cancellations of the line item.
         */
        cancellations?: Schema$OrderCancellation[];
        /**
         * The ID of the line item.
         */
        id?: string | null;
        /**
         * Total price for the line item. For example, if two items for $10 are purchased, the total price will be $20.
         */
        price?: Schema$Price;
        /**
         * Product data as seen by customer from the time of the order placement. Note that certain attributes values (e.g. title or gtin) might be reformatted and no longer match values submitted via product feed.
         */
        product?: Schema$OrderLineItemProduct;
        /**
         * Number of items canceled.
         */
        quantityCanceled?: number | null;
        /**
         * Number of items delivered.
         */
        quantityDelivered?: number | null;
        /**
         * Number of items ordered.
         */
        quantityOrdered?: number | null;
        /**
         * Number of items pending.
         */
        quantityPending?: number | null;
        /**
         * Number of items ready for pickup.
         */
        quantityReadyForPickup?: number | null;
        /**
         * Number of items returned.
         */
        quantityReturned?: number | null;
        /**
         * Number of items shipped.
         */
        quantityShipped?: number | null;
        /**
         * Number of items undeliverable.
         */
        quantityUndeliverable?: number | null;
        /**
         * Details of the return policy for the line item.
         */
        returnInfo?: Schema$OrderLineItemReturnInfo;
        /**
         * Returns of the line item.
         */
        returns?: Schema$OrderReturn[];
        /**
         * Details of the requested shipping for the line item.
         */
        shippingDetails?: Schema$OrderLineItemShippingDetails;
        /**
         * Total tax amount for the line item. For example, if two items are purchased, and each have a cost tax of $2, the total tax amount will be $4.
         */
        tax?: Schema$Price;
    }
    export interface Schema$OrderLineItemAdjustment {
        /**
         * Adjustment for total price of the line item.
         */
        priceAdjustment?: Schema$Price;
        /**
         * Adjustment for total tax of the line item.
         */
        taxAdjustment?: Schema$Price;
        /**
         * Type of this adjustment. Acceptable values are: - "`promotion`"
         */
        type?: string | null;
    }
    export interface Schema$OrderLineItemProduct {
        /**
         * Brand of the item.
         */
        brand?: string | null;
        /**
         * Condition or state of the item. Acceptable values are: - "`new`" - "`refurbished`" - "`used`"
         */
        condition?: string | null;
        /**
         * The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Associated fees at order creation time.
         */
        fees?: Schema$OrderLineItemProductFee[];
        /**
         * Global Trade Item Number (GTIN) of the item.
         */
        gtin?: string | null;
        /**
         * The REST ID of the product.
         */
        id?: string | null;
        /**
         * URL of an image of the item.
         */
        imageLink?: string | null;
        /**
         * Shared identifier for all variants of the same product.
         */
        itemGroupId?: string | null;
        /**
         * Manufacturer Part Number (MPN) of the item.
         */
        mpn?: string | null;
        /**
         * An identifier of the item.
         */
        offerId?: string | null;
        /**
         * Price of the item.
         */
        price?: Schema$Price;
        /**
         * URL to the cached image shown to the user when order was placed.
         */
        shownImage?: string | null;
        /**
         * The CLDR territory // code of the target country of the product.
         */
        targetCountry?: string | null;
        /**
         * The title of the product.
         */
        title?: string | null;
        /**
         * Variant attributes for the item. These are dimensions of the product, such as color, gender, material, pattern, and size. You can find a comprehensive list of variant attributes here.
         */
        variantAttributes?: Schema$OrderLineItemProductVariantAttribute[];
    }
    export interface Schema$OrderLineItemProductFee {
        /**
         * Amount of the fee.
         */
        amount?: Schema$Price;
        /**
         * Name of the fee.
         */
        name?: string | null;
    }
    export interface Schema$OrderLineItemProductVariantAttribute {
        /**
         * The dimension of the variant.
         */
        dimension?: string | null;
        /**
         * The value for the dimension.
         */
        value?: string | null;
    }
    export interface Schema$OrderLineItemReturnInfo {
        /**
         * Required. How many days later the item can be returned.
         */
        daysToReturn?: number | null;
        /**
         * Required. Whether the item is returnable.
         */
        isReturnable?: boolean | null;
        /**
         * Required. URL of the item return policy.
         */
        policyUrl?: string | null;
    }
    export interface Schema$OrderLineItemShippingDetails {
        /**
         * Required. The delivery by date, in ISO 8601 format.
         */
        deliverByDate?: string | null;
        /**
         * Required. Details of the shipping method.
         */
        method?: Schema$OrderLineItemShippingDetailsMethod;
        /**
         * The promised time in minutes in which the order will be ready for pickup. This only applies to buy-online-pickup-in-store same-day order.
         */
        pickupPromiseInMinutes?: number | null;
        /**
         * Required. The ship by date, in ISO 8601 format.
         */
        shipByDate?: string | null;
        /**
         * Type of shipment. Indicates whether `deliveryDetails` or `pickupDetails` is applicable for this shipment. Acceptable values are: - "`delivery`" - "`pickup`"
         */
        type?: string | null;
    }
    export interface Schema$OrderLineItemShippingDetailsMethod {
        /**
         * The carrier for the shipping. Optional. See `shipments[].carrier` for a list of acceptable values.
         */
        carrier?: string | null;
        /**
         * Required. Maximum transit time.
         */
        maxDaysInTransit?: number | null;
        /**
         * Required. The name of the shipping method.
         */
        methodName?: string | null;
        /**
         * Required. Minimum transit time.
         */
        minDaysInTransit?: number | null;
    }
    export interface Schema$OrderMerchantProvidedAnnotation {
        /**
         * Key for additional merchant provided (as key-value pairs) annotation about the line item.
         */
        key?: string | null;
        /**
         * Value for additional merchant provided (as key-value pairs) annotation about the line item.
         */
        value?: string | null;
    }
    export interface Schema$OrderOrderAnnotation {
        /**
         * Key for additional google provided (as key-value pairs) annotation.
         */
        key?: string | null;
        /**
         * Value for additional google provided (as key-value pairs) annotation.
         */
        value?: string | null;
    }
    export interface Schema$OrderPickupDetails {
        /**
         * Address of the pickup location where the shipment should be sent. Note that `recipientName` in the address is the name of the business at the pickup location.
         */
        address?: Schema$OrderAddress;
        /**
         * Collectors authorized to pick up shipment from the pickup location.
         */
        collectors?: Schema$OrderPickupDetailsCollector[];
        /**
         * ID of the pickup location.
         */
        locationId?: string | null;
        /**
         * The pickup type of this order. Acceptable values are: - "`merchantStore`" - "`merchantStoreCurbside`" - "`merchantStoreLocker`" - "`thirdPartyPickupPoint`" - "`thirdPartyLocker`"
         */
        pickupType?: string | null;
    }
    export interface Schema$OrderPickupDetailsCollector {
        /**
         * Name of the person picking up the shipment.
         */
        name?: string | null;
        /**
         * Phone number of the person picking up the shipment.
         */
        phoneNumber?: string | null;
    }
    export interface Schema$OrderPromotion {
        /**
         * Items that this promotion may be applied to. If empty, there are no restrictions on applicable items and quantity. This field will also be empty for shipping promotions because shipping is not tied to any specific item.
         */
        applicableItems?: Schema$OrderPromotionItem[];
        /**
         * Items that this promotion have been applied to. Do not provide for `orders.createtestorder`. This field will be empty for shipping promotions because shipping is not tied to any specific item.
         */
        appliedItems?: Schema$OrderPromotionItem[];
        /**
         * Promotion end time in ISO 8601 format. Date, time, and offset required, e.g., "2020-01-02T09:00:00+01:00" or "2020-01-02T09:00:00Z".
         */
        endTime?: string | null;
        /**
         * Required. The party funding the promotion. Only `merchant` is supported for `orders.createtestorder`. Acceptable values are: - "`google`" - "`merchant`"
         */
        funder?: string | null;
        /**
         * Required. This field is used to identify promotions within merchants' own systems.
         */
        merchantPromotionId?: string | null;
        /**
         * Estimated discount applied to price. Amount is pre-tax or post-tax depending on location of order.
         */
        priceValue?: Schema$Price;
        /**
         * A short title of the promotion to be shown on the checkout page. Do not provide for `orders.createtestorder`.
         */
        shortTitle?: string | null;
        /**
         * Promotion start time in ISO 8601 format. Date, time, and offset required, e.g., "2020-01-02T09:00:00+01:00" or "2020-01-02T09:00:00Z".
         */
        startTime?: string | null;
        /**
         * Required. The category of the promotion. Only `moneyOff` is supported for `orders.createtestorder`. Acceptable values are: - "`buyMGetMoneyOff`" - "`buyMGetNMoneyOff`" - "`buyMGetNPercentOff`" - "`buyMGetPercentOff`" - "`freeGift`" - "`freeGiftWithItemId`" - "`freeGiftWithValue`" - "`freeShippingOvernight`" - "`freeShippingStandard`" - "`freeShippingTwoDay`" - "`moneyOff`" - "`percentOff`" - "`rewardPoints`" - "`salePrice`"
         */
        subtype?: string | null;
        /**
         * Estimated discount applied to tax (if allowed by law). Do not provide for `orders.createtestorder`.
         */
        taxValue?: Schema$Price;
        /**
         * Required. The title of the promotion.
         */
        title?: string | null;
        /**
         * Required. The scope of the promotion. Only `product` is supported for `orders.createtestorder`. Acceptable values are: - "`product`" - "`shipping`"
         */
        type?: string | null;
    }
    export interface Schema$OrderPromotionItem {
        /**
         * The line item ID of a product. Do not provide for `orders.createtestorder`.
         */
        lineItemId?: string | null;
        /**
         * Required. Offer ID of a product. Only for `orders.createtestorder`.
         */
        offerId?: string | null;
        /**
         * `orders.createtestorder`.
         */
        productId?: string | null;
        /**
         * The quantity of the associated product. Do not provide for `orders.createtestorder`.
         */
        quantity?: number | null;
    }
    export interface Schema$OrderRefund {
        /**
         * The actor that created the refund. Acceptable values are: - "`customer`" - "`googleBot`" - "`googleCustomerService`" - "`googlePayments`" - "`googleSabre`" - "`merchant`"
         */
        actor?: string | null;
        /**
         * The amount that is refunded.
         */
        amount?: Schema$Price;
        /**
         * Date on which the item has been created, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * The reason for the refund. Acceptable values are: - "`adjustment`" - "`autoPostInternal`" - "`autoPostInvalidBillingAddress`" - "`autoPostNoInventory`" - "`autoPostPriceError`" - "`autoPostUndeliverableShippingAddress`" - "`couponAbuse`" - "`courtesyAdjustment`" - "`customerCanceled`" - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`customerSupportRequested`" - "`deliveredLateByCarrier`" - "`deliveredTooLate`" - "`expiredItem`" - "`failToPushOrderGoogleError`" - "`failToPushOrderMerchantError`" - "`failToPushOrderMerchantFulfillmentError`" - "`failToPushOrderToMerchant`" - "`failToPushOrderToMerchantOutOfStock`" - "`feeAdjustment`" - "`invalidCoupon`" - "`lateShipmentCredit`" - "`malformedShippingAddress`" - "`merchantDidNotShipOnTime`" - "`noInventory`" - "`orderTimeout`" - "`other`" - "`paymentAbuse`" - "`paymentDeclined`" - "`priceAdjustment`" - "`priceError`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`promoReallocation`" - "`qualityNotAsExpected`" - "`returnRefundAbuse`" - "`shippingCostAdjustment`" - "`shippingPriceError`" - "`taxAdjustment`" - "`taxError`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    /**
     * Order disbursement. All methods require the payment analyst role.
     */
    export interface Schema$OrderReportDisbursement {
        /**
         * The disbursement amount.
         */
        disbursementAmount?: Schema$Price;
        /**
         * The disbursement date, in ISO 8601 format.
         */
        disbursementCreationDate?: string | null;
        /**
         * The date the disbursement was initiated, in ISO 8601 format.
         */
        disbursementDate?: string | null;
        /**
         * The ID of the disbursement.
         */
        disbursementId?: string | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
    }
    export interface Schema$OrderreportsListDisbursementsResponse {
        /**
         * The list of disbursements.
         */
        disbursements?: Schema$OrderReportDisbursement[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderreportsListDisbursementsResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of disbursements.
         */
        nextPageToken?: string | null;
    }
    export interface Schema$OrderreportsListTransactionsResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderreportsListTransactionsResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of transactions.
         */
        nextPageToken?: string | null;
        /**
         * The list of transactions.
         */
        transactions?: Schema$OrderReportTransaction[];
    }
    export interface Schema$OrderReportTransaction {
        /**
         * The disbursement amount.
         */
        disbursementAmount?: Schema$Price;
        /**
         * The date the disbursement was created, in ISO 8601 format.
         */
        disbursementCreationDate?: string | null;
        /**
         * The date the disbursement was initiated, in ISO 8601 format.
         */
        disbursementDate?: string | null;
        /**
         * The ID of the disbursement.
         */
        disbursementId?: string | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * Merchant-provided ID of the order.
         */
        merchantOrderId?: string | null;
        /**
         * The ID of the order.
         */
        orderId?: string | null;
        /**
         * Total amount for the items.
         */
        productAmount?: Schema$ProductAmount;
        /**
         * The date of the transaction, in ISO 8601 format.
         */
        transactionDate?: string | null;
    }
    export interface Schema$OrderReturn {
        /**
         * The actor that created the refund. Acceptable values are: - "`customer`" - "`googleBot`" - "`googleCustomerService`" - "`googlePayments`" - "`googleSabre`" - "`merchant`"
         */
        actor?: string | null;
        /**
         * Date on which the item has been created, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * Quantity that is returned.
         */
        quantity?: number | null;
        /**
         * The reason for the return. Acceptable values are: - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`deliveredTooLate`" - "`expiredItem`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`other`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`qualityNotAsExpected`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrderreturnsAcknowledgeRequest {
        /**
         * [required] The ID of the operation, unique across all operations for a given order return.
         */
        operationId?: string | null;
    }
    export interface Schema$OrderreturnsAcknowledgeResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderreturnsAcknowledgeResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrderreturnsCreateOrderReturnRequest {
        /**
         * The list of line items to return.
         */
        lineItems?: Schema$OrderreturnsLineItem[];
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The ID of the order.
         */
        orderId?: string | null;
        /**
         * The way of the package being returned.
         */
        returnMethodType?: string | null;
    }
    export interface Schema$OrderreturnsCreateOrderReturnResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderreturnsCreateOrderReturnResponse".
         */
        kind?: string | null;
        /**
         * Created order return.
         */
        orderReturn?: Schema$MerchantOrderReturn;
    }
    export interface Schema$OrderreturnsLineItem {
        /**
         * The ID of the line item. This value is assigned by Google when an order is created. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the product to cancel. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The quantity of this line item.
         */
        quantity?: number | null;
    }
    export interface Schema$OrderreturnsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderreturnsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of returns.
         */
        nextPageToken?: string | null;
        resources?: Schema$MerchantOrderReturn[];
    }
    export interface Schema$OrderreturnsPartialRefund {
        /**
         * The pre-tax or post-tax amount to be refunded, depending on the location of the order.
         */
        priceAmount?: Schema$Price;
        /**
         * Tax amount to be refunded. Note: This has different meaning depending on the location of the order.
         */
        taxAmount?: Schema$Price;
    }
    export interface Schema$OrderreturnsProcessRequest {
        /**
         * Option to charge the customer return shipping cost.
         */
        fullChargeReturnShippingCost?: boolean | null;
        /**
         * [required] The ID of the operation, unique across all operations for a given order return.
         */
        operationId?: string | null;
        /**
         * Refunds for original shipping fee.
         */
        refundShippingFee?: Schema$OrderreturnsRefundOperation;
        /**
         * The list of items to return.
         */
        returnItems?: Schema$OrderreturnsReturnItem[];
    }
    export interface Schema$OrderreturnsProcessResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#orderreturnsProcessResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrderreturnsRefundOperation {
        /**
         * If true, the item will be fully refunded. Allowed only when payment_type is FOP. Merchant can choose this refund option to indicate the full remaining amount of corresponding object to be refunded to the customer via FOP.
         */
        fullRefund?: boolean | null;
        /**
         * If this is set, the item will be partially refunded. Merchant can choose this refund option to specify the customized amount that to be refunded to the customer.
         */
        partialRefund?: Schema$OrderreturnsPartialRefund;
        /**
         * The payment way of issuing refund. Default value is ORIGINAL_FOP if not set.
         */
        paymentType?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
        /**
         * Code of the refund reason.
         */
        returnRefundReason?: string | null;
    }
    export interface Schema$OrderreturnsRejectOperation {
        /**
         * The reason for the return.
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrderreturnsReturnItem {
        /**
         * Refunds the item.
         */
        refund?: Schema$OrderreturnsRefundOperation;
        /**
         * Rejects the item.
         */
        reject?: Schema$OrderreturnsRejectOperation;
        /**
         * Unit level ID for the return item. Different units of the same product will have different IDs.
         */
        returnItemId?: string | null;
    }
    export interface Schema$OrdersAcknowledgeRequest {
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
    }
    export interface Schema$OrdersAcknowledgeResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersAcknowledgeResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersAdvanceTestOrderResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersAdvanceTestOrderResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersCancelLineItemRequest {
        /**
         * The ID of the line item to cancel. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The ID of the product to cancel. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The quantity to cancel.
         */
        quantity?: number | null;
        /**
         * The reason for the cancellation. Acceptable values are: - "`customerInitiatedCancel`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`noInventory`" - "`other`" - "`priceError`" - "`shippingPriceError`" - "`taxError`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrdersCancelLineItemResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersCancelLineItemResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersCancelRequest {
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The reason for the cancellation. Acceptable values are: - "`customerInitiatedCancel`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`noInventory`" - "`other`" - "`priceError`" - "`shippingPriceError`" - "`taxError`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrdersCancelResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersCancelResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersCancelTestOrderByCustomerRequest {
        /**
         * The reason for the cancellation. Acceptable values are: - "`changedMind`" - "`orderedWrongItem`" - "`other`"
         */
        reason?: string | null;
    }
    export interface Schema$OrdersCancelTestOrderByCustomerResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersCancelTestOrderByCustomerResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersCreateTestOrderRequest {
        /**
         * The CLDR territory code of the country of the test order to create. Affects the currency and addresses of orders created via `template_name`, or the addresses of orders created via `test_order`. Acceptable values are: - "`US`" - "`FR`" Defaults to `US`.
         */
        country?: string | null;
        /**
         * The test order template to use. Specify as an alternative to `testOrder` as a shortcut for retrieving a template and then creating an order using that template. Acceptable values are: - "`template1`" - "`template1a`" - "`template1b`" - "`template2`" - "`template3`"
         */
        templateName?: string | null;
        /**
         * The test order to create.
         */
        testOrder?: Schema$TestOrder;
    }
    export interface Schema$OrdersCreateTestOrderResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersCreateTestOrderResponse".
         */
        kind?: string | null;
        /**
         * The ID of the newly created test order.
         */
        orderId?: string | null;
    }
    export interface Schema$OrdersCreateTestReturnRequest {
        /**
         * Returned items.
         */
        items?: Schema$OrdersCustomBatchRequestEntryCreateTestReturnReturnItem[];
    }
    export interface Schema$OrdersCreateTestReturnResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersCreateTestReturnResponse".
         */
        kind?: string | null;
        /**
         * The ID of the newly created test order return.
         */
        returnId?: string | null;
    }
    export interface Schema$OrdersCustomBatchRequestEntryCreateTestReturnReturnItem {
        /**
         * The ID of the line item to return.
         */
        lineItemId?: string | null;
        /**
         * Quantity that is returned.
         */
        quantity?: number | null;
    }
    export interface Schema$OrdersCustomBatchRequestEntryRefundItemItem {
        /**
         * The total amount that is refunded. (e.g. refunding $5 each for 2 products should be done by setting quantity to 2 and amount to 10$) In case of multiple refunds, this should be the amount you currently want to refund to the customer.
         */
        amount?: Schema$MonetaryAmount;
        /**
         * If true, the full item will be refunded. If this is true, amount should not be provided and will be ignored.
         */
        fullRefund?: boolean | null;
        /**
         * The ID of the line item. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the product. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The number of products that are refunded.
         */
        quantity?: number | null;
    }
    export interface Schema$OrdersCustomBatchRequestEntryRefundItemShipping {
        /**
         * The amount that is refunded. If this is not the first refund for the shipment, this should be the newly refunded amount.
         */
        amount?: Schema$Price;
        /**
         * If set to true, all shipping costs for the order will be refunded. If this is true, amount should not be provided and will be ignored. If set to false, submit the amount of the partial shipping refund, excluding the shipping tax. The shipping tax is calculated and handled on Google's side.
         */
        fullRefund?: boolean | null;
    }
    export interface Schema$OrdersCustomBatchRequestEntryShipLineItemsShipmentInfo {
        /**
         * The carrier handling the shipment. See `shipments[].carrier` in the Orders resource representation for a list of acceptable values.
         */
        carrier?: string | null;
        /**
         * Required. The ID of the shipment. This is assigned by the merchant and is unique to each shipment.
         */
        shipmentId?: string | null;
        /**
         * The tracking ID for the shipment.
         */
        trackingId?: string | null;
    }
    /**
     * ScheduledDeliveryDetails used to update the scheduled delivery order.
     */
    export interface Schema$OrdersCustomBatchRequestEntryUpdateShipmentScheduledDeliveryDetails {
        /**
         * The phone number of the carrier fulfilling the delivery. The phone number should be formatted as the international notation in
         */
        carrierPhoneNumber?: string | null;
        /**
         * The date a shipment is scheduled for delivery, in ISO 8601 format.
         */
        scheduledDate?: string | null;
    }
    export interface Schema$OrdersGetByMerchantOrderIdResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersGetByMerchantOrderIdResponse".
         */
        kind?: string | null;
        /**
         * The requested order.
         */
        order?: Schema$Order;
    }
    export interface Schema$OrdersGetTestOrderTemplateResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersGetTestOrderTemplateResponse".
         */
        kind?: string | null;
        /**
         * The requested test order template.
         */
        template?: Schema$TestOrder;
    }
    export interface Schema$OrderShipment {
        /**
         * The carrier handling the shipment. For supported carriers, Google includes the carrier name and tracking URL in emails to customers. For select supported carriers, Google also automatically updates the shipment status based on the provided shipment ID. *Note:* You can also use unsupported carriers, but emails to customers will not include the carrier name or tracking URL, and there will be no automatic order status updates. Supported carriers for US are: - "`ups`" (United Parcel Service) *automatic status updates* - "`usps`" (United States Postal Service) *automatic status updates* - "`fedex`" (FedEx) *automatic status updates * - "`dhl`" (DHL eCommerce) *automatic status updates* (US only) - "`ontrac`" (OnTrac) *automatic status updates * - "`dhl express`" (DHL Express) - "`deliv`" (Deliv) - "`dynamex`" (TForce) - "`lasership`" (LaserShip) - "`mpx`" (Military Parcel Xpress) - "`uds`" (United Delivery Service) - "`efw`" (Estes Forwarding Worldwide) - "`jd logistics`" (JD Logistics) - "`yunexpress`" (YunExpress) - "`china post`" (China Post) - "`china ems`" (China Post Express Mail Service) - "`singapore post`" (Singapore Post) - "`pos malaysia`" (Pos Malaysia) - "`postnl`" (PostNL) - "`ptt`" (PTT Turkish Post) - "`eub`" (ePacket) - "`chukou1`" (Chukou1 Logistics) - "`bestex`" (Best Express) - "`canada post`" (Canada Post) - "`purolator`" (Purolator) - "`canpar`" (Canpar) - "`india post`" (India Post) - "`blue dart`" (Blue Dart) - "`delhivery`" (Delhivery) - "`dtdc`" (DTDC) - "`tpc india`" (TPC India) - "`lso`" (Lone Star Overnight) - "`tww`" (Team Worldwide) Supported carriers for FR are: - "`la poste`" (La Poste) *automatic status updates * - "`colissimo`" (Colissimo by La Poste) *automatic status updates* - "`ups`" (United Parcel Service) *automatic status updates * - "`chronopost`" (Chronopost by La Poste) - "`gls`" (General Logistics Systems France) - "`dpd`" (DPD Group by GeoPost) - "`bpost`" (Belgian Post Group) - "`colis prive`" (Colis Privé) - "`boxtal`" (Boxtal) - "`geodis`" (GEODIS) - "`tnt`" (TNT) - "`db schenker`" (DB Schenker) - "`aramex`" (Aramex)
         */
        carrier?: string | null;
        /**
         * Date on which the shipment has been created, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * Date on which the shipment has been delivered, in ISO 8601 format. Present only if `status` is `delivered`
         */
        deliveryDate?: string | null;
        /**
         * The ID of the shipment.
         */
        id?: string | null;
        /**
         * The line items that are shipped.
         */
        lineItems?: Schema$OrderShipmentLineItemShipment[];
        /**
         * Delivery details of the shipment if scheduling is needed.
         */
        scheduledDeliveryDetails?: Schema$OrderShipmentScheduledDeliveryDetails;
        /**
         * The shipment group ID of the shipment. This is set in shiplineitems request.
         */
        shipmentGroupId?: string | null;
        /**
         * The status of the shipment. Acceptable values are: - "`delivered`" - "`readyForPickup`" - "`shipped`" - "`undeliverable`"
         */
        status?: string | null;
        /**
         * The tracking ID for the shipment.
         */
        trackingId?: string | null;
    }
    export interface Schema$OrderShipmentLineItemShipment {
        /**
         * The ID of the line item that is shipped. This value is assigned by Google when an order is created. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the product to ship. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The quantity that is shipped.
         */
        quantity?: number | null;
    }
    export interface Schema$OrderShipmentScheduledDeliveryDetails {
        /**
         * The phone number of the carrier fulfilling the delivery. The phone number is formatted as the international notation in ITU-T Recommendation E.123 (e.g., "+41 44 668 1800").
         */
        carrierPhoneNumber?: string | null;
        /**
         * The date a shipment is scheduled for delivery, in ISO 8601 format.
         */
        scheduledDate?: string | null;
    }
    export interface Schema$OrdersInStoreRefundLineItemRequest {
        /**
         * The ID of the line item to return. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The amount to be refunded. This may be pre-tax or post-tax depending on the location of the order. Required.
         */
        priceAmount?: Schema$Price;
        /**
         * The ID of the product to return. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The quantity to return and refund.
         */
        quantity?: number | null;
        /**
         * The reason for the return. Acceptable values are: - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`deliveredTooLate`" - "`expiredItem`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`other`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`qualityNotAsExpected`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
        /**
         * The amount of tax to be refunded. Required.
         */
        taxAmount?: Schema$Price;
    }
    export interface Schema$OrdersInStoreRefundLineItemResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersInStoreRefundLineItemResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of orders.
         */
        nextPageToken?: string | null;
        resources?: Schema$Order[];
    }
    export interface Schema$OrdersRefundItemRequest {
        /**
         * The items that are refunded. Either Item or Shipping must be provided in the request.
         */
        items?: Schema$OrdersCustomBatchRequestEntryRefundItemItem[];
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The reason for the refund. Acceptable values are: - "`shippingCostAdjustment`" - "`priceAdjustment`" - "`taxAdjustment`" - "`feeAdjustment`" - "`courtesyAdjustment`" - "`adjustment`" - "`customerCancelled`" - "`noInventory`" - "`productNotAsDescribed`" - "`undeliverableShippingAddress`" - "`wrongProductShipped`" - "`lateShipmentCredit`" - "`deliveredLateByCarrier`" - "`productArrivedDamaged`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
        /**
         * The refund on shipping. Optional, but either Item or Shipping must be provided in the request.
         */
        shipping?: Schema$OrdersCustomBatchRequestEntryRefundItemShipping;
    }
    export interface Schema$OrdersRefundItemResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersRefundItemResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersRefundOrderRequest {
        /**
         * The amount that is refunded. If this is not the first refund for the order, this should be the newly refunded amount.
         */
        amount?: Schema$MonetaryAmount;
        /**
         * If true, the full order will be refunded, including shipping. If this is true, amount should not be provided and will be ignored.
         */
        fullRefund?: boolean | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The reason for the refund. Acceptable values are: - "`courtesyAdjustment`" - "`other`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrdersRefundOrderResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersRefundOrderResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersRejectReturnLineItemRequest {
        /**
         * The ID of the line item to return. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The ID of the product to return. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The quantity to return and refund.
         */
        quantity?: number | null;
        /**
         * The reason for the return. Acceptable values are: - "`damagedOrUsed`" - "`missingComponent`" - "`notEligible`" - "`other`" - "`outOfReturnWindow`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
    }
    export interface Schema$OrdersRejectReturnLineItemResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersRejectReturnLineItemResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersReturnRefundLineItemRequest {
        /**
         * The ID of the line item to return. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The amount to be refunded. This may be pre-tax or post-tax depending on the location of the order. If omitted, refundless return is assumed.
         */
        priceAmount?: Schema$Price;
        /**
         * The ID of the product to return. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * The quantity to return and refund. Quantity is required.
         */
        quantity?: number | null;
        /**
         * The reason for the return. Acceptable values are: - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`deliveredTooLate`" - "`expiredItem`" - "`invalidCoupon`" - "`malformedShippingAddress`" - "`other`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`qualityNotAsExpected`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reason?: string | null;
        /**
         * The explanation of the reason.
         */
        reasonText?: string | null;
        /**
         * The amount of tax to be refunded. Optional, but if filled, then priceAmount must be set. Calculated automatically if not provided.
         */
        taxAmount?: Schema$Price;
    }
    export interface Schema$OrdersReturnRefundLineItemResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersReturnRefundLineItemResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersSetLineItemMetadataRequest {
        annotations?: Schema$OrderMerchantProvidedAnnotation[];
        /**
         * The ID of the line item to set metadata. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The ID of the product to set metadata. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
    }
    export interface Schema$OrdersSetLineItemMetadataResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersSetLineItemMetadataResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersShipLineItemsRequest {
        /**
         * Line items to ship.
         */
        lineItems?: Schema$OrderShipmentLineItemShipment[];
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * ID of the shipment group. Required for orders that use the orderinvoices service.
         */
        shipmentGroupId?: string | null;
        /**
         * Shipment information. This field is repeated because a single line item can be shipped in several packages (and have several tracking IDs).
         */
        shipmentInfos?: Schema$OrdersCustomBatchRequestEntryShipLineItemsShipmentInfo[];
    }
    export interface Schema$OrdersShipLineItemsResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersShipLineItemsResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersUpdateLineItemShippingDetailsRequest {
        /**
         * Updated delivery by date, in ISO 8601 format. If not specified only ship by date is updated. Provided date should be within 1 year timeframe and can not be a date in the past.
         */
        deliverByDate?: string | null;
        /**
         * The ID of the line item to set metadata. Either lineItemId or productId is required.
         */
        lineItemId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * The ID of the product to set metadata. This is the REST ID used in the products service. Either lineItemId or productId is required.
         */
        productId?: string | null;
        /**
         * Updated ship by date, in ISO 8601 format. If not specified only deliver by date is updated. Provided date should be within 1 year timeframe and can not be a date in the past.
         */
        shipByDate?: string | null;
    }
    export interface Schema$OrdersUpdateLineItemShippingDetailsResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersUpdateLineItemShippingDetailsResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersUpdateMerchantOrderIdRequest {
        /**
         * The merchant order id to be assigned to the order. Must be unique per merchant.
         */
        merchantOrderId?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
    }
    export interface Schema$OrdersUpdateMerchantOrderIdResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersUpdateMerchantOrderIdResponse".
         */
        kind?: string | null;
    }
    export interface Schema$OrdersUpdateShipmentRequest {
        /**
         * The carrier handling the shipment. Not updated if missing. See `shipments[].carrier` in the Orders resource representation for a list of acceptable values.
         */
        carrier?: string | null;
        /**
         * Date on which the shipment has been delivered, in ISO 8601 format. Optional and can be provided only if `status` is `delivered`.
         */
        deliveryDate?: string | null;
        /**
         * Date after which the pickup will expire, in ISO 8601 format. Required only when order is buy-online-pickup-in-store(BOPIS) and `status` is `ready for pickup`.
         */
        lastPickupDate?: string | null;
        /**
         * The ID of the operation. Unique across all operations for a given order.
         */
        operationId?: string | null;
        /**
         * Date on which the shipment has been ready for pickup, in ISO 8601 format. Optional and can be provided only if `status` is `ready for pickup`.
         */
        readyPickupDate?: string | null;
        /**
         * Delivery details of the shipment if scheduling is needed.
         */
        scheduledDeliveryDetails?: Schema$OrdersCustomBatchRequestEntryUpdateShipmentScheduledDeliveryDetails;
        /**
         * The ID of the shipment.
         */
        shipmentId?: string | null;
        /**
         * New status for the shipment. Not updated if missing. Acceptable values are: - "`delivered`" - "`undeliverable`" - "`readyForPickup`"
         */
        status?: string | null;
        /**
         * The tracking ID for the shipment. Not updated if missing.
         */
        trackingId?: string | null;
        /**
         * Date on which the shipment has been undeliverable, in ISO 8601 format. Optional and can be provided only if `status` is `undeliverable`.
         */
        undeliveredDate?: string | null;
    }
    export interface Schema$OrdersUpdateShipmentResponse {
        /**
         * The status of the execution. Acceptable values are: - "`duplicate`" - "`executed`"
         */
        executionStatus?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#ordersUpdateShipmentResponse".
         */
        kind?: string | null;
    }
    /**
     * Represents a merchant trade from which signals are extracted, e.g. shipping.
     */
    export interface Schema$OrderTrackingSignal {
        /**
         * The shipping fee of the order; this value should be set to zero in the case of free shipping.
         */
        customerShippingFee?: Schema$PriceAmount;
        /**
         * Required. The delivery postal code, as a continuous string without spaces or dashes, e.g. "95016". This field will be anonymized in returned OrderTrackingSignal creation response.
         */
        deliveryPostalCode?: string | null;
        /**
         * Required. The [CLDR territory code] (http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) for the shipping destination.
         */
        deliveryRegionCode?: string | null;
        /**
         * Information about line items in the order.
         */
        lineItems?: Schema$OrderTrackingSignalLineItemDetails[];
        /**
         * The Google merchant ID of this order tracking signal. This value is optional. If left unset, the caller's merchant ID is used. You must request access in order to provide data on behalf of another merchant. For more information, see [Submitting Order Tracking Signals](/shopping-content/guides/order-tracking-signals).
         */
        merchantId?: string | null;
        /**
         * Required. The time when the order was created on the merchant side. Include the year and timezone string, if available.
         */
        orderCreatedTime?: Schema$DateTime;
        /**
         * Required. The ID of the order on the merchant side. This field will be hashed in returned OrderTrackingSignal creation response.
         */
        orderId?: string | null;
        /**
         * Output only. The ID that uniquely identifies this order tracking signal.
         */
        orderTrackingSignalId?: string | null;
        /**
         * The mapping of the line items to the shipment information.
         */
        shipmentLineItemMapping?: Schema$OrderTrackingSignalShipmentLineItemMapping[];
        /**
         * The shipping information for the order.
         */
        shippingInfo?: Schema$OrderTrackingSignalShippingInfo[];
    }
    /**
     * The line items of the order.
     */
    export interface Schema$OrderTrackingSignalLineItemDetails {
        /**
         * The Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. The ID for this line item.
         */
        lineItemId?: string | null;
        /**
         * The manufacturer part number.
         */
        mpn?: string | null;
        /**
         * Required. The Content API REST ID of the product, in the form channel:contentLanguage:targetCountry:offerId.
         */
        productId?: string | null;
        /**
         * Required. The quantity of the line item in the order.
         */
        quantity?: string | null;
    }
    /**
     * Represents how many items are in the shipment for the given shipment_id and line_item_id.
     */
    export interface Schema$OrderTrackingSignalShipmentLineItemMapping {
        /**
         * Required. The line item ID.
         */
        lineItemId?: string | null;
        /**
         * Required. The line item quantity in the shipment.
         */
        quantity?: string | null;
        /**
         * Required. The shipment ID. This field will be hashed in returned OrderTrackingSignal creation response.
         */
        shipmentId?: string | null;
    }
    /**
     * The shipping information for the order.
     */
    export interface Schema$OrderTrackingSignalShippingInfo {
        /**
         * The time when the shipment was actually delivered. Include the year and timezone string, if available. This field is required, if one of the following fields is absent: tracking_id or carrier_name.
         */
        actualDeliveryTime?: Schema$DateTime;
        /**
         * The name of the shipping carrier for the delivery. This field is required if one of the following fields is absent: earliest_delivery_promise_time, latest_delivery_promise_time, and actual_delivery_time.
         */
        carrierName?: string | null;
        /**
         * The service type for fulfillment, e.g., GROUND, FIRST_CLASS, etc.
         */
        carrierServiceName?: string | null;
        /**
         * The earliest delivery promised time. Include the year and timezone string, if available. This field is required, if one of the following fields is absent: tracking_id or carrier_name.
         */
        earliestDeliveryPromiseTime?: Schema$DateTime;
        /**
         * The latest delivery promised time. Include the year and timezone string, if available. This field is required, if one of the following fields is absent: tracking_id or carrier_name.
         */
        latestDeliveryPromiseTime?: Schema$DateTime;
        /**
         * The origin postal code, as a continuous string without spaces or dashes, e.g. "95016". This field will be anonymized in returned OrderTrackingSignal creation response.
         */
        originPostalCode?: string | null;
        /**
         * The [CLDR territory code] (http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) for the shipping origin.
         */
        originRegionCode?: string | null;
        /**
         * Required. The shipment ID. This field will be hashed in returned OrderTrackingSignal creation response.
         */
        shipmentId?: string | null;
        /**
         * The time when the shipment was shipped. Include the year and timezone string, if available.
         */
        shippedTime?: Schema$DateTime;
        /**
         * The status of the shipment.
         */
        shippingStatus?: string | null;
        /**
         * The tracking ID of the shipment. This field is required if one of the following fields is absent: earliest_delivery_promise_time, latest_delivery_promise_time, and actual_delivery_time.
         */
        trackingId?: string | null;
    }
    /**
     * Request message for the PauseProgram method.
     */
    export interface Schema$PauseBuyOnGoogleProgramRequest {
    }
    /**
     * Additional information required for PAYMENT_SERVICE_PROVIDER link type.
     */
    export interface Schema$PaymentServiceProviderLinkInfo {
        /**
         * The business country of the merchant account as identified by the third party service provider.
         */
        externalAccountBusinessCountry?: string | null;
        /**
         * The id used by the third party service provider to identify the merchant.
         */
        externalAccountId?: string | null;
    }
    export interface Schema$PickupCarrierService {
        /**
         * The name of the pickup carrier (e.g., `"UPS"`). Required.
         */
        carrierName?: string | null;
        /**
         * The name of the pickup service (e.g., `"Access point"`). Required.
         */
        serviceName?: string | null;
    }
    export interface Schema$PickupServicesPickupService {
        /**
         * The name of the carrier (e.g., `"UPS"`). Always present.
         */
        carrierName?: string | null;
        /**
         * The CLDR country code of the carrier (e.g., "US"). Always present.
         */
        country?: string | null;
        /**
         * The name of the pickup service (e.g., `"Access point"`). Always present.
         */
        serviceName?: string | null;
    }
    export interface Schema$PosCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$PosCustomBatchRequestEntry[];
    }
    export interface Schema$PosCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The inventory to submit. This should be set only if the method is `inventory`.
         */
        inventory?: Schema$PosInventory;
        /**
         * The ID of the POS data provider.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`delete`" - "`get`" - "`insert`" - "`inventory`" - "`sale`"
         */
        method?: string | null;
        /**
         * The sale information to submit. This should be set only if the method is `sale`.
         */
        sale?: Schema$PosSale;
        /**
         * The store information to submit. This should be set only if the method is `insert`.
         */
        store?: Schema$PosStore;
        /**
         * The store code. This should be set only if the method is `delete` or `get`.
         */
        storeCode?: string | null;
        /**
         * The ID of the account for which to get/submit data.
         */
        targetMerchantId?: string | null;
    }
    export interface Schema$PosCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$PosCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#posCustomBatchResponse".
         */
        kind?: string | null;
    }
    export interface Schema$PosCustomBatchResponseEntry {
        /**
         * The ID of the request entry to which this entry responds.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if, and only if, the request failed.
         */
        errors?: Schema$Errors;
        /**
         * The updated inventory information.
         */
        inventory?: Schema$PosInventory;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#posCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The updated sale information.
         */
        sale?: Schema$PosSale;
        /**
         * The retrieved or updated store information.
         */
        store?: Schema$PosStore;
    }
    export interface Schema$PosDataProviders {
        /**
         * Country code.
         */
        country?: string | null;
        /**
         * A list of POS data providers.
         */
        posDataProviders?: Schema$PosDataProvidersPosDataProvider[];
    }
    export interface Schema$PosDataProvidersPosDataProvider {
        /**
         * The display name of Pos data Provider.
         */
        displayName?: string | null;
        /**
         * The full name of this POS data Provider.
         */
        fullName?: string | null;
        /**
         * The ID of the account.
         */
        providerId?: string | null;
    }
    /**
     * The absolute quantity of an item available at the given store.
     */
    export interface Schema$PosInventory {
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. A unique identifier for the item.
         */
        itemId?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#posInventory`"
         */
        kind?: string | null;
        /**
         * Required. The current price of the item.
         */
        price?: Schema$Price;
        /**
         * Required. The available quantity of the item.
         */
        quantity?: string | null;
        /**
         * Required. The identifier of the merchant's store. Either a `storeCode` inserted via the API or the code of the store in Google My Business.
         */
        storeCode?: string | null;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * Required. The inventory timestamp, in ISO 8601 format.
         */
        timestamp?: string | null;
    }
    export interface Schema$PosInventoryRequest {
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. A unique identifier for the item.
         */
        itemId?: string | null;
        /**
         * Required. The current price of the item.
         */
        price?: Schema$Price;
        /**
         * Required. The available quantity of the item.
         */
        quantity?: string | null;
        /**
         * Required. The identifier of the merchant's store. Either a `storeCode` inserted via the API or the code of the store in Google My Business.
         */
        storeCode?: string | null;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * Required. The inventory timestamp, in ISO 8601 format.
         */
        timestamp?: string | null;
    }
    export interface Schema$PosInventoryResponse {
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. A unique identifier for the item.
         */
        itemId?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#posInventoryResponse".
         */
        kind?: string | null;
        /**
         * Required. The current price of the item.
         */
        price?: Schema$Price;
        /**
         * Required. The available quantity of the item.
         */
        quantity?: string | null;
        /**
         * Required. The identifier of the merchant's store. Either a `storeCode` inserted via the API or the code of the store in Google My Business.
         */
        storeCode?: string | null;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * Required. The inventory timestamp, in ISO 8601 format.
         */
        timestamp?: string | null;
    }
    export interface Schema$PosListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#posListResponse".
         */
        kind?: string | null;
        resources?: Schema$PosStore[];
    }
    /**
     * The change of the available quantity of an item at the given store.
     */
    export interface Schema$PosSale {
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. A unique identifier for the item.
         */
        itemId?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#posSale`"
         */
        kind?: string | null;
        /**
         * Required. The price of the item.
         */
        price?: Schema$Price;
        /**
         * Required. The relative change of the available quantity. Negative for items returned.
         */
        quantity?: string | null;
        /**
         * A unique ID to group items from the same sale event.
         */
        saleId?: string | null;
        /**
         * Required. The identifier of the merchant's store. Either a `storeCode` inserted via the API or the code of the store in Google My Business.
         */
        storeCode?: string | null;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * Required. The inventory timestamp, in ISO 8601 format.
         */
        timestamp?: string | null;
    }
    export interface Schema$PosSaleRequest {
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. A unique identifier for the item.
         */
        itemId?: string | null;
        /**
         * Required. The price of the item.
         */
        price?: Schema$Price;
        /**
         * Required. The relative change of the available quantity. Negative for items returned.
         */
        quantity?: string | null;
        /**
         * A unique ID to group items from the same sale event.
         */
        saleId?: string | null;
        /**
         * Required. The identifier of the merchant's store. Either a `storeCode` inserted via the API or the code of the store in Google My Business.
         */
        storeCode?: string | null;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * Required. The inventory timestamp, in ISO 8601 format.
         */
        timestamp?: string | null;
    }
    export interface Schema$PosSaleResponse {
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Global Trade Item Number.
         */
        gtin?: string | null;
        /**
         * Required. A unique identifier for the item.
         */
        itemId?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#posSaleResponse".
         */
        kind?: string | null;
        /**
         * Required. The price of the item.
         */
        price?: Schema$Price;
        /**
         * Required. The relative change of the available quantity. Negative for items returned.
         */
        quantity?: string | null;
        /**
         * A unique ID to group items from the same sale event.
         */
        saleId?: string | null;
        /**
         * Required. The identifier of the merchant's store. Either a `storeCode` inserted via the API or the code of the store in Google My Business.
         */
        storeCode?: string | null;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * Required. The inventory timestamp, in ISO 8601 format.
         */
        timestamp?: string | null;
    }
    /**
     * Store resource.
     */
    export interface Schema$PosStore {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#posStore`"
         */
        kind?: string | null;
        /**
         * Required. The street address of the store.
         */
        storeAddress?: string | null;
        /**
         * Required. A store identifier that is unique for the given merchant.
         */
        storeCode?: string | null;
    }
    export interface Schema$PostalCodeGroup {
        /**
         * The CLDR territory code of the country the postal code group applies to. Required.
         */
        country?: string | null;
        /**
         * The name of the postal code group, referred to in headers. Required.
         */
        name?: string | null;
        /**
         * A range of postal codes. Required.
         */
        postalCodeRanges?: Schema$PostalCodeRange[];
    }
    export interface Schema$PostalCodeRange {
        /**
         * A postal code or a pattern of the form `prefix*` denoting the inclusive lower bound of the range defining the area. Examples values: `"94108"`, `"9410*"`, `"9*"`. Required.
         */
        postalCodeRangeBegin?: string | null;
        /**
         * A postal code or a pattern of the form `prefix*` denoting the inclusive upper bound of the range defining the area. It must have the same length as `postalCodeRangeBegin`: if `postalCodeRangeBegin` is a postal code then `postalCodeRangeEnd` must be a postal code too; if `postalCodeRangeBegin` is a pattern then `postalCodeRangeEnd` must be a pattern with the same prefix length. Optional: if not set, then the area is defined as being all the postal codes matching `postalCodeRangeBegin`.
         */
        postalCodeRangeEnd?: string | null;
    }
    export interface Schema$Price {
        /**
         * The currency of the price.
         */
        currency?: string | null;
        /**
         * The price represented as a number.
         */
        value?: string | null;
    }
    /**
     * The price represented as a number and currency.
     */
    export interface Schema$PriceAmount {
        /**
         * The currency of the price.
         */
        currency?: string | null;
        /**
         * The price represented as a number.
         */
        value?: string | null;
    }
    /**
     *  Required product attributes are primarily defined by the products data specification. See the Products Data Specification Help Center article for information. Product data. After inserting, updating, or deleting a product, it may take several minutes before changes take effect.
     */
    export interface Schema$Product {
        /**
         * Additional URLs of images of the item.
         */
        additionalImageLinks?: string[] | null;
        /**
         * Additional cut of the item. Used together with size_type to represent combined size types for apparel items.
         */
        additionalSizeType?: string | null;
        /**
         * Used to group items in an arbitrary way. Only for CPA%, discouraged otherwise.
         */
        adsGrouping?: string | null;
        /**
         * Similar to ads_grouping, but only works on CPC.
         */
        adsLabels?: string[] | null;
        /**
         * Allows advertisers to override the item URL when the product is shown within the context of Product Ads.
         */
        adsRedirect?: string | null;
        /**
         * Should be set to true if the item is targeted towards adults.
         */
        adult?: boolean | null;
        /**
         * Target age group of the item.
         */
        ageGroup?: string | null;
        /**
         * Availability status of the item.
         */
        availability?: string | null;
        /**
         * The day a pre-ordered product becomes available for delivery, in ISO 8601 format.
         */
        availabilityDate?: string | null;
        /**
         * Brand of the item.
         */
        brand?: string | null;
        /**
         * URL for the canonical version of your item's landing page.
         */
        canonicalLink?: string | null;
        /**
         * Required. The item's channel (online or local). Acceptable values are: - "`local`" - "`online`"
         */
        channel?: string | null;
        /**
         * Color of the item.
         */
        color?: string | null;
        /**
         * Condition or state of the item.
         */
        condition?: string | null;
        /**
         * Required. The two-letter ISO 639-1 language code for the item.
         */
        contentLanguage?: string | null;
        /**
         * Cost of goods sold. Used for gross profit reporting.
         */
        costOfGoodsSold?: Schema$Price;
        /**
         * A list of custom (merchant-provided) attributes. It can also be used for submitting any attribute of the feed specification in its generic form (e.g., `{ "name": "size type", "value": "regular" \}`). This is useful for submitting attributes not explicitly exposed by the API, such as additional attributes used for Buy on Google (formerly known as Shopping Actions).
         */
        customAttributes?: Schema$CustomAttribute[];
        /**
         * Custom label 0 for custom grouping of items in a Shopping campaign.
         */
        customLabel0?: string | null;
        /**
         * Custom label 1 for custom grouping of items in a Shopping campaign.
         */
        customLabel1?: string | null;
        /**
         * Custom label 2 for custom grouping of items in a Shopping campaign.
         */
        customLabel2?: string | null;
        /**
         * Custom label 3 for custom grouping of items in a Shopping campaign.
         */
        customLabel3?: string | null;
        /**
         * Custom label 4 for custom grouping of items in a Shopping campaign.
         */
        customLabel4?: string | null;
        /**
         * Description of the item.
         */
        description?: string | null;
        /**
         * An identifier for an item for dynamic remarketing campaigns.
         */
        displayAdsId?: string | null;
        /**
         * URL directly to your item's landing page for dynamic remarketing campaigns.
         */
        displayAdsLink?: string | null;
        /**
         * Advertiser-specified recommendations.
         */
        displayAdsSimilarIds?: string[] | null;
        /**
         * Title of an item for dynamic remarketing campaigns.
         */
        displayAdsTitle?: string | null;
        /**
         * Offer margin for dynamic remarketing campaigns.
         */
        displayAdsValue?: number | null;
        /**
         * The energy efficiency class as defined in EU directive 2010/30/EU.
         */
        energyEfficiencyClass?: string | null;
        /**
         * The list of destinations to exclude for this target (corresponds to unchecked check boxes in Merchant Center).
         */
        excludedDestinations?: string[] | null;
        /**
         * Date on which the item should expire, as specified upon insertion, in ISO 8601 format. The actual expiration date in Google Shopping is exposed in `productstatuses` as `googleExpirationDate` and might be earlier if `expirationDate` is too far in the future.
         */
        expirationDate?: string | null;
        /**
         * Target gender of the item.
         */
        gender?: string | null;
        /**
         * Google's category of the item (see [Google product taxonomy](https://support.google.com/merchants/answer/1705911)). When querying products, this field will contain the user provided value. There is currently no way to get back the auto assigned google product categories through the API.
         */
        googleProductCategory?: string | null;
        /**
         * Global Trade Item Number (GTIN) of the item.
         */
        gtin?: string | null;
        /**
         * The REST ID of the product. Content API methods that operate on products take this as their `productId` parameter. The REST ID for a product is of the form channel:contentLanguage: targetCountry: offerId.
         */
        id?: string | null;
        /**
         * False when the item does not have unique product identifiers appropriate to its category, such as GTIN, MPN, and brand. Required according to the Unique Product Identifier Rules for all target countries except for Canada.
         */
        identifierExists?: boolean | null;
        /**
         * URL of an image of the item.
         */
        imageLink?: string | null;
        /**
         * The list of destinations to include for this target (corresponds to checked check boxes in Merchant Center). Default destinations are always included unless provided in `excludedDestinations`.
         */
        includedDestinations?: string[] | null;
        /**
         * Number and amount of installments to pay for an item.
         */
        installment?: Schema$Installment;
        /**
         * Whether the item is a merchant-defined bundle. A bundle is a custom grouping of different products sold by a merchant for a single price.
         */
        isBundle?: boolean | null;
        /**
         * Shared identifier for all variants of the same product.
         */
        itemGroupId?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#product`"
         */
        kind?: string | null;
        /**
         * URL directly linking to your item's page on your website.
         */
        link?: string | null;
        /**
         * URL template for merchant hosted local storefront.
         */
        linkTemplate?: string | null;
        /**
         * Loyalty points that users receive after purchasing the item. Japan only.
         */
        loyaltyPoints?: Schema$LoyaltyPoints;
        /**
         * The material of which the item is made.
         */
        material?: string | null;
        /**
         * The energy efficiency class as defined in EU directive 2010/30/EU.
         */
        maxEnergyEfficiencyClass?: string | null;
        /**
         * Maximal product handling time (in business days).
         */
        maxHandlingTime?: string | null;
        /**
         * The energy efficiency class as defined in EU directive 2010/30/EU.
         */
        minEnergyEfficiencyClass?: string | null;
        /**
         * Minimal product handling time (in business days).
         */
        minHandlingTime?: string | null;
        /**
         * URL for the mobile-optimized version of your item's landing page.
         */
        mobileLink?: string | null;
        /**
         * URL template for merchant hosted local storefront optimized for mobile devices.
         */
        mobileLinkTemplate?: string | null;
        /**
         * Manufacturer Part Number (MPN) of the item.
         */
        mpn?: string | null;
        /**
         * The number of identical products in a merchant-defined multipack.
         */
        multipack?: string | null;
        /**
         * Required. A unique identifier for the item. Leading and trailing whitespaces are stripped and multiple whitespaces are replaced by a single whitespace upon submission. Only valid unicode characters are accepted. See the products feed specification for details. *Note:* Content API methods that operate on products take the REST ID of the product, *not* this identifier.
         */
        offerId?: string | null;
        /**
         * The item's pattern (e.g. polka dots).
         */
        pattern?: string | null;
        /**
         * The pick up option for the item. Acceptable values are: - "`buy`" - "`reserve`" - "`ship to store`" - "`not supported`"
         */
        pickupMethod?: string | null;
        /**
         * Item store pickup timeline. Acceptable values are: - "`same day`" - "`next day`" - "`2-day`" - "`3-day`" - "`4-day`" - "`5-day`" - "`6-day`" - "`7-day`" - "`multi-week`"
         */
        pickupSla?: string | null;
        /**
         * Price of the item.
         */
        price?: Schema$Price;
        /**
         * Technical specification or additional product details.
         */
        productDetails?: Schema$ProductProductDetail[];
        /**
         * Bullet points describing the most relevant highlights of a product.
         */
        productHighlights?: string[] | null;
        /**
         * Categories of the item (formatted as in products data specification).
         */
        productTypes?: string[] | null;
        /**
         * The unique ID of a promotion.
         */
        promotionIds?: string[] | null;
        /**
         * Advertised sale price of the item.
         */
        salePrice?: Schema$Price;
        /**
         * Date range during which the item is on sale (see products data specification ).
         */
        salePriceEffectiveDate?: string | null;
        /**
         * The quantity of the product that is available for selling on Google. Supported only for online products.
         */
        sellOnGoogleQuantity?: string | null;
        /**
         * Shipping rules.
         */
        shipping?: Schema$ProductShipping[];
        /**
         * Height of the item for shipping.
         */
        shippingHeight?: Schema$ProductShippingDimension;
        /**
         * The shipping label of the product, used to group product in account-level shipping rules.
         */
        shippingLabel?: string | null;
        /**
         * Length of the item for shipping.
         */
        shippingLength?: Schema$ProductShippingDimension;
        /**
         * Weight of the item for shipping.
         */
        shippingWeight?: Schema$ProductShippingWeight;
        /**
         * Width of the item for shipping.
         */
        shippingWidth?: Schema$ProductShippingDimension;
        /**
         * List of country codes (ISO 3166-1 alpha-2) to exclude the offer from Shopping Ads destination. Countries from this list are removed from countries configured in MC feed settings.
         */
        shoppingAdsExcludedCountries?: string[] | null;
        /**
         * Size of the item. Only one value is allowed. For variants with different sizes, insert a separate product for each size with the same `itemGroupId` value (see size definition).
         */
        sizes?: string[] | null;
        /**
         * System in which the size is specified. Recommended for apparel items.
         */
        sizeSystem?: string | null;
        /**
         * The cut of the item. Recommended for apparel items.
         */
        sizeType?: string | null;
        /**
         * The source of the offer, i.e., how the offer was created. Acceptable values are: - "`api`" - "`crawl`" - "`feed`"
         */
        source?: string | null;
        /**
         * Number of periods (months or years) and amount of payment per period for an item with an associated subscription contract.
         */
        subscriptionCost?: Schema$ProductSubscriptionCost;
        /**
         * Required. The CLDR territory code for the item.
         */
        targetCountry?: string | null;
        /**
         * The tax category of the product, used to configure detailed tax nexus in account-level tax settings.
         */
        taxCategory?: string | null;
        /**
         * Tax information.
         */
        taxes?: Schema$ProductTax[];
        /**
         * Title of the item.
         */
        title?: string | null;
        /**
         * The transit time label of the product, used to group product in account-level transit time tables.
         */
        transitTimeLabel?: string | null;
        /**
         * The preference of the denominator of the unit price.
         */
        unitPricingBaseMeasure?: Schema$ProductUnitPricingBaseMeasure;
        /**
         * The measure and dimension of an item.
         */
        unitPricingMeasure?: Schema$ProductUnitPricingMeasure;
    }
    export interface Schema$ProductAmount {
        /**
         * The pre-tax or post-tax price depending on the location of the order.
         */
        priceAmount?: Schema$Price;
        /**
         * Remitted tax value.
         */
        remittedTaxAmount?: Schema$Price;
        /**
         * Tax value.
         */
        taxAmount?: Schema$Price;
    }
    export interface Schema$ProductProductDetail {
        /**
         * The name of the product detail.
         */
        attributeName?: string | null;
        /**
         * The value of the product detail.
         */
        attributeValue?: string | null;
        /**
         * The section header used to group a set of product details.
         */
        sectionName?: string | null;
    }
    export interface Schema$ProductsCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$ProductsCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch products request.
     */
    export interface Schema$ProductsCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The Content API feed id.
         */
        feedId?: string | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`delete`" - "`get`" - "`insert`" - "`update`"
         */
        method?: string | null;
        /**
         * The product to insert. Only required if the method is `insert`.
         */
        product?: Schema$Product;
        /**
         * The ID of the product to get or delete. Only defined if the method is `get` or `delete`.
         */
        productId?: string | null;
        /**
         * The comma-separated list of product attributes to be updated. Example: `"title,salePrice"`. Attributes specified in the update mask without a value specified in the body will be deleted from the product. Only top-level product attributes can be updated. If not defined, product attributes with set values will be updated and other attributes will stay unchanged. Only defined if the method is `update`.
         */
        updateMask?: string | null;
    }
    export interface Schema$ProductsCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$ProductsCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#productsCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch products response.
     */
    export interface Schema$ProductsCustomBatchResponseEntry {
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#productsCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The inserted product. Only defined if the method is `insert` and if the request was successful.
         */
        product?: Schema$Product;
    }
    export interface Schema$ProductShipping {
        /**
         * The CLDR territory code of the country to which an item will ship.
         */
        country?: string | null;
        /**
         * The location where the shipping is applicable, represented by a location group name.
         */
        locationGroupName?: string | null;
        /**
         * The numeric ID of a location that the shipping rate applies to as defined in the AdWords API.
         */
        locationId?: string | null;
        /**
         * Maximum handling time (inclusive) between when the order is received and shipped in business days. 0 means that the order is shipped on the same day as it is received if it happens before the cut-off time. Both maxHandlingTime and maxTransitTime are required if providing shipping speeds.
         */
        maxHandlingTime?: string | null;
        /**
         * Maximum transit time (inclusive) between when the order has shipped and when it is delivered in business days. 0 means that the order is delivered on the same day as it ships. Both maxHandlingTime and maxTransitTime are required if providing shipping speeds.
         */
        maxTransitTime?: string | null;
        /**
         * Minimum handling time (inclusive) between when the order is received and shipped in business days. 0 means that the order is shipped on the same day as it is received if it happens before the cut-off time. minHandlingTime can only be present together with maxHandlingTime; but it is not required if maxHandlingTime is present.
         */
        minHandlingTime?: string | null;
        /**
         * Minimum transit time (inclusive) between when the order has shipped and when it is delivered in business days. 0 means that the order is delivered on the same day as it ships. minTransitTime can only be present together with maxTransitTime; but it is not required if maxTransitTime is present.
         */
        minTransitTime?: string | null;
        /**
         * The postal code range that the shipping rate applies to, represented by a postal code, a postal code prefix followed by a * wildcard, a range between two postal codes or two postal code prefixes of equal length.
         */
        postalCode?: string | null;
        /**
         * Fixed shipping price, represented as a number.
         */
        price?: Schema$Price;
        /**
         * The geographic region to which a shipping rate applies.
         */
        region?: string | null;
        /**
         * A free-form description of the service class or delivery speed.
         */
        service?: string | null;
    }
    export interface Schema$ProductShippingDimension {
        /**
         * The unit of value.
         */
        unit?: string | null;
        /**
         * The dimension of the product used to calculate the shipping cost of the item.
         */
        value?: number | null;
    }
    export interface Schema$ProductShippingWeight {
        /**
         * The unit of value.
         */
        unit?: string | null;
        /**
         * The weight of the product used to calculate the shipping cost of the item.
         */
        value?: number | null;
    }
    export interface Schema$ProductsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#productsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of products.
         */
        nextPageToken?: string | null;
        resources?: Schema$Product[];
    }
    /**
     * The status of a product, i.e., information about a product computed asynchronously.
     */
    export interface Schema$ProductStatus {
        /**
         * Date on which the item has been created, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * The intended destinations for the product.
         */
        destinationStatuses?: Schema$ProductStatusDestinationStatus[];
        /**
         * Date on which the item expires in Google Shopping, in ISO 8601 format.
         */
        googleExpirationDate?: string | null;
        /**
         * A list of all issues associated with the product.
         */
        itemLevelIssues?: Schema$ProductStatusItemLevelIssue[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#productStatus`"
         */
        kind?: string | null;
        /**
         * Date on which the item has been last updated, in ISO 8601 format.
         */
        lastUpdateDate?: string | null;
        /**
         * The link to the product.
         */
        link?: string | null;
        /**
         * The ID of the product for which status is reported.
         */
        productId?: string | null;
        /**
         * The title of the product.
         */
        title?: string | null;
    }
    export interface Schema$ProductStatusDestinationStatus {
        /**
         * List of country codes (ISO 3166-1 alpha-2) where the offer is approved.
         */
        approvedCountries?: string[] | null;
        /**
         * The name of the destination
         */
        destination?: string | null;
        /**
         * List of country codes (ISO 3166-1 alpha-2) where the offer is disapproved.
         */
        disapprovedCountries?: string[] | null;
        /**
         * List of country codes (ISO 3166-1 alpha-2) where the offer is pending approval.
         */
        pendingCountries?: string[] | null;
        /**
         * Destination approval status in `targetCountry` of the offer.
         */
        status?: string | null;
    }
    export interface Schema$ProductstatusesCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$ProductstatusesCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch productstatuses request.
     */
    export interface Schema$ProductstatusesCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         */
        destinations?: string[] | null;
        includeAttributes?: boolean | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`get`"
         */
        method?: string | null;
        /**
         * The ID of the product whose status to get.
         */
        productId?: string | null;
    }
    export interface Schema$ProductstatusesCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$ProductstatusesCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#productstatusesCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch productstatuses response.
     */
    export interface Schema$ProductstatusesCustomBatchResponseEntry {
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors, if the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#productstatusesCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The requested product status. Only defined if the request was successful.
         */
        productStatus?: Schema$ProductStatus;
    }
    export interface Schema$ProductstatusesListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#productstatusesListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of products statuses.
         */
        nextPageToken?: string | null;
        resources?: Schema$ProductStatus[];
    }
    export interface Schema$ProductStatusItemLevelIssue {
        /**
         * List of country codes (ISO 3166-1 alpha-2) where issue applies to the offer.
         */
        applicableCountries?: string[] | null;
        /**
         * The attribute's name, if the issue is caused by a single attribute.
         */
        attributeName?: string | null;
        /**
         * The error code of the issue.
         */
        code?: string | null;
        /**
         * A short issue description in English.
         */
        description?: string | null;
        /**
         * The destination the issue applies to.
         */
        destination?: string | null;
        /**
         * A detailed issue description in English.
         */
        detail?: string | null;
        /**
         * The URL of a web page to help with resolving this issue.
         */
        documentation?: string | null;
        /**
         * Whether the issue can be resolved by the merchant.
         */
        resolution?: string | null;
        /**
         * How this issue affects serving of the offer.
         */
        servability?: string | null;
    }
    export interface Schema$ProductSubscriptionCost {
        /**
         * The amount the buyer has to pay per subscription period.
         */
        amount?: Schema$Price;
        /**
         * The type of subscription period.
         */
        period?: string | null;
        /**
         * The number of subscription periods the buyer has to pay.
         */
        periodLength?: string | null;
    }
    export interface Schema$ProductTax {
        /**
         * The country within which the item is taxed, specified as a CLDR territory code.
         */
        country?: string | null;
        /**
         * The numeric ID of a location that the tax rate applies to as defined in the AdWords API.
         */
        locationId?: string | null;
        /**
         * The postal code range that the tax rate applies to, represented by a ZIP code, a ZIP code prefix using * wildcard, a range between two ZIP codes or two ZIP code prefixes of equal length. Examples: 94114, 94*, 94002-95460, 94*-95*.
         */
        postalCode?: string | null;
        /**
         * The percentage of tax rate that applies to the item price.
         */
        rate?: number | null;
        /**
         * The geographic region to which the tax rate applies.
         */
        region?: string | null;
        /**
         * Should be set to true if tax is charged on shipping.
         */
        taxShip?: boolean | null;
    }
    export interface Schema$ProductUnitPricingBaseMeasure {
        /**
         * The unit of the denominator.
         */
        unit?: string | null;
        /**
         * The denominator of the unit price.
         */
        value?: string | null;
    }
    export interface Schema$ProductUnitPricingMeasure {
        /**
         * The unit of the measure.
         */
        unit?: string | null;
        /**
         * The measure of an item.
         */
        value?: number | null;
    }
    /**
     * Settings for Pub/Sub notifications, all methods require that the caller is a direct user of the merchant center account.
     */
    export interface Schema$PubsubNotificationSettings {
        /**
         * Cloud pub/sub topic to which notifications are sent (read-only).
         */
        cloudTopicName?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#pubsubNotificationSettings`"
         */
        kind?: string | null;
        /**
         * List of event types. Acceptable values are: - "`orderPendingShipment`"
         */
        registeredEvents?: string[] | null;
    }
    export interface Schema$RateGroup {
        /**
         * A list of shipping labels defining the products to which this rate group applies to. This is a disjunction: only one of the labels has to match for the rate group to apply. May only be empty for the last rate group of a service. Required.
         */
        applicableShippingLabels?: string[] | null;
        /**
         * A list of carrier rates that can be referred to by `mainTable` or `singleValue`.
         */
        carrierRates?: Schema$CarrierRate[];
        /**
         * A table defining the rate group, when `singleValue` is not expressive enough. Can only be set if `singleValue` is not set.
         */
        mainTable?: Schema$Table;
        /**
         * Name of the rate group. Optional. If set has to be unique within shipping service.
         */
        name?: string | null;
        /**
         * The value of the rate group (e.g. flat rate $10). Can only be set if `mainTable` and `subtables` are not set.
         */
        singleValue?: Schema$Value;
        /**
         * A list of subtables referred to by `mainTable`. Can only be set if `mainTable` is set.
         */
        subtables?: Schema$Table[];
    }
    export interface Schema$RefundReason {
        /**
         * Description of the reason.
         */
        description?: string | null;
        /**
         * Code of the refund reason. Acceptable values are: - "`adjustment`" - "`autoPostInternal`" - "`autoPostInvalidBillingAddress`" - "`autoPostNoInventory`" - "`autoPostPriceError`" - "`autoPostUndeliverableShippingAddress`" - "`couponAbuse`" - "`courtesyAdjustment`" - "`customerCanceled`" - "`customerDiscretionaryReturn`" - "`customerInitiatedMerchantCancel`" - "`customerSupportRequested`" - "`deliveredLateByCarrier`" - "`deliveredTooLate`" - "`expiredItem`" - "`failToPushOrderGoogleError`" - "`failToPushOrderMerchantError`" - "`failToPushOrderMerchantFulfillmentError`" - "`failToPushOrderToMerchant`" - "`failToPushOrderToMerchantOutOfStock`" - "`feeAdjustment`" - "`invalidCoupon`" - "`lateShipmentCredit`" - "`malformedShippingAddress`" - "`merchantDidNotShipOnTime`" - "`noInventory`" - "`orderTimeout`" - "`other`" - "`paymentAbuse`" - "`paymentDeclined`" - "`priceAdjustment`" - "`priceError`" - "`productArrivedDamaged`" - "`productNotAsDescribed`" - "`promoReallocation`" - "`qualityNotAsExpected`" - "`returnRefundAbuse`" - "`shippingCostAdjustment`" - "`shippingPriceError`" - "`taxAdjustment`" - "`taxError`" - "`undeliverableShippingAddress`" - "`unsupportedPoBoxAddress`" - "`wrongProductShipped`"
         */
        reasonCode?: string | null;
    }
    /**
     * Represents a geographic region that you can use as a target with both the `RegionalInventory` and `ShippingSettings` services. You can define regions as collections of either postal codes or, in some countries, using predefined geotargets.
     */
    export interface Schema$Region {
        /**
         * The display name of the region.
         */
        displayName?: string | null;
        /**
         * A list of geotargets that defines the region area.
         */
        geotargetArea?: Schema$RegionGeoTargetArea;
        /**
         * Output only. Immutable. Merchant that owns the region.
         */
        merchantId?: string | null;
        /**
         * A list of postal codes that defines the region area.
         */
        postalCodeArea?: Schema$RegionPostalCodeArea;
        /**
         * Output only. Indicates if the region is eligible to use in the Regional Inventory configuration.
         */
        regionalInventoryEligible?: boolean | null;
        /**
         * Output only. Immutable. The ID uniquely identifying each region.
         */
        regionId?: string | null;
        /**
         * Output only. Indicates if the region is eligible to use in the Shipping Services configuration.
         */
        shippingEligible?: boolean | null;
    }
    /**
     * Regional inventory resource. contains the regional name and all attributes which are overridden for the specified region.
     */
    export interface Schema$RegionalInventory {
        /**
         * The availability of the product.
         */
        availability?: string | null;
        /**
         * A list of custom (merchant-provided) attributes. It can also be used for submitting any attribute of the feed specification in its generic form.
         */
        customAttributes?: Schema$CustomAttribute[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#regionalInventory".
         */
        kind?: string | null;
        /**
         * The price of the product.
         */
        price?: Schema$Price;
        /**
         * The ID uniquely identifying each region.
         */
        regionId?: string | null;
        /**
         * The sale price of the product. Mandatory if `sale_price_effective_date` is defined.
         */
        salePrice?: Schema$Price;
        /**
         * A date range represented by a pair of ISO 8601 dates separated by a space, comma, or slash. Both dates might be specified as 'null' if undecided.
         */
        salePriceEffectiveDate?: string | null;
    }
    export interface Schema$RegionalinventoryCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$RegionalinventoryCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch regional inventory request.
     */
    export interface Schema$RegionalinventoryCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * Method of the batch request entry. Acceptable values are: - "`insert`"
         */
        method?: string | null;
        /**
         * The ID of the product for which to update price and availability.
         */
        productId?: string | null;
        /**
         * Price and availability of the product.
         */
        regionalInventory?: Schema$RegionalInventory;
    }
    export interface Schema$RegionalinventoryCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$RegionalinventoryCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#regionalinventoryCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch regional inventory response.
     */
    export interface Schema$RegionalinventoryCustomBatchResponseEntry {
        /**
         * The ID of the request entry this entry responds to.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if and only if the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#regionalinventoryCustomBatchResponseEntry".
         */
        kind?: string | null;
        /**
         * Price and availability of the product.
         */
        regionalInventory?: Schema$RegionalInventory;
    }
    /**
     * A list of geotargets that defines the region area.
     */
    export interface Schema$RegionGeoTargetArea {
        /**
         * Required. A non-empty list of [location IDs](https://developers.google.com/adwords/api/docs/appendix/geotargeting). They must all be of the same location type (e.g., state).
         */
        geotargetCriteriaIds?: string[] | null;
    }
    /**
     * A list of postal codes that defines the region area. Note: All regions defined using postal codes are accessible via the account's `ShippingSettings.postalCodeGroups` resource.
     */
    export interface Schema$RegionPostalCodeArea {
        /**
         * Required. A range of postal codes.
         */
        postalCodes?: Schema$RegionPostalCodeAreaPostalCodeRange[];
        /**
         * Required. CLDR territory code or the country the postal code group applies to.
         */
        regionCode?: string | null;
    }
    /**
     * A range of postal codes that defines the region area.
     */
    export interface Schema$RegionPostalCodeAreaPostalCodeRange {
        /**
         * Required. A postal code or a pattern of the form prefix* denoting the inclusive lower bound of the range defining the area. Examples values: "94108", "9410*", "9*".
         */
        begin?: string | null;
        /**
         * Optional. A postal code or a pattern of the form prefix* denoting the inclusive upper bound of the range defining the area. It must have the same length as postalCodeRangeBegin: if postalCodeRangeBegin is a postal code then postalCodeRangeEnd must be a postal code too; if postalCodeRangeBegin is a pattern then postalCodeRangeEnd must be a pattern with the same prefix length. Optional: if not set, then the area is defined as being all the postal codes matching postalCodeRangeBegin.
         */
        end?: string | null;
    }
    /**
     * Result row returned from the search query.
     */
    export interface Schema$ReportRow {
        /**
         * Metrics requested by the merchant in the query. Metric values are only set for metrics requested explicitly in the query.
         */
        metrics?: Schema$Metrics;
        /**
         * Segmentation dimensions requested by the merchant in the query. Dimension values are only set for dimensions requested explicitly in the query.
         */
        segments?: Schema$Segments;
    }
    /**
     * Resource that represents a daily Repricing product report. Each report contains stats for a single type of Repricing rule for a single product on a given day. If there are multiple rules of the same type for the product on that day, the report lists all the rules by rule ids, combines the stats, and paginates the results by date. To retrieve the stats of a particular rule, provide the rule_id in the request.
     */
    export interface Schema$RepricingProductReport {
        /**
         * Total count of Repricer applications. This value captures how many times the rule of this type was applied to this product during this reporting period.
         */
        applicationCount?: string | null;
        /**
         * Stats specific to buybox winning rules for product report (deprecated).
         */
        buyboxWinningProductStats?: Schema$RepricingProductReportBuyboxWinningProductStats;
        /**
         * Date of the stats in this report. The report starts and ends according to the merchant's timezone.
         */
        date?: Schema$Date;
        /**
         * Maximum displayed price after repriced during this reporting period.
         */
        highWatermark?: Schema$PriceAmount;
        /**
         * List of all reasons the rule did not apply to the product during the specified reporting period.
         */
        inapplicabilityDetails?: Schema$InapplicabilityDetails[];
        /**
         * Minimum displayed price after repriced during this reporting period.
         */
        lowWatermark?: Schema$PriceAmount;
        /**
         * Total unit count of impacted products ordered while the rule was active on the date of the report. This count includes all orders that were started while the rule was active, even if the rule was no longer active when the order was completed.
         */
        orderItemCount?: number | null;
        /**
         * Ids of the Repricing rule for this report.
         */
        ruleIds?: string[] | null;
        /**
         * Total GMV generated by impacted products while the rule was active on the date of the report. This value includes all orders that were started while the rule was active, even if the rule was no longer active when the order was completed.
         */
        totalGmv?: Schema$PriceAmount;
        /**
         * Type of the rule.
         */
        type?: string | null;
    }
    /**
     * Stats specific to buybox winning rules for product report.
     */
    export interface Schema$RepricingProductReportBuyboxWinningProductStats {
        /**
         * Number of times this product won the buybox with these rules during this time period.
         */
        buyboxWinsCount?: number | null;
    }
    /**
     * Represents a repricing rule. A repricing rule is used by shopping serving to adjust transactable offer prices if conditions are met. Next ID: 24
     */
    export interface Schema$RepricingRule {
        /**
         * The rule definition for TYPE_COGS_BASED. Required when the rule type is TYPE_COGS_BASED.
         */
        cogsBasedRule?: Schema$RepricingRuleCostOfGoodsSaleRule;
        /**
         * Required. Immutable. [CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (e.g. "US").
         */
        countryCode?: string | null;
        /**
         * Required. Time period when the rule should take effect.
         */
        effectiveTimePeriod?: Schema$RepricingRuleEffectiveTime;
        /**
         * Required. Match criteria for the eligible offers.
         */
        eligibleOfferMatcher?: Schema$RepricingRuleEligibleOfferMatcher;
        /**
         * Required. Immutable. The two-letter ISO 639-1 language code associated with the repricing rule.
         */
        languageCode?: string | null;
        /**
         * Output only. Immutable. Merchant that owns the repricing rule.
         */
        merchantId?: string | null;
        /**
         * Represents whether a rule is paused. A paused rule will behave like a non-paused rule within CRUD operations, with the major difference that a paused rule will not be evaluated and will have no effect on offers.
         */
        paused?: boolean | null;
        /**
         * Required. Restriction of the rule appliance.
         */
        restriction?: Schema$RepricingRuleRestriction;
        /**
         * Output only. Immutable. The ID to uniquely identify each repricing rule.
         */
        ruleId?: string | null;
        /**
         * The rule definition for TYPE_STATS_BASED. Required when the rule type is TYPE_STATS_BASED.
         */
        statsBasedRule?: Schema$RepricingRuleStatsBasedRule;
        /**
         * The title for the rule.
         */
        title?: string | null;
        /**
         * Required. Immutable. The type of the rule.
         */
        type?: string | null;
    }
    /**
     * A repricing rule that changes the sale price based on cost of goods sale.
     */
    export interface Schema$RepricingRuleCostOfGoodsSaleRule {
        /**
         * The percent change against the COGS. Ex: 20 would mean to set the adjusted price 1.2X of the COGS data.
         */
        percentageDelta?: number | null;
        /**
         * The price delta against the COGS. E.g. 2 means $2 more of the COGS.
         */
        priceDelta?: string | null;
    }
    export interface Schema$RepricingRuleEffectiveTime {
        /**
         * A list of fixed time periods combined with OR. The maximum number of entries is limited to 5.
         */
        fixedTimePeriods?: Schema$RepricingRuleEffectiveTimeFixedTimePeriod[];
    }
    /**
     * Definition of a fixed time period.
     */
    export interface Schema$RepricingRuleEffectiveTimeFixedTimePeriod {
        /**
         * The end time (exclusive) of the period. It can only be hour granularity.
         */
        endTime?: string | null;
        /**
         * The start time (inclusive) of the period. It can only be hour granularity.
         */
        startTime?: string | null;
    }
    /**
     * Matcher that specifies eligible offers. When the USE_FEED_ATTRIBUTE option is selected, only the repricing_rule_id attribute on the product feed is used to specify offer-rule mapping. When the CUSTOM_FILTER option is selected, only the *_matcher fields are used to filter the offers for offer-rule mapping. If the CUSTOM_FILTER option is selected, an offer needs to satisfy each custom filter matcher to be eligible for a rule. Size limit: the sum of the number of entries in all the matchers should not exceed 20. For example, there can be 15 product ids and 5 brands, but not 10 product ids and 11 brands.
     */
    export interface Schema$RepricingRuleEligibleOfferMatcher {
        /**
         * Filter by the brand.
         */
        brandMatcher?: Schema$RepricingRuleEligibleOfferMatcherStringMatcher;
        /**
         * Filter by the item group id.
         */
        itemGroupIdMatcher?: Schema$RepricingRuleEligibleOfferMatcherStringMatcher;
        /**
         * Determines whether to use the custom matchers or the product feed attribute "repricing_rule_id" to specify offer-rule mapping.
         */
        matcherOption?: string | null;
        /**
         * Filter by the offer id.
         */
        offerIdMatcher?: Schema$RepricingRuleEligibleOfferMatcherStringMatcher;
        /**
         * When true, the rule won't be applied to offers with active promotions.
         */
        skipWhenOnPromotion?: boolean | null;
    }
    /**
     * Matcher by string attributes.
     */
    export interface Schema$RepricingRuleEligibleOfferMatcherStringMatcher {
        /**
         * String attributes, as long as such attribute of an offer is one of the string attribute values, the offer is considered as passing the matcher. The string matcher checks an offer for inclusivity in the string attributes, not equality. Only literal string matching is supported, no regex.
         */
        strAttributes?: string[] | null;
    }
    /**
     * Resource that represents a daily Repricing rule report. Next ID: 11
     */
    export interface Schema$RepricingRuleReport {
        /**
         * Stats specific to buybox winning rules for rule report (deprecated).
         */
        buyboxWinningRuleStats?: Schema$RepricingRuleReportBuyboxWinningRuleStats;
        /**
         * Date of the stats in this report. The report starts and ends according to the merchant's timezone.
         */
        date?: Schema$Date;
        /**
         * List of product ids that are impacted by this rule during this reporting period. Out of stock products and products not searched for by customers are examples of non-impacted products.
         */
        impactedProducts?: string[] | null;
        /**
         * List of all reasons the rule did not apply to the inapplicable products during the specified reporting period.
         */
        inapplicabilityDetails?: Schema$InapplicabilityDetails[];
        /**
         * List of product ids that are inapplicable to this rule during this reporting period. To get the inapplicable reason for a specific product, see RepricingProductReport.
         */
        inapplicableProducts?: string[] | null;
        /**
         * Total unit count of impacted products ordered while the rule was active on the date of the report. This count includes all orders that were started while the rule was active, even if the rule was no longer active when the order was completed.
         */
        orderItemCount?: number | null;
        /**
         * Id of the Repricing rule for this report.
         */
        ruleId?: string | null;
        /**
         * Total GMV generated by impacted products while the rule was active on the date of the report. This value includes all orders that were started while the rule was active, even if the rule was no longer active when the order was completed.
         */
        totalGmv?: Schema$PriceAmount;
        /**
         * Type of the rule.
         */
        type?: string | null;
    }
    /**
     * Stats specific to buybox winning rules for rule report.
     */
    export interface Schema$RepricingRuleReportBuyboxWinningRuleStats {
        /**
         * Number of unique products that won the buybox with this rule during this period of time.
         */
        buyboxWonProductCount?: number | null;
    }
    /**
     * Definition of a rule restriction. At least one of the following needs to be true: (1) use_auto_pricing_min_price is true (2) floor.price_delta exists (3) floor.percentage_delta exists If floor.price_delta and floor.percentage_delta are both set on a rule, the highest value will be chosen by the Repricer. In other words, for a product with a price of $50, if the `floor.percentage_delta` is "-10" and the floor.price_delta is "-12", the offer price will only be lowered $5 (10% lower than the original offer price).
     */
    export interface Schema$RepricingRuleRestriction {
        /**
         * The inclusive floor lower bound. The repricing rule only applies when new price \>= floor.
         */
        floor?: Schema$RepricingRuleRestrictionBoundary;
        /**
         * If true, use the AUTO_PRICING_MIN_PRICE offer attribute as the lower bound of the rule. If use_auto_pricing_min_price is true, then only offers with `AUTO_PRICING_MIN_PRICE` existing on the offer will get Repricer treatment, even if a floor value is set on the rule. Also, if use_auto_pricing_min_price is true, the floor restriction will be ignored.
         */
        useAutoPricingMinPrice?: boolean | null;
    }
    /**
     * Definition of a boundary.
     */
    export interface Schema$RepricingRuleRestrictionBoundary {
        /**
         * The percentage delta relative to the offer selling price. This field is signed. It must be negative in floor. When it is used in floor, it should be \> -100. For example, if an offer is selling at $10 and this field is -30 in floor, the repricing rule only applies if the calculated new price is \>= $7.
         */
        percentageDelta?: number | null;
        /**
         * The price micros relative to the offer selling price. This field is signed. It must be negative in floor. For example, if an offer is selling at $10 and this field is -$2 in floor, the repricing rule only applies if the calculated new price is \>= $8.
         */
        priceDelta?: string | null;
    }
    /**
     * Definition of stats based rule.
     */
    export interface Schema$RepricingRuleStatsBasedRule {
        /**
         * The percent change against the price target. Valid from 0 to 100 inclusively.
         */
        percentageDelta?: number | null;
        /**
         * The price delta against the above price target. A positive value means the price should be adjusted to be above statistical measure, and a negative value means below. Currency code must not be included.
         */
        priceDelta?: string | null;
    }
    /**
     * Request message for the RequestReviewProgram method.
     */
    export interface Schema$RequestReviewBuyOnGoogleProgramRequest {
    }
    /**
     * Return address resource.
     */
    export interface Schema$ReturnAddress {
        /**
         * Required. The address.
         */
        address?: Schema$ReturnAddressAddress;
        /**
         * Required. The country of sale where the return address is applicable.
         */
        country?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#returnAddress`"
         */
        kind?: string | null;
        /**
         * Required. The user-defined label of the return address. For the default address, use the label "default".
         */
        label?: string | null;
        /**
         * Required. The merchant's contact phone number regarding the return.
         */
        phoneNumber?: string | null;
        /**
         * Return address ID generated by Google.
         */
        returnAddressId?: string | null;
    }
    export interface Schema$ReturnAddressAddress {
        /**
         * CLDR country code (e.g. "US").
         */
        country?: string | null;
        /**
         * City, town or commune. May also include dependent localities or sublocalities (e.g. neighborhoods or suburbs).
         */
        locality?: string | null;
        /**
         * Postal code or ZIP (e.g. "94043").
         */
        postalCode?: string | null;
        /**
         * Name of the recipient to address returns to.
         */
        recipientName?: string | null;
        /**
         * Top-level administrative subdivision of the country. For example, a state like California ("CA") or a province like Quebec ("QC").
         */
        region?: string | null;
        /**
         * Street-level part of the address. May be up to two lines, each line specified as an array element.
         */
        streetAddress?: string[] | null;
    }
    export interface Schema$ReturnaddressCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$ReturnaddressCustomBatchRequestEntry[];
    }
    export interface Schema$ReturnaddressCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The Merchant Center account ID.
         */
        merchantId?: string | null;
        /**
         * Method of the batch request entry. Acceptable values are: - "`delete`" - "`get`" - "`insert`"
         */
        method?: string | null;
        /**
         * The return address to submit. This should be set only if the method is `insert`.
         */
        returnAddress?: Schema$ReturnAddress;
        /**
         * The return address ID. This should be set only if the method is `delete` or `get`.
         */
        returnAddressId?: string | null;
    }
    export interface Schema$ReturnaddressCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$ReturnaddressCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#returnaddressCustomBatchResponse".
         */
        kind?: string | null;
    }
    export interface Schema$ReturnaddressCustomBatchResponseEntry {
        /**
         * The ID of the request entry to which this entry responds.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if, and only if, the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#returnaddressCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The retrieved return address.
         */
        returnAddress?: Schema$ReturnAddress;
    }
    export interface Schema$ReturnaddressListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#returnaddressListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of addresses.
         */
        nextPageToken?: string | null;
        resources?: Schema$ReturnAddress[];
    }
    /**
     * Return policy resource.
     */
    export interface Schema$ReturnPolicy {
        /**
         * Required. The country of sale where the return policy is applicable.
         */
        country?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#returnPolicy`"
         */
        kind?: string | null;
        /**
         * Required. The user-defined label of the return policy. For the default policy, use the label "default".
         */
        label?: string | null;
        /**
         * Required. The name of the policy as shown in Merchant Center.
         */
        name?: string | null;
        /**
         * Return reasons that will incur return fees.
         */
        nonFreeReturnReasons?: string[] | null;
        /**
         * Required. The policy.
         */
        policy?: Schema$ReturnPolicyPolicy;
        /**
         * Return policy ID generated by Google.
         */
        returnPolicyId?: string | null;
        /**
         * The return shipping fee that will apply to non free return reasons.
         */
        returnShippingFee?: Schema$Price;
        /**
         * An optional list of seasonal overrides.
         */
        seasonalOverrides?: Schema$ReturnPolicySeasonalOverride[];
    }
    export interface Schema$ReturnpolicyCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$ReturnpolicyCustomBatchRequestEntry[];
    }
    export interface Schema$ReturnpolicyCustomBatchRequestEntry {
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The Merchant Center account ID.
         */
        merchantId?: string | null;
        /**
         * Method of the batch request entry. Acceptable values are: - "`delete`" - "`get`" - "`insert`"
         */
        method?: string | null;
        /**
         * The return policy to submit. This should be set only if the method is `insert`.
         */
        returnPolicy?: Schema$ReturnPolicy;
        /**
         * The return policy ID. This should be set only if the method is `delete` or `get`.
         */
        returnPolicyId?: string | null;
    }
    export interface Schema$ReturnpolicyCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$ReturnpolicyCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#returnpolicyCustomBatchResponse".
         */
        kind?: string | null;
    }
    export interface Schema$ReturnpolicyCustomBatchResponseEntry {
        /**
         * The ID of the request entry to which this entry responds.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if, and only if, the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#returnpolicyCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The retrieved return policy.
         */
        returnPolicy?: Schema$ReturnPolicy;
    }
    export interface Schema$ReturnpolicyListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#returnpolicyListResponse".
         */
        kind?: string | null;
        resources?: Schema$ReturnPolicy[];
    }
    /**
     * Return policy online object. This is currently used to represent return policies for ads and free listings programs.
     */
    export interface Schema$ReturnPolicyOnline {
        /**
         * The countries of sale where the return policy is applicable. The values must be a valid 2 letter ISO 3166 code, e.g. "US".
         */
        countries?: string[] | null;
        /**
         * The item conditions that are accepted for returns. This is required to not be empty unless the type of return policy is noReturns.
         */
        itemConditions?: string[] | null;
        /**
         * The unique user-defined label of the return policy. The same label cannot be used in different return policies for the same country. Policies with the label 'default' will apply to all products, unless a product specifies a return_policy_label attribute.
         */
        label?: string | null;
        /**
         * The name of the policy as shown in Merchant Center.
         */
        name?: string | null;
        /**
         * The return policy.
         */
        policy?: Schema$ReturnPolicyOnlinePolicy;
        /**
         * The restocking fee that applies to all return reason categories. This would be treated as a free restocking fee if the value is not set.
         */
        restockingFee?: Schema$ReturnPolicyOnlineRestockingFee;
        /**
         * The return methods of how customers can return an item. This value is required to not be empty unless the type of return policy is noReturns.
         */
        returnMethods?: string[] | null;
        /**
         * Output only. Return policy ID generated by Google.
         */
        returnPolicyId?: string | null;
        /**
         * The return policy uri. This can used by Google to do a sanity check for the policy.
         */
        returnPolicyUri?: string | null;
        /**
         * The return reason category information. This required to not be empty unless the type of return policy is noReturns.
         */
        returnReasonCategoryInfo?: Schema$ReturnPolicyOnlineReturnReasonCategoryInfo[];
    }
    /**
     * The available policies.
     */
    export interface Schema$ReturnPolicyOnlinePolicy {
        /**
         * The number of days items can be returned after delivery, where one day is defined to be 24 hours after the delivery timestamp. Required for `numberOfDaysAfterDelivery` returns.
         */
        days?: string | null;
        /**
         * Policy type.
         */
        type?: string | null;
    }
    /**
     * The restocking fee. This can either be a fixed fee or a micro percent.
     */
    export interface Schema$ReturnPolicyOnlineRestockingFee {
        /**
         * Fixed restocking fee.
         */
        fixedFee?: Schema$PriceAmount;
        /**
         * Percent of total price in micros. 15,000,000 means 15% of the total price would be charged.
         */
        microPercent?: number | null;
    }
    /**
     * The return reason category info wrapper.
     */
    export interface Schema$ReturnPolicyOnlineReturnReasonCategoryInfo {
        /**
         * The corresponding return label source.
         */
        returnLabelSource?: string | null;
        /**
         * The return reason category.
         */
        returnReasonCategory?: string | null;
        /**
         * The corresponding return shipping fee. This is only applicable when returnLabelSource is not the customer's responsibility.
         */
        returnShippingFee?: Schema$ReturnPolicyOnlineReturnShippingFee;
    }
    /**
     * The return shipping fee. This can either be a fixed fee or a boolean to indicate that the customer pays the actual shipping cost.
     */
    export interface Schema$ReturnPolicyOnlineReturnShippingFee {
        /**
         * Fixed return shipping fee amount. This value is only applicable when type is FIXED. We will treat the return shipping fee as free if type is FIXED and this value is not set.
         */
        fixedFee?: Schema$PriceAmount;
        /**
         * Type of return shipping fee.
         */
        type?: string | null;
    }
    export interface Schema$ReturnPolicyPolicy {
        /**
         * Required. Last day for returning the items. In ISO 8601 format. When specifying the return window like this, set the policy type to "lastReturnDate". Use this for seasonal overrides only.
         */
        lastReturnDate?: string | null;
        /**
         * The number of days items can be returned after delivery, where one day is defined to be 24 hours after the delivery timestamp. When specifying the return window like this, set the policy type to "numberOfDaysAfterDelivery". Acceptable values are 30, 45, 60, 90, 100, 180, 270 and 365 for the default policy. Additional policies further allow 14, 15, 21 and 28 days, but note that for most items a minimum of 30 days is required for returns. Exceptions may be made for electronics. A policy of less than 30 days can only be applied to those items.
         */
        numberOfDays?: string | null;
        /**
         * Policy type. Use "lastReturnDate" for seasonal overrides only. Note that for most items a minimum of 30 days is required for returns. Exceptions may be made for electronics or non-returnable items such as food, perishables, and living things. A policy of less than 30 days can only be applied to those items. Acceptable values are: - "`lastReturnDate`" - "`lifetimeReturns`" - "`noReturns`" - "`numberOfDaysAfterDelivery`"
         */
        type?: string | null;
    }
    export interface Schema$ReturnPolicySeasonalOverride {
        /**
         * Required. Last day on which the override applies. In ISO 8601 format.
         */
        endDate?: string | null;
        /**
         * Required. The name of the seasonal override as shown in Merchant Center.
         */
        name?: string | null;
        /**
         * Required. The policy which is in effect during that time.
         */
        policy?: Schema$ReturnPolicyPolicy;
        /**
         * Required. First day on which the override applies. In ISO 8601 format.
         */
        startDate?: string | null;
    }
    export interface Schema$ReturnPricingInfo {
        /**
         * Default option for whether merchant should charge the customer for return shipping costs, based on customer selected return reason and merchant's return policy for the items being returned.
         */
        chargeReturnShippingFee?: boolean | null;
        /**
         * Maximum return shipping costs that may be charged to the customer depending on merchant's assessment of the return reason and the merchant's return policy for the items being returned.
         */
        maxReturnShippingFee?: Schema$MonetaryAmount;
        /**
         * Total amount that can be refunded for the items in this return. It represents the total amount received by the merchant for the items, after applying merchant coupons.
         */
        refundableItemsTotalAmount?: Schema$MonetaryAmount;
        /**
         * Maximum amount that can be refunded for the original shipping fee.
         */
        refundableShippingAmount?: Schema$MonetaryAmount;
        /**
         * Total amount already refunded by the merchant. It includes all types of refunds (items, shipping, etc.) Not provided if no refund has been applied yet.
         */
        totalRefundedAmount?: Schema$MonetaryAmount;
    }
    export interface Schema$ReturnShipment {
        /**
         * The date of creation of the shipment, in ISO 8601 format.
         */
        creationDate?: string | null;
        /**
         * The date of delivery of the shipment, in ISO 8601 format.
         */
        deliveryDate?: string | null;
        /**
         * Type of the return method. Acceptable values are: - "`byMail`" - "`contactCustomerSupport`" - "`returnless`" - "`inStore`"
         */
        returnMethodType?: string | null;
        /**
         * Shipment ID generated by Google.
         */
        shipmentId?: string | null;
        /**
         * Tracking information of the shipment. One return shipment might be handled by several shipping carriers sequentially.
         */
        shipmentTrackingInfos?: Schema$ShipmentTrackingInfo[];
        /**
         * The date of shipping of the shipment, in ISO 8601 format.
         */
        shippingDate?: string | null;
        /**
         * State of the shipment. Acceptable values are: - "`completed`" - "`new`" - "`shipped`" - "`undeliverable`" - "`pending`"
         */
        state?: string | null;
    }
    /**
     * Return shipping label for a Buy on Google merchant-managed return.
     */
    export interface Schema$ReturnShippingLabel {
        /**
         * Name of the carrier.
         */
        carrier?: string | null;
        /**
         * The URL for the return shipping label in PDF format
         */
        labelUri?: string | null;
        /**
         * The tracking id of this return label.
         */
        trackingId?: string | null;
    }
    export interface Schema$Row {
        /**
         * The list of cells that constitute the row. Must have the same length as `columnHeaders` for two-dimensional tables, a length of 1 for one-dimensional tables. Required.
         */
        cells?: Schema$Value[];
    }
    /**
     * Request message for the ReportService.Search method.
     */
    export interface Schema$SearchRequest {
        /**
         * Number of ReportRows to retrieve in a single page. Defaults to the maximum of 1000. Values above 1000 are coerced to 1000.
         */
        pageSize?: number | null;
        /**
         * Token of the page to retrieve. If not specified, the first page of results is returned. In order to request the next page of results, the value obtained from `next_page_token` in the previous response should be used.
         */
        pageToken?: string | null;
        /**
         * Required. Query that defines performance metrics to retrieve and dimensions according to which the metrics are to be segmented.
         */
        query?: string | null;
    }
    /**
     * Response message for the ReportService.Search method.
     */
    export interface Schema$SearchResponse {
        /**
         * Token which can be sent as `page_token` to retrieve the next page. If omitted, there are no subsequent pages.
         */
        nextPageToken?: string | null;
        /**
         * Rows that matched the search query.
         */
        results?: Schema$ReportRow[];
    }
    /**
     * Dimensions according to which metrics are segmented in the response. Values of product dimensions, e.g., offer id, reflect the state of a product at the time of the corresponding event, e.g., impression or order. Segment fields cannot be selected in queries without also selecting at least one metric field. Values are only set for dimensions requested explicitly in the request's search query.
     */
    export interface Schema$Segments {
        /**
         * Brand of the product.
         */
        brand?: string | null;
        /**
         * Product category (1st level) in Google's product taxonomy.
         */
        categoryL1?: string | null;
        /**
         * Product category (2nd level) in Google's product taxonomy.
         */
        categoryL2?: string | null;
        /**
         * Product category (3rd level) in Google's product taxonomy.
         */
        categoryL3?: string | null;
        /**
         * Product category (4th level) in Google's product taxonomy.
         */
        categoryL4?: string | null;
        /**
         * Product category (5th level) in Google's product taxonomy.
         */
        categoryL5?: string | null;
        /**
         * Currency in which price metrics are represented, e.g., if you select `ordered_item_sales_micros`, the returned value will be represented by this currency.
         */
        currencyCode?: string | null;
        /**
         * Custom label 0 for custom grouping of products.
         */
        customLabel0?: string | null;
        /**
         * Custom label 1 for custom grouping of products.
         */
        customLabel1?: string | null;
        /**
         * Custom label 2 for custom grouping of products.
         */
        customLabel2?: string | null;
        /**
         * Custom label 3 for custom grouping of products.
         */
        customLabel3?: string | null;
        /**
         * Custom label 4 for custom grouping of products.
         */
        customLabel4?: string | null;
        /**
         * Date in the merchant timezone to which metrics apply.
         */
        date?: Schema$Date;
        /**
         * Merchant-provided id of the product.
         */
        offerId?: string | null;
        /**
         * Product category (1st level) in merchant's own product taxonomy.
         */
        productTypeL1?: string | null;
        /**
         * Product category (2nd level) in merchant's own product taxonomy.
         */
        productTypeL2?: string | null;
        /**
         * Product category (3rd level) in merchant's own product taxonomy.
         */
        productTypeL3?: string | null;
        /**
         * Product category (4th level) in merchant's own product taxonomy.
         */
        productTypeL4?: string | null;
        /**
         * Product category (5th level) in merchant's own product taxonomy.
         */
        productTypeL5?: string | null;
        /**
         * Program to which metrics apply, e.g., Free Product Listing.
         */
        program?: string | null;
        /**
         * Title of the product.
         */
        title?: string | null;
        /**
         * First day of the week (Monday) of the metrics date in the merchant timezone.
         */
        week?: Schema$Date;
    }
    export interface Schema$Service {
        /**
         * A boolean exposing the active status of the shipping service. Required.
         */
        active?: boolean | null;
        /**
         * The CLDR code of the currency to which this service applies. Must match that of the prices in rate groups.
         */
        currency?: string | null;
        /**
         * The CLDR territory code of the country to which the service applies. Required.
         */
        deliveryCountry?: string | null;
        /**
         * Time spent in various aspects from order to the delivery of the product. Required.
         */
        deliveryTime?: Schema$DeliveryTime;
        /**
         * Eligibility for this service. Acceptable values are: - "`All scenarios`" - "`All scenarios except Shopping Actions`" - "`Shopping Actions`"
         */
        eligibility?: string | null;
        /**
         * Minimum order value for this service. If set, indicates that customers will have to spend at least this amount. All prices within a service must have the same currency. Cannot be set together with minimum_order_value_table.
         */
        minimumOrderValue?: Schema$Price;
        /**
         * Table of per store minimum order values for the pickup fulfillment type. Cannot be set together with minimum_order_value.
         */
        minimumOrderValueTable?: Schema$MinimumOrderValueTable;
        /**
         * Free-form name of the service. Must be unique within target account. Required.
         */
        name?: string | null;
        /**
         * The carrier-service pair delivering items to collection points. The list of supported pickup services can be retrieved via the `getSupportedPickupServices` method. Required if and only if the service delivery type is `pickup`.
         */
        pickupService?: Schema$PickupCarrierService;
        /**
         * Shipping rate group definitions. Only the last one is allowed to have an empty `applicableShippingLabels`, which means "everything else". The other `applicableShippingLabels` must not overlap.
         */
        rateGroups?: Schema$RateGroup[];
        /**
         * Type of locations this service ships orders to. Acceptable values are: - "`delivery`" - "`pickup`"
         */
        shipmentType?: string | null;
    }
    /**
     *  Settlement reports detail order-level and item-level credits and debits between you and Google.
     */
    export interface Schema$SettlementReport {
        /**
         * The end date on which all transactions are included in the report, in ISO 8601 format.
         */
        endDate?: string | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#settlementReport`"
         */
        kind?: string | null;
        /**
         * The residual amount from the previous invoice. This is set only if the previous invoices are not paid because of negative balance.
         */
        previousBalance?: Schema$Price;
        /**
         * The ID of the settlement report.
         */
        settlementId?: string | null;
        /**
         * The start date on which all transactions are included in the report, in ISO 8601 format.
         */
        startDate?: string | null;
        /**
         * The money due to the merchant.
         */
        transferAmount?: Schema$Price;
        /**
         * Date on which transfer for this payment was initiated by Google, in ISO 8601 format.
         */
        transferDate?: string | null;
        /**
         * The list of bank identifiers used for the transfer. e.g. Trace ID for Federal Automated Clearing House (ACH). This may also be known as the Wire ID.
         */
        transferIds?: string[] | null;
    }
    export interface Schema$SettlementreportsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#settlementreportsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of returns.
         */
        nextPageToken?: string | null;
        resources?: Schema$SettlementReport[];
    }
    /**
     * Settlement transactions give a detailed breakdown of the settlement report.
     */
    export interface Schema$SettlementTransaction {
        /**
         * The amount for the transaction.
         */
        amount?: Schema$SettlementTransactionAmount;
        /**
         * Identifiers of the transaction.
         */
        identifiers?: Schema$SettlementTransactionIdentifiers;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#settlementTransaction`"
         */
        kind?: string | null;
        /**
         * Details of the transaction.
         */
        transaction?: Schema$SettlementTransactionTransaction;
    }
    export interface Schema$SettlementTransactionAmount {
        commission?: Schema$SettlementTransactionAmountCommission;
        /**
         * The description of the event. Acceptable values are: - "`taxWithhold`" - "`principal`" - "`principalAdjustment`" - "`shippingFee`" - "`merchantRemittedSalesTax`" - "`googleRemittedSalesTax`" - "`merchantCoupon`" - "`merchantCouponTax`" - "`merchantRemittedDisposalTax`" - "`googleRemittedDisposalTax`" - "`merchantRemittedRedemptionFee`" - "`googleRemittedRedemptionFee`" - "`eeeEcoFee`" - "`furnitureEcoFee`" - "`copyPrivateFee`" - "`eeeEcoFeeCommission`" - "`furnitureEcoFeeCommission`" - "`copyPrivateFeeCommission`" - "`principalRefund`" - "`principalRefundTax`" - "`itemCommission`" - "`adjustmentCommission`" - "`shippingFeeCommission`" - "`commissionRefund`" - "`damaged`" - "`damagedOrDefectiveItem`" - "`expiredItem`" - "`faultyItem`" - "`incorrectItemReceived`" - "`itemMissing`" - "`qualityNotExpected`" - "`receivedTooLate`" - "`storePackageMissing`" - "`transitPackageMissing`" - "`unsuccessfulDeliveryUndeliverable`" - "`wrongChargeInStore`" - "`wrongItem`" - "`returns`" - "`undeliverable`" - "`issueRelatedRefundAndReplacementAmountDescription`" - "`refundFromMerchant`" - "`returnLabelShippingFee`" - "`lumpSumCorrection`" - "`pspFee`" - "`principalRefundDoesNotFit`" - "`principalRefundOrderedWrongItem`" - "`principalRefundQualityNotExpected`" - "`principalRefundBetterPriceFound`" - "`principalRefundNoLongerNeeded`" - "`principalRefundChangedMind`" - "`principalRefundReceivedTooLate`" - "`principalRefundIncorrectItemReceived`" - "`principalRefundDamagedOrDefectiveItem`" - "`principalRefundDidNotMatchDescription`" - "`principalRefundExpiredItem`"
         */
        description?: string | null;
        /**
         * The amount that contributes to the line item price.
         */
        transactionAmount?: Schema$Price;
        /**
         * The type of the amount. Acceptable values are: - "`itemPrice`" - "`orderPrice`" - "`refund`" - "`earlyRefund`" - "`courtesyRefund`" - "`returnRefund`" - "`returnLabelShippingFeeAmount`" - "`lumpSumCorrectionAmount`"
         */
        type?: string | null;
    }
    export interface Schema$SettlementTransactionAmountCommission {
        /**
         * The category of the commission. Acceptable values are: - "`animalsAndPetSupplies`" - "`dogCatFoodAndCatLitter`" - "`apparelAndAccessories`" - "`shoesHandbagsAndSunglasses`" - "`costumesAndAccessories`" - "`jewelry`" - "`watches`" - "`hobbiesArtsAndCrafts`" - "`homeAndGarden`" - "`entertainmentCollectibles`" - "`collectibleCoins`" - "`sportsCollectibles`" - "`sportingGoods`" - "`toysAndGames`" - "`musicalInstruments`" - "`giftCards`" - "`babyAndToddler`" - "`babyFoodWipesAndDiapers`" - "`businessAndIndustrial`" - "`camerasOpticsAndPhotography`" - "`consumerElectronics`" - "`electronicsAccessories`" - "`personalComputers`" - "`videoGameConsoles`" - "`foodAndGrocery`" - "`beverages`" - "`tobaccoProducts`" - "`furniture`" - "`hardware`" - "`buildingMaterials`" - "`tools`" - "`healthAndPersonalCare`" - "`beauty`" - "`householdSupplies`" - "`kitchenAndDining`" - "`majorAppliances`" - "`luggageAndBags`" - "`media`" - "`officeSupplies`" - "`softwareAndVideoGames`" - "`vehiclePartsAndAccessories`" - "`vehicleTiresAndWheels`" - "`vehicles`" - "`everythingElse`"
         */
        category?: string | null;
        /**
         * Rate of the commission in percentage.
         */
        rate?: string | null;
    }
    export interface Schema$SettlementTransactionIdentifiers {
        /**
         * The identifier of the adjustments, if it is available.
         */
        adjustmentId?: string | null;
        /**
         * The merchant provided order ID.
         */
        merchantOrderId?: string | null;
        /**
         * The identifier of the item.
         */
        orderItemId?: string | null;
        /**
         * The unique ID of the settlement transaction entry.
         */
        settlementEntryId?: string | null;
        /**
         * The shipment ids for the item.
         */
        shipmentIds?: string[] | null;
        /**
         * The Google transaction ID.
         */
        transactionId?: string | null;
    }
    export interface Schema$SettlementtransactionsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#settlementtransactionsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of returns.
         */
        nextPageToken?: string | null;
        resources?: Schema$SettlementTransaction[];
    }
    export interface Schema$SettlementTransactionTransaction {
        /**
         * The time on which the event occurred in ISO 8601 format.
         */
        postDate?: string | null;
        /**
         * The type of the transaction that occurred. Acceptable values are: - "`order`" - "`reversal`" - "`orderRefund`" - "`reversalRefund`" - "`issueRelatedRefundAndReplacement`" - "`returnLabelShippingFeeTransaction`" - "`reversalIssueRelatedRefundAndReplacement`" - "`reversalReturnLabelShippingFeeTransaction`" - "`lumpSumCorrectionTransaction`"
         */
        type?: string | null;
    }
    export interface Schema$ShipmentInvoice {
        /**
         * [required] Invoice summary.
         */
        invoiceSummary?: Schema$InvoiceSummary;
        /**
         * [required] Invoice details per line item.
         */
        lineItemInvoices?: Schema$ShipmentInvoiceLineItemInvoice[];
        /**
         * [required] ID of the shipment group. It is assigned by the merchant in the `shipLineItems` method and is used to group multiple line items that have the same kind of shipping charges.
         */
        shipmentGroupId?: string | null;
    }
    export interface Schema$ShipmentInvoiceLineItemInvoice {
        /**
         * ID of the line item. Either lineItemId or productId must be set.
         */
        lineItemId?: string | null;
        /**
         * ID of the product. This is the REST ID used in the products service. Either lineItemId or productId must be set.
         */
        productId?: string | null;
        /**
         * [required] The shipment unit ID is assigned by the merchant and defines individual quantities within a line item. The same ID can be assigned to units that are the same while units that differ must be assigned a different ID (for example: free or promotional units).
         */
        shipmentUnitIds?: string[] | null;
        /**
         * [required] Invoice details for a single unit.
         */
        unitInvoice?: Schema$UnitInvoice;
    }
    export interface Schema$ShipmentTrackingInfo {
        /**
         * The shipping carrier that handles the package. Acceptable values are: - "`boxtal`" - "`bpost`" - "`chronopost`" - "`colisPrive`" - "`colissimo`" - "`cxt`" - "`deliv`" - "`dhl`" - "`dpd`" - "`dynamex`" - "`eCourier`" - "`easypost`" - "`efw`" - "`fedex`" - "`fedexSmartpost`" - "`geodis`" - "`gls`" - "`googleCourier`" - "`gsx`" - "`jdLogistics`" - "`laPoste`" - "`lasership`" - "`manual`" - "`mpx`" - "`onTrac`" - "`other`" - "`tnt`" - "`uds`" - "`ups`" - "`usps`"
         */
        carrier?: string | null;
        /**
         * The tracking number for the package.
         */
        trackingNumber?: string | null;
    }
    /**
     * The merchant account's shipping settings. All methods except getsupportedcarriers and getsupportedholidays require the admin role.
     */
    export interface Schema$ShippingSettings {
        /**
         * The ID of the account to which these account shipping settings belong. Ignored upon update, always present in get request responses.
         */
        accountId?: string | null;
        /**
         * A list of postal code groups that can be referred to in `services`. Optional.
         */
        postalCodeGroups?: Schema$PostalCodeGroup[];
        /**
         * The target account's list of services. Optional.
         */
        services?: Schema$Service[];
    }
    export interface Schema$ShippingsettingsCustomBatchRequest {
        /**
         * The request entries to be processed in the batch.
         */
        entries?: Schema$ShippingsettingsCustomBatchRequestEntry[];
    }
    /**
     * A batch entry encoding a single non-batch shippingsettings request.
     */
    export interface Schema$ShippingsettingsCustomBatchRequestEntry {
        /**
         * The ID of the account for which to get/update account shipping settings.
         */
        accountId?: string | null;
        /**
         * An entry ID, unique within the batch request.
         */
        batchId?: number | null;
        /**
         * The ID of the managing account.
         */
        merchantId?: string | null;
        /**
         * The method of the batch entry. Acceptable values are: - "`get`" - "`update`"
         */
        method?: string | null;
        /**
         * The account shipping settings to update. Only defined if the method is `update`.
         */
        shippingSettings?: Schema$ShippingSettings;
    }
    export interface Schema$ShippingsettingsCustomBatchResponse {
        /**
         * The result of the execution of the batch requests.
         */
        entries?: Schema$ShippingsettingsCustomBatchResponseEntry[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#shippingsettingsCustomBatchResponse".
         */
        kind?: string | null;
    }
    /**
     * A batch entry encoding a single non-batch shipping settings response.
     */
    export interface Schema$ShippingsettingsCustomBatchResponseEntry {
        /**
         * The ID of the request entry to which this entry responds.
         */
        batchId?: number | null;
        /**
         * A list of errors defined if, and only if, the request failed.
         */
        errors?: Schema$Errors;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#shippingsettingsCustomBatchResponseEntry`"
         */
        kind?: string | null;
        /**
         * The retrieved or updated account shipping settings.
         */
        shippingSettings?: Schema$ShippingSettings;
    }
    export interface Schema$ShippingsettingsGetSupportedCarriersResponse {
        /**
         * A list of supported carriers. May be empty.
         */
        carriers?: Schema$CarriersCarrier[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#shippingsettingsGetSupportedCarriersResponse".
         */
        kind?: string | null;
    }
    export interface Schema$ShippingsettingsGetSupportedHolidaysResponse {
        /**
         * A list of holidays applicable for delivery guarantees. May be empty.
         */
        holidays?: Schema$HolidaysHoliday[];
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#shippingsettingsGetSupportedHolidaysResponse".
         */
        kind?: string | null;
    }
    export interface Schema$ShippingsettingsGetSupportedPickupServicesResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#shippingsettingsGetSupportedPickupServicesResponse".
         */
        kind?: string | null;
        /**
         * A list of supported pickup services. May be empty.
         */
        pickupServices?: Schema$PickupServicesPickupService[];
    }
    export interface Schema$ShippingsettingsListResponse {
        /**
         * Identifies what kind of resource this is. Value: the fixed string "content#shippingsettingsListResponse".
         */
        kind?: string | null;
        /**
         * The token for the retrieval of the next page of shipping settings.
         */
        nextPageToken?: string | null;
        resources?: Schema$ShippingSettings[];
    }
    export interface Schema$Table {
        /**
         * Headers of the table's columns. Optional: if not set then the table has only one dimension.
         */
        columnHeaders?: Schema$Headers;
        /**
         * Name of the table. Required for subtables, ignored for the main table.
         */
        name?: string | null;
        /**
         * Headers of the table's rows. Required.
         */
        rowHeaders?: Schema$Headers;
        /**
         * The list of rows that constitute the table. Must have the same length as `rowHeaders`. Required.
         */
        rows?: Schema$Row[];
    }
    export interface Schema$TestOrder {
        /**
         * Overrides the predefined delivery details if provided.
         */
        deliveryDetails?: Schema$TestOrderDeliveryDetails;
        /**
         * Whether the orderinvoices service should support this order.
         */
        enableOrderinvoices?: boolean | null;
        /**
         * Identifies what kind of resource this is. Value: the fixed string "`content#testOrder`"
         */
        kind?: string | null;
        /**
         * Required. Line items that are ordered. At least one line item must be provided.
         */
        lineItems?: Schema$TestOrderLineItem[];
        /**
         * Restricted. Do not use.
         */
        notificationMode?: string | null;
        /**
         * Overrides the predefined pickup details if provided.
         */
        pickupDetails?: Schema$TestOrderPickupDetails;
        /**
         * Required. The billing address. Acceptable values are: - "`dwight`" - "`jim`" - "`pam`"
         */
        predefinedBillingAddress?: string | null;
        /**
         * Required. Identifier of one of the predefined delivery addresses for the delivery. Acceptable values are: - "`dwight`" - "`jim`" - "`pam`"
         */
        predefinedDeliveryAddress?: string | null;
        /**
         * Required. Email address of the customer. Acceptable values are: - "`pog.dwight.schrute@gmail.com`" - "`pog.jim.halpert@gmail.com`" - "`penpog.pam.beesly@gmail.comding`"
         */
        predefinedEmail?: string | null;
        /**
         * Identifier of one of the predefined pickup details. Required for orders containing line items with shipping type `pickup`. Acceptable values are: - "`dwight`" - "`jim`" - "`pam`"
         */
        predefinedPickupDetails?: string | null;
        /**
         * Promotions associated with the order.
         */
        promotions?: Schema$OrderPromotion[];
        /**
         * Required. The price of shipping for all items. Shipping tax is automatically calculated for orders where marketplace facilitator tax laws are applicable. Otherwise, tax settings from Merchant Center are applied. Note that shipping is not taxed in certain states.
         */
        shippingCost?: Schema$Price;
        /**
         * Required. The requested shipping option. Acceptable values are: - "`economy`" - "`expedited`" - "`oneDay`" - "`sameDay`" - "`standard`" - "`twoDay`"
         */
        shippingOption?: string | null;
    }
    export interface Schema$TestOrderAddress {
        /**
         * CLDR country code (e.g. "US").
         */
        country?: string | null;
        /**
         * Strings representing the lines of the printed label for mailing the order, for example: John Smith 1600 Amphitheatre Parkway Mountain View, CA, 94043 United States
         */
        fullAddress?: string[] | null;
        /**
         * Whether the address is a post office box.
         */
        isPostOfficeBox?: boolean | null;
        /**
         * City, town or commune. May also include dependent localities or sublocalities (e.g. neighborhoods or suburbs).
         */
        locality?: string | null;
        /**
         * Postal Code or ZIP (e.g. "94043").
         */
        postalCode?: string | null;
        /**
         * Name of the recipient.
         */
        recipientName?: string | null;
        /**
         * Top-level administrative subdivision of the country. For example, a state like California ("CA") or a province like Quebec ("QC").
         */
        region?: string | null;
        /**
         * Street-level part of the address.
         */
        streetAddress?: string[] | null;
    }
    export interface Schema$TestOrderDeliveryDetails {
        /**
         * The delivery address
         */
        address?: Schema$TestOrderAddress;
        /**
         * Whether the order is scheduled delivery order.
         */
        isScheduledDelivery?: boolean | null;
        /**
         * The phone number of the person receiving the delivery.
         */
        phoneNumber?: string | null;
    }
    export interface Schema$TestOrderLineItem {
        /**
         * Required. Product data from the time of the order placement.
         */
        product?: Schema$TestOrderLineItemProduct;
        /**
         * Required. Number of items ordered.
         */
        quantityOrdered?: number | null;
        /**
         * Required. Details of the return policy for the line item.
         */
        returnInfo?: Schema$OrderLineItemReturnInfo;
        /**
         * Required. Details of the requested shipping for the line item.
         */
        shippingDetails?: Schema$OrderLineItemShippingDetails;
    }
    export interface Schema$TestOrderLineItemProduct {
        /**
         * Required. Brand of the item.
         */
        brand?: string | null;
        /**
         * Required. Condition or state of the item. Acceptable values are: - "`new`"
         */
        condition?: string | null;
        /**
         * Required. The two-letter ISO 639-1 language code for the item. Acceptable values are: - "`en`" - "`fr`"
         */
        contentLanguage?: string | null;
        /**
         * Fees for the item. Optional.
         */
        fees?: Schema$OrderLineItemProductFee[];
        /**
         * Global Trade Item Number (GTIN) of the item. Optional.
         */
        gtin?: string | null;
        /**
         * Required. URL of an image of the item.
         */
        imageLink?: string | null;
        /**
         * Shared identifier for all variants of the same product. Optional.
         */
        itemGroupId?: string | null;
        /**
         * Manufacturer Part Number (MPN) of the item. Optional.
         */
        mpn?: string | null;
        /**
         * Required. An identifier of the item.
         */
        offerId?: string | null;
        /**
         * Required. The price for the product. Tax is automatically calculated for orders where marketplace facilitator tax laws are applicable. Otherwise, tax settings from Merchant Center are applied.
         */
        price?: Schema$Price;
        /**
         * Required. The CLDR territory // code of the target country of the product.
         */
        targetCountry?: string | null;
        /**
         * Required. The title of the product.
         */
        title?: string | null;
        /**
         * Variant attributes for the item. Optional.
         */
        variantAttributes?: Schema$OrderLineItemProductVariantAttribute[];
    }
    export interface Schema$TestOrderPickupDetails {
        /**
         * Required. Code of the location defined by provider or merchant.
         */
        locationCode?: string | null;
        /**
         * Required. Pickup location address.
         */
        pickupLocationAddress?: Schema$TestOrderAddress;
        /**
         * Pickup location type. Acceptable values are: - "`locker`" - "`store`" - "`curbside`"
         */
        pickupLocationType?: string | null;
        /**
         * Required. all pickup persons set by users.
         */
        pickupPersons?: Schema$TestOrderPickupDetailsPickupPerson[];
    }
    export interface Schema$TestOrderPickupDetailsPickupPerson {
        /**
         * Required. Full name of the pickup person.
         */
        name?: string | null;
        /**
         * Required. The phone number of the person picking up the items.
         */
        phoneNumber?: string | null;
    }
    /**
     * Represents a time zone from the [IANA Time Zone Database](https://www.iana.org/time-zones).
     */
    export interface Schema$TimeZone {
        /**
         * IANA Time Zone Database time zone, e.g. "America/New_York".
         */
        id?: string | null;
        /**
         * Optional. IANA Time Zone Database version number, e.g. "2019a".
         */
        version?: string | null;
    }
    export interface Schema$TransitTable {
        /**
         * A list of postal group names. The last value can be `"all other locations"`. Example: `["zone 1", "zone 2", "all other locations"]`. The referred postal code groups must match the delivery country of the service.
         */
        postalCodeGroupNames?: string[] | null;
        rows?: Schema$TransitTableTransitTimeRow[];
        /**
         * A list of transit time labels. The last value can be `"all other labels"`. Example: `["food", "electronics", "all other labels"]`.
         */
        transitTimeLabels?: string[] | null;
    }
    export interface Schema$TransitTableTransitTimeRow {
        values?: Schema$TransitTableTransitTimeRowTransitTimeValue[];
    }
    export interface Schema$TransitTableTransitTimeRowTransitTimeValue {
        /**
         * Must be greater than or equal to `minTransitTimeInDays`.
         */
        maxTransitTimeInDays?: number | null;
        /**
         * Transit time range (min-max) in business days. 0 means same day delivery, 1 means next day delivery.
         */
        minTransitTimeInDays?: number | null;
    }
    export interface Schema$UnitInvoice {
        /**
         * Additional charges for a unit, e.g. shipping costs.
         */
        additionalCharges?: Schema$UnitInvoiceAdditionalCharge[];
        /**
         * [required] Pre-tax or post-tax price of the unit depending on the locality of the order.
         */
        unitPrice?: Schema$Price;
        /**
         * Tax amounts to apply to the unit price.
         */
        unitPriceTaxes?: Schema$UnitInvoiceTaxLine[];
    }
    export interface Schema$UnitInvoiceAdditionalCharge {
        /**
         * [required] Amount of the additional charge.
         */
        additionalChargeAmount?: Schema$Amount;
        /**
         * [required] Type of the additional charge. Acceptable values are: - "`shipping`"
         */
        type?: string | null;
    }
    export interface Schema$UnitInvoiceTaxLine {
        /**
         * [required] Tax amount for the tax type.
         */
        taxAmount?: Schema$Price;
        /**
         * Optional name of the tax type. This should only be provided if `taxType` is `otherFeeTax`.
         */
        taxName?: string | null;
        /**
         * [required] Type of the tax. Acceptable values are: - "`otherFee`" - "`otherFeeTax`" - "`sales`"
         */
        taxType?: string | null;
    }
    /**
     * The single value of a rate group or the value of a rate group table's cell. Exactly one of `noShipping`, `flatRate`, `pricePercentage`, `carrierRateName`, `subtableName` must be set.
     */
    export interface Schema$Value {
        /**
         * The name of a carrier rate referring to a carrier rate defined in the same rate group. Can only be set if all other fields are not set.
         */
        carrierRateName?: string | null;
        /**
         * A flat rate. Can only be set if all other fields are not set.
         */
        flatRate?: Schema$Price;
        /**
         * If true, then the product can't ship. Must be true when set, can only be set if all other fields are not set.
         */
        noShipping?: boolean | null;
        /**
         * A percentage of the price represented as a number in decimal notation (e.g., `"5.4"`). Can only be set if all other fields are not set.
         */
        pricePercentage?: string | null;
        /**
         * The name of a subtable. Can only be set in table cells (i.e., not for single values), and only if all other fields are not set.
         */
        subtableName?: string | null;
    }
    export interface Schema$WarehouseBasedDeliveryTime {
        /**
         * Required. Carrier, such as `"UPS"` or `"Fedex"`. The list of supported carriers can be retrieved via the `listSupportedCarriers` method.
         */
        carrier?: string | null;
        /**
         * Required. Carrier service, such as `"ground"` or `"2 days"`. The list of supported services for a carrier can be retrieved via the `listSupportedCarriers` method. The name of the service must be in the eddSupportedServices list.
         */
        carrierService?: string | null;
        /**
         * Required. Shipping origin's state.
         */
        originAdministrativeArea?: string | null;
        /**
         * Required. Shipping origin's city.
         */
        originCity?: string | null;
        /**
         * Required. Shipping origin's country represented as a [CLDR territory code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml).
         */
        originCountry?: string | null;
        /**
         * Required. Shipping origin.
         */
        originPostalCode?: string | null;
        /**
         * Shipping origin's street address.
         */
        originStreetAddress?: string | null;
    }
    export interface Schema$Weight {
        /**
         * Required. The weight unit. Acceptable values are: - "`kg`" - "`lb`"
         */
        unit?: string | null;
        /**
         * Required. The weight represented as a number. The weight can have a maximum precision of four decimal places.
         */
        value?: string | null;
    }
    export class Resource$Accounts {
        context: APIRequestContext;
        credentials: Resource$Accounts$Credentials;
        labels: Resource$Accounts$Labels;
        returncarrier: Resource$Accounts$Returncarrier;
        constructor(context: APIRequestContext);
        /**
         * Returns information about the authenticated user.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.authinfo({});
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountIdentifiers": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        authinfo(params: Params$Resource$Accounts$Authinfo, options: StreamMethodOptions): GaxiosPromise<Readable>;
        authinfo(params?: Params$Resource$Accounts$Authinfo, options?: MethodOptions): GaxiosPromise<Schema$AccountsAuthInfoResponse>;
        authinfo(params: Params$Resource$Accounts$Authinfo, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        authinfo(params: Params$Resource$Accounts$Authinfo, options: MethodOptions | BodyResponseCallback<Schema$AccountsAuthInfoResponse>, callback: BodyResponseCallback<Schema$AccountsAuthInfoResponse>): void;
        authinfo(params: Params$Resource$Accounts$Authinfo, callback: BodyResponseCallback<Schema$AccountsAuthInfoResponse>): void;
        authinfo(callback: BodyResponseCallback<Schema$AccountsAuthInfoResponse>): void;
        /**
         * Claims the website of a Merchant Center sub-account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.claimwebsite({
         *     // The ID of the account whose website is claimed.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *     // Only available to selected merchants. When set to `True`, this flag removes any existing claim on the requested website by another account and replaces it with a claim from this account.
         *     overwrite: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        claimwebsite(params: Params$Resource$Accounts$Claimwebsite, options: StreamMethodOptions): GaxiosPromise<Readable>;
        claimwebsite(params?: Params$Resource$Accounts$Claimwebsite, options?: MethodOptions): GaxiosPromise<Schema$AccountsClaimWebsiteResponse>;
        claimwebsite(params: Params$Resource$Accounts$Claimwebsite, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        claimwebsite(params: Params$Resource$Accounts$Claimwebsite, options: MethodOptions | BodyResponseCallback<Schema$AccountsClaimWebsiteResponse>, callback: BodyResponseCallback<Schema$AccountsClaimWebsiteResponse>): void;
        claimwebsite(params: Params$Resource$Accounts$Claimwebsite, callback: BodyResponseCallback<Schema$AccountsClaimWebsiteResponse>): void;
        claimwebsite(callback: BodyResponseCallback<Schema$AccountsClaimWebsiteResponse>): void;
        /**
         * Retrieves, inserts, updates, and deletes multiple Merchant Center (sub-)accounts in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Accounts$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Accounts$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$AccountsCustomBatchResponse>;
        custombatch(params: Params$Resource$Accounts$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Accounts$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$AccountsCustomBatchResponse>, callback: BodyResponseCallback<Schema$AccountsCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Accounts$Custombatch, callback: BodyResponseCallback<Schema$AccountsCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$AccountsCustomBatchResponse>): void;
        /**
         * Deletes a Merchant Center sub-account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.delete({
         *     // The ID of the account.
         *     accountId: 'placeholder-value',
         *     // Flag to delete sub-accounts with products. The default value is false.
         *     force: 'placeholder-value',
         *     // The ID of the managing account. This must be a multi-client account, and accountId must be the ID of a sub-account of this account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Accounts$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Accounts$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Accounts$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Accounts$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Accounts$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves a Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.get({
         *     // The ID of the account.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *     // Controls which fields will be populated. Acceptable values are: "merchant" and "css". The default value is "merchant".
         *     view: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "adsLinks": [],
         *   //   "adultContent": false,
         *   //   "automaticLabelIds": [],
         *   //   "businessInformation": {},
         *   //   "cssId": "my_cssId",
         *   //   "googleMyBusinessLink": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "labelIds": [],
         *   //   "name": "my_name",
         *   //   "sellerId": "my_sellerId",
         *   //   "users": [],
         *   //   "websiteUrl": "my_websiteUrl",
         *   //   "youtubeChannelLinks": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Accounts$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Accounts$Get, options?: MethodOptions): GaxiosPromise<Schema$Account>;
        get(params: Params$Resource$Accounts$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Accounts$Get, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
        get(params: Params$Resource$Accounts$Get, callback: BodyResponseCallback<Schema$Account>): void;
        get(callback: BodyResponseCallback<Schema$Account>): void;
        /**
         * Creates a Merchant Center sub-account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.insert({
         *     // The ID of the managing account. This must be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "adsLinks": [],
         *       //   "adultContent": false,
         *       //   "automaticLabelIds": [],
         *       //   "businessInformation": {},
         *       //   "cssId": "my_cssId",
         *       //   "googleMyBusinessLink": {},
         *       //   "id": "my_id",
         *       //   "kind": "my_kind",
         *       //   "labelIds": [],
         *       //   "name": "my_name",
         *       //   "sellerId": "my_sellerId",
         *       //   "users": [],
         *       //   "websiteUrl": "my_websiteUrl",
         *       //   "youtubeChannelLinks": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "adsLinks": [],
         *   //   "adultContent": false,
         *   //   "automaticLabelIds": [],
         *   //   "businessInformation": {},
         *   //   "cssId": "my_cssId",
         *   //   "googleMyBusinessLink": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "labelIds": [],
         *   //   "name": "my_name",
         *   //   "sellerId": "my_sellerId",
         *   //   "users": [],
         *   //   "websiteUrl": "my_websiteUrl",
         *   //   "youtubeChannelLinks": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Accounts$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Accounts$Insert, options?: MethodOptions): GaxiosPromise<Schema$Account>;
        insert(params: Params$Resource$Accounts$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Accounts$Insert, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
        insert(params: Params$Resource$Accounts$Insert, callback: BodyResponseCallback<Schema$Account>): void;
        insert(callback: BodyResponseCallback<Schema$Account>): void;
        /**
         * Performs an action on a link between two Merchant Center accounts, namely accountId and linkedAccountId.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.link({
         *     // The ID of the account that should be linked.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "action": "my_action",
         *       //   "linkType": "my_linkType",
         *       //   "linkedAccountId": "my_linkedAccountId",
         *       //   "paymentServiceProviderLinkInfo": {},
         *       //   "services": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        link(params: Params$Resource$Accounts$Link, options: StreamMethodOptions): GaxiosPromise<Readable>;
        link(params?: Params$Resource$Accounts$Link, options?: MethodOptions): GaxiosPromise<Schema$AccountsLinkResponse>;
        link(params: Params$Resource$Accounts$Link, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        link(params: Params$Resource$Accounts$Link, options: MethodOptions | BodyResponseCallback<Schema$AccountsLinkResponse>, callback: BodyResponseCallback<Schema$AccountsLinkResponse>): void;
        link(params: Params$Resource$Accounts$Link, callback: BodyResponseCallback<Schema$AccountsLinkResponse>): void;
        link(callback: BodyResponseCallback<Schema$AccountsLinkResponse>): void;
        /**
         * Lists the sub-accounts in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.list({
         *     // If view is set to "css", only return accounts that are assigned label with given ID.
         *     label: 'placeholder-value',
         *     // The maximum number of accounts to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the managing account. This must be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *     // Controls which fields will be populated. Acceptable values are: "merchant" and "css". The default value is "merchant".
         *     view: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Accounts$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Accounts$List, options?: MethodOptions): GaxiosPromise<Schema$AccountsListResponse>;
        list(params: Params$Resource$Accounts$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Accounts$List, options: MethodOptions | BodyResponseCallback<Schema$AccountsListResponse>, callback: BodyResponseCallback<Schema$AccountsListResponse>): void;
        list(params: Params$Resource$Accounts$List, callback: BodyResponseCallback<Schema$AccountsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$AccountsListResponse>): void;
        /**
         * Returns the list of accounts linked to your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.listlinks({
         *     // The ID of the account for which to list links.
         *     accountId: 'placeholder-value',
         *     // The maximum number of links to return in the response, used for pagination. The minimum allowed value is 5 results per page. If provided value is lower than 5, it will be automatically increased to 5.
         *     maxResults: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "links": [],
         *   //   "nextPageToken": "my_nextPageToken"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        listlinks(params: Params$Resource$Accounts$Listlinks, options: StreamMethodOptions): GaxiosPromise<Readable>;
        listlinks(params?: Params$Resource$Accounts$Listlinks, options?: MethodOptions): GaxiosPromise<Schema$AccountsListLinksResponse>;
        listlinks(params: Params$Resource$Accounts$Listlinks, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        listlinks(params: Params$Resource$Accounts$Listlinks, options: MethodOptions | BodyResponseCallback<Schema$AccountsListLinksResponse>, callback: BodyResponseCallback<Schema$AccountsListLinksResponse>): void;
        listlinks(params: Params$Resource$Accounts$Listlinks, callback: BodyResponseCallback<Schema$AccountsListLinksResponse>): void;
        listlinks(callback: BodyResponseCallback<Schema$AccountsListLinksResponse>): void;
        /**
         * Updates a Merchant Center account. Any fields that are not provided are deleted from the resource.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.update({
         *     // The ID of the account.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "adsLinks": [],
         *       //   "adultContent": false,
         *       //   "automaticLabelIds": [],
         *       //   "businessInformation": {},
         *       //   "cssId": "my_cssId",
         *       //   "googleMyBusinessLink": {},
         *       //   "id": "my_id",
         *       //   "kind": "my_kind",
         *       //   "labelIds": [],
         *       //   "name": "my_name",
         *       //   "sellerId": "my_sellerId",
         *       //   "users": [],
         *       //   "websiteUrl": "my_websiteUrl",
         *       //   "youtubeChannelLinks": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "adsLinks": [],
         *   //   "adultContent": false,
         *   //   "automaticLabelIds": [],
         *   //   "businessInformation": {},
         *   //   "cssId": "my_cssId",
         *   //   "googleMyBusinessLink": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "labelIds": [],
         *   //   "name": "my_name",
         *   //   "sellerId": "my_sellerId",
         *   //   "users": [],
         *   //   "websiteUrl": "my_websiteUrl",
         *   //   "youtubeChannelLinks": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Accounts$Update, options?: MethodOptions): GaxiosPromise<Schema$Account>;
        update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Accounts$Update, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
        update(params: Params$Resource$Accounts$Update, callback: BodyResponseCallback<Schema$Account>): void;
        update(callback: BodyResponseCallback<Schema$Account>): void;
        /**
         * Updates labels that are assigned to the Merchant Center account by CSS user.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.updatelabels({
         *     // The ID of the account whose labels are updated.
         *     accountId: 'placeholder-value',
         *     // The ID of the managing account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "labelIds": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        updatelabels(params: Params$Resource$Accounts$Updatelabels, options: StreamMethodOptions): GaxiosPromise<Readable>;
        updatelabels(params?: Params$Resource$Accounts$Updatelabels, options?: MethodOptions): GaxiosPromise<Schema$AccountsUpdateLabelsResponse>;
        updatelabels(params: Params$Resource$Accounts$Updatelabels, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        updatelabels(params: Params$Resource$Accounts$Updatelabels, options: MethodOptions | BodyResponseCallback<Schema$AccountsUpdateLabelsResponse>, callback: BodyResponseCallback<Schema$AccountsUpdateLabelsResponse>): void;
        updatelabels(params: Params$Resource$Accounts$Updatelabels, callback: BodyResponseCallback<Schema$AccountsUpdateLabelsResponse>): void;
        updatelabels(callback: BodyResponseCallback<Schema$AccountsUpdateLabelsResponse>): void;
    }
    export interface Params$Resource$Accounts$Authinfo extends StandardParameters {
    }
    export interface Params$Resource$Accounts$Claimwebsite extends StandardParameters {
        /**
         * The ID of the account whose website is claimed.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Only available to selected merchants. When set to `True`, this flag removes any existing claim on the requested website by another account and replaces it with a claim from this account.
         */
        overwrite?: boolean;
    }
    export interface Params$Resource$Accounts$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountsCustomBatchRequest;
    }
    export interface Params$Resource$Accounts$Delete extends StandardParameters {
        /**
         * The ID of the account.
         */
        accountId?: string;
        /**
         * Flag to delete sub-accounts with products. The default value is false.
         */
        force?: boolean;
        /**
         * The ID of the managing account. This must be a multi-client account, and accountId must be the ID of a sub-account of this account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Accounts$Get extends StandardParameters {
        /**
         * The ID of the account.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Controls which fields will be populated. Acceptable values are: "merchant" and "css". The default value is "merchant".
         */
        view?: string;
    }
    export interface Params$Resource$Accounts$Insert extends StandardParameters {
        /**
         * The ID of the managing account. This must be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Account;
    }
    export interface Params$Resource$Accounts$Link extends StandardParameters {
        /**
         * The ID of the account that should be linked.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountsLinkRequest;
    }
    export interface Params$Resource$Accounts$List extends StandardParameters {
        /**
         * If view is set to "css", only return accounts that are assigned label with given ID.
         */
        label?: string;
        /**
         * The maximum number of accounts to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the managing account. This must be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
        /**
         * Controls which fields will be populated. Acceptable values are: "merchant" and "css". The default value is "merchant".
         */
        view?: string;
    }
    export interface Params$Resource$Accounts$Listlinks extends StandardParameters {
        /**
         * The ID of the account for which to list links.
         */
        accountId?: string;
        /**
         * The maximum number of links to return in the response, used for pagination. The minimum allowed value is 5 results per page. If provided value is lower than 5, it will be automatically increased to 5.
         */
        maxResults?: number;
        /**
         * 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.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Accounts$Update extends StandardParameters {
        /**
         * The ID of the account.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Account;
    }
    export interface Params$Resource$Accounts$Updatelabels extends StandardParameters {
        /**
         * The ID of the account whose labels are updated.
         */
        accountId?: string;
        /**
         * The ID of the managing account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountsUpdateLabelsRequest;
    }
    export class Resource$Accounts$Credentials {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Uploads credentials for the Merchant Center account. If credentials already exist for this Merchant Center account and purpose, this method updates them.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.credentials.create({
         *     // Required. The merchant id of the account these credentials belong to.
         *     accountId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "accessToken": "my_accessToken",
         *       //   "expiresIn": "my_expiresIn",
         *       //   "purpose": "my_purpose"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accessToken": "my_accessToken",
         *   //   "expiresIn": "my_expiresIn",
         *   //   "purpose": "my_purpose"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Accounts$Credentials$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Accounts$Credentials$Create, options?: MethodOptions): GaxiosPromise<Schema$AccountCredentials>;
        create(params: Params$Resource$Accounts$Credentials$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Accounts$Credentials$Create, options: MethodOptions | BodyResponseCallback<Schema$AccountCredentials>, callback: BodyResponseCallback<Schema$AccountCredentials>): void;
        create(params: Params$Resource$Accounts$Credentials$Create, callback: BodyResponseCallback<Schema$AccountCredentials>): void;
        create(callback: BodyResponseCallback<Schema$AccountCredentials>): void;
    }
    export interface Params$Resource$Accounts$Credentials$Create extends StandardParameters {
        /**
         * Required. The merchant id of the account these credentials belong to.
         */
        accountId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountCredentials;
    }
    export class Resource$Accounts$Labels {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Creates a new label, not assigned to any account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.labels.create({
         *     // Required. The id of the account this label belongs to.
         *     accountId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "accountId": "my_accountId",
         *       //   "description": "my_description",
         *       //   "labelId": "my_labelId",
         *       //   "labelType": "my_labelType",
         *       //   "name": "my_name"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "description": "my_description",
         *   //   "labelId": "my_labelId",
         *   //   "labelType": "my_labelType",
         *   //   "name": "my_name"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Accounts$Labels$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Accounts$Labels$Create, options?: MethodOptions): GaxiosPromise<Schema$AccountLabel>;
        create(params: Params$Resource$Accounts$Labels$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Accounts$Labels$Create, options: MethodOptions | BodyResponseCallback<Schema$AccountLabel>, callback: BodyResponseCallback<Schema$AccountLabel>): void;
        create(params: Params$Resource$Accounts$Labels$Create, callback: BodyResponseCallback<Schema$AccountLabel>): void;
        create(callback: BodyResponseCallback<Schema$AccountLabel>): void;
        /**
         * Deletes a label and removes it from all accounts to which it was assigned.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.labels.delete({
         *     // Required. The id of the account that owns the label.
         *     accountId: 'placeholder-value',
         *     // Required. The id of the label to delete.
         *     labelId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Accounts$Labels$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Accounts$Labels$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Accounts$Labels$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Accounts$Labels$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Accounts$Labels$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Lists the labels assigned to an account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.labels.list({
         *     // Required. The account id for whose labels are to be listed.
         *     accountId: 'placeholder-value',
         *     // The maximum number of labels to return. The service may return fewer than this value. If unspecified, at most 50 labels will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         *     pageSize: 'placeholder-value',
         *     // A page token, received from a previous `ListAccountLabels` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccountLabels` must match the call that provided the page token.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountLabels": [],
         *   //   "nextPageToken": "my_nextPageToken"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Accounts$Labels$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Accounts$Labels$List, options?: MethodOptions): GaxiosPromise<Schema$ListAccountLabelsResponse>;
        list(params: Params$Resource$Accounts$Labels$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Accounts$Labels$List, options: MethodOptions | BodyResponseCallback<Schema$ListAccountLabelsResponse>, callback: BodyResponseCallback<Schema$ListAccountLabelsResponse>): void;
        list(params: Params$Resource$Accounts$Labels$List, callback: BodyResponseCallback<Schema$ListAccountLabelsResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListAccountLabelsResponse>): void;
        /**
         * Updates a label.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.labels.patch({
         *     // Required. The id of the account this label belongs to.
         *     accountId: 'placeholder-value',
         *     // Required. The id of the label to update.
         *     labelId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "accountId": "my_accountId",
         *       //   "description": "my_description",
         *       //   "labelId": "my_labelId",
         *       //   "labelType": "my_labelType",
         *       //   "name": "my_name"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "description": "my_description",
         *   //   "labelId": "my_labelId",
         *   //   "labelType": "my_labelType",
         *   //   "name": "my_name"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        patch(params: Params$Resource$Accounts$Labels$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        patch(params?: Params$Resource$Accounts$Labels$Patch, options?: MethodOptions): GaxiosPromise<Schema$AccountLabel>;
        patch(params: Params$Resource$Accounts$Labels$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        patch(params: Params$Resource$Accounts$Labels$Patch, options: MethodOptions | BodyResponseCallback<Schema$AccountLabel>, callback: BodyResponseCallback<Schema$AccountLabel>): void;
        patch(params: Params$Resource$Accounts$Labels$Patch, callback: BodyResponseCallback<Schema$AccountLabel>): void;
        patch(callback: BodyResponseCallback<Schema$AccountLabel>): void;
    }
    export interface Params$Resource$Accounts$Labels$Create extends StandardParameters {
        /**
         * Required. The id of the account this label belongs to.
         */
        accountId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountLabel;
    }
    export interface Params$Resource$Accounts$Labels$Delete extends StandardParameters {
        /**
         * Required. The id of the account that owns the label.
         */
        accountId?: string;
        /**
         * Required. The id of the label to delete.
         */
        labelId?: string;
    }
    export interface Params$Resource$Accounts$Labels$List extends StandardParameters {
        /**
         * Required. The account id for whose labels are to be listed.
         */
        accountId?: string;
        /**
         * The maximum number of labels to return. The service may return fewer than this value. If unspecified, at most 50 labels will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         */
        pageSize?: number;
        /**
         * A page token, received from a previous `ListAccountLabels` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccountLabels` must match the call that provided the page token.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Accounts$Labels$Patch extends StandardParameters {
        /**
         * Required. The id of the account this label belongs to.
         */
        accountId?: string;
        /**
         * Required. The id of the label to update.
         */
        labelId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountLabel;
    }
    export class Resource$Accounts$Returncarrier {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Links return carrier to a merchant account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.returncarrier.create({
         *     // Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         *     accountId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "carrierAccountId": "my_carrierAccountId",
         *       //   "carrierAccountName": "my_carrierAccountName",
         *       //   "carrierAccountNumber": "my_carrierAccountNumber",
         *       //   "carrierCode": "my_carrierCode"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "carrierAccountId": "my_carrierAccountId",
         *   //   "carrierAccountName": "my_carrierAccountName",
         *   //   "carrierAccountNumber": "my_carrierAccountNumber",
         *   //   "carrierCode": "my_carrierCode"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Accounts$Returncarrier$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Accounts$Returncarrier$Create, options?: MethodOptions): GaxiosPromise<Schema$AccountReturnCarrier>;
        create(params: Params$Resource$Accounts$Returncarrier$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Accounts$Returncarrier$Create, options: MethodOptions | BodyResponseCallback<Schema$AccountReturnCarrier>, callback: BodyResponseCallback<Schema$AccountReturnCarrier>): void;
        create(params: Params$Resource$Accounts$Returncarrier$Create, callback: BodyResponseCallback<Schema$AccountReturnCarrier>): void;
        create(callback: BodyResponseCallback<Schema$AccountReturnCarrier>): void;
        /**
         * Delete a return carrier in the merchant account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.returncarrier.delete({
         *     // Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         *     accountId: 'placeholder-value',
         *     // Required. The Google-provided unique carrier ID, used to update the resource.
         *     carrierAccountId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Accounts$Returncarrier$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Accounts$Returncarrier$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Accounts$Returncarrier$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Accounts$Returncarrier$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Accounts$Returncarrier$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Lists available return carriers in the merchant account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.returncarrier.list({
         *     // Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         *     accountId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountReturnCarriers": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Accounts$Returncarrier$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Accounts$Returncarrier$List, options?: MethodOptions): GaxiosPromise<Schema$ListAccountReturnCarrierResponse>;
        list(params: Params$Resource$Accounts$Returncarrier$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Accounts$Returncarrier$List, options: MethodOptions | BodyResponseCallback<Schema$ListAccountReturnCarrierResponse>, callback: BodyResponseCallback<Schema$ListAccountReturnCarrierResponse>): void;
        list(params: Params$Resource$Accounts$Returncarrier$List, callback: BodyResponseCallback<Schema$ListAccountReturnCarrierResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListAccountReturnCarrierResponse>): void;
        /**
         * Updates a return carrier in the merchant account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounts.returncarrier.patch({
         *     // Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         *     accountId: 'placeholder-value',
         *     // Required. The Google-provided unique carrier ID, used to update the resource.
         *     carrierAccountId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "carrierAccountId": "my_carrierAccountId",
         *       //   "carrierAccountName": "my_carrierAccountName",
         *       //   "carrierAccountNumber": "my_carrierAccountNumber",
         *       //   "carrierCode": "my_carrierCode"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "carrierAccountId": "my_carrierAccountId",
         *   //   "carrierAccountName": "my_carrierAccountName",
         *   //   "carrierAccountNumber": "my_carrierAccountNumber",
         *   //   "carrierCode": "my_carrierCode"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        patch(params: Params$Resource$Accounts$Returncarrier$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        patch(params?: Params$Resource$Accounts$Returncarrier$Patch, options?: MethodOptions): GaxiosPromise<Schema$AccountReturnCarrier>;
        patch(params: Params$Resource$Accounts$Returncarrier$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        patch(params: Params$Resource$Accounts$Returncarrier$Patch, options: MethodOptions | BodyResponseCallback<Schema$AccountReturnCarrier>, callback: BodyResponseCallback<Schema$AccountReturnCarrier>): void;
        patch(params: Params$Resource$Accounts$Returncarrier$Patch, callback: BodyResponseCallback<Schema$AccountReturnCarrier>): void;
        patch(callback: BodyResponseCallback<Schema$AccountReturnCarrier>): void;
    }
    export interface Params$Resource$Accounts$Returncarrier$Create extends StandardParameters {
        /**
         * Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         */
        accountId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountReturnCarrier;
    }
    export interface Params$Resource$Accounts$Returncarrier$Delete extends StandardParameters {
        /**
         * Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         */
        accountId?: string;
        /**
         * Required. The Google-provided unique carrier ID, used to update the resource.
         */
        carrierAccountId?: string;
    }
    export interface Params$Resource$Accounts$Returncarrier$List extends StandardParameters {
        /**
         * Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         */
        accountId?: string;
    }
    export interface Params$Resource$Accounts$Returncarrier$Patch extends StandardParameters {
        /**
         * Required. The Merchant Center Account Id under which the Return Carrier is to be linked.
         */
        accountId?: string;
        /**
         * Required. The Google-provided unique carrier ID, used to update the resource.
         */
        carrierAccountId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountReturnCarrier;
    }
    export class Resource$Accountstatuses {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves multiple Merchant Center account statuses in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accountstatuses.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Accountstatuses$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Accountstatuses$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$AccountstatusesCustomBatchResponse>;
        custombatch(params: Params$Resource$Accountstatuses$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Accountstatuses$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$AccountstatusesCustomBatchResponse>, callback: BodyResponseCallback<Schema$AccountstatusesCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Accountstatuses$Custombatch, callback: BodyResponseCallback<Schema$AccountstatusesCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$AccountstatusesCustomBatchResponse>): void;
        /**
         * Retrieves the status of a Merchant Center account. No itemLevelIssues are returned for multi-client accounts.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accountstatuses.get({
         *     // The ID of the account.
         *     accountId: 'placeholder-value',
         *     // If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         *     destinations: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "accountLevelIssues": [],
         *   //   "kind": "my_kind",
         *   //   "products": [],
         *   //   "websiteClaimed": false
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Accountstatuses$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Accountstatuses$Get, options?: MethodOptions): GaxiosPromise<Schema$AccountStatus>;
        get(params: Params$Resource$Accountstatuses$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Accountstatuses$Get, options: MethodOptions | BodyResponseCallback<Schema$AccountStatus>, callback: BodyResponseCallback<Schema$AccountStatus>): void;
        get(params: Params$Resource$Accountstatuses$Get, callback: BodyResponseCallback<Schema$AccountStatus>): void;
        get(callback: BodyResponseCallback<Schema$AccountStatus>): void;
        /**
         * Lists the statuses of the sub-accounts in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accountstatuses.list({
         *     // If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         *     destinations: 'placeholder-value',
         *     // The maximum number of account statuses to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the managing account. This must be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Accountstatuses$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Accountstatuses$List, options?: MethodOptions): GaxiosPromise<Schema$AccountstatusesListResponse>;
        list(params: Params$Resource$Accountstatuses$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Accountstatuses$List, options: MethodOptions | BodyResponseCallback<Schema$AccountstatusesListResponse>, callback: BodyResponseCallback<Schema$AccountstatusesListResponse>): void;
        list(params: Params$Resource$Accountstatuses$List, callback: BodyResponseCallback<Schema$AccountstatusesListResponse>): void;
        list(callback: BodyResponseCallback<Schema$AccountstatusesListResponse>): void;
    }
    export interface Params$Resource$Accountstatuses$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountstatusesCustomBatchRequest;
    }
    export interface Params$Resource$Accountstatuses$Get extends StandardParameters {
        /**
         * The ID of the account.
         */
        accountId?: string;
        /**
         * If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         */
        destinations?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Accountstatuses$List extends StandardParameters {
        /**
         * If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         */
        destinations?: string[];
        /**
         * The maximum number of account statuses to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the managing account. This must be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export class Resource$Accounttax {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves and updates tax settings of multiple accounts in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounttax.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Accounttax$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Accounttax$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$AccounttaxCustomBatchResponse>;
        custombatch(params: Params$Resource$Accounttax$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Accounttax$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$AccounttaxCustomBatchResponse>, callback: BodyResponseCallback<Schema$AccounttaxCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Accounttax$Custombatch, callback: BodyResponseCallback<Schema$AccounttaxCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$AccounttaxCustomBatchResponse>): void;
        /**
         * Retrieves the tax settings of the account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounttax.get({
         *     // The ID of the account for which to get/update account tax settings.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "kind": "my_kind",
         *   //   "rules": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Accounttax$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Accounttax$Get, options?: MethodOptions): GaxiosPromise<Schema$AccountTax>;
        get(params: Params$Resource$Accounttax$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Accounttax$Get, options: MethodOptions | BodyResponseCallback<Schema$AccountTax>, callback: BodyResponseCallback<Schema$AccountTax>): void;
        get(params: Params$Resource$Accounttax$Get, callback: BodyResponseCallback<Schema$AccountTax>): void;
        get(callback: BodyResponseCallback<Schema$AccountTax>): void;
        /**
         * Lists the tax settings of the sub-accounts in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounttax.list({
         *     // The maximum number of tax settings to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the managing account. This must be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Accounttax$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Accounttax$List, options?: MethodOptions): GaxiosPromise<Schema$AccounttaxListResponse>;
        list(params: Params$Resource$Accounttax$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Accounttax$List, options: MethodOptions | BodyResponseCallback<Schema$AccounttaxListResponse>, callback: BodyResponseCallback<Schema$AccounttaxListResponse>): void;
        list(params: Params$Resource$Accounttax$List, callback: BodyResponseCallback<Schema$AccounttaxListResponse>): void;
        list(callback: BodyResponseCallback<Schema$AccounttaxListResponse>): void;
        /**
         * Updates the tax settings of the account. Any fields that are not provided are deleted from the resource.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.accounttax.update({
         *     // The ID of the account for which to get/update account tax settings.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "accountId": "my_accountId",
         *       //   "kind": "my_kind",
         *       //   "rules": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "kind": "my_kind",
         *   //   "rules": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Accounttax$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Accounttax$Update, options?: MethodOptions): GaxiosPromise<Schema$AccountTax>;
        update(params: Params$Resource$Accounttax$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Accounttax$Update, options: MethodOptions | BodyResponseCallback<Schema$AccountTax>, callback: BodyResponseCallback<Schema$AccountTax>): void;
        update(params: Params$Resource$Accounttax$Update, callback: BodyResponseCallback<Schema$AccountTax>): void;
        update(callback: BodyResponseCallback<Schema$AccountTax>): void;
    }
    export interface Params$Resource$Accounttax$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccounttaxCustomBatchRequest;
    }
    export interface Params$Resource$Accounttax$Get extends StandardParameters {
        /**
         * The ID of the account for which to get/update account tax settings.
         */
        accountId?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Accounttax$List extends StandardParameters {
        /**
         * The maximum number of tax settings to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the managing account. This must be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Accounttax$Update extends StandardParameters {
        /**
         * The ID of the account for which to get/update account tax settings.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$AccountTax;
    }
    export class Resource$Buyongoogleprograms {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Reactivates the BoG program in your Merchant Center account. Moves the program to the active state when allowed, e.g. when paused. Important: This method is only whitelisted for selected merchants.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.buyongoogleprograms.activate({
         *     // Required. The ID of the account.
         *     merchantId: 'placeholder-value',
         *     // The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         *     regionCode: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {}
         *     },
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        activate(params: Params$Resource$Buyongoogleprograms$Activate, options: StreamMethodOptions): GaxiosPromise<Readable>;
        activate(params?: Params$Resource$Buyongoogleprograms$Activate, options?: MethodOptions): GaxiosPromise<void>;
        activate(params: Params$Resource$Buyongoogleprograms$Activate, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        activate(params: Params$Resource$Buyongoogleprograms$Activate, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        activate(params: Params$Resource$Buyongoogleprograms$Activate, callback: BodyResponseCallback<void>): void;
        activate(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves a status of the BoG program for your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.buyongoogleprograms.get({
         *     // Required. The ID of the account.
         *     merchantId: 'placeholder-value',
         *     // The Program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         *     regionCode: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "customerServicePendingEmail": "my_customerServicePendingEmail",
         *   //   "customerServiceVerifiedEmail": "my_customerServiceVerifiedEmail",
         *   //   "participationStage": "my_participationStage"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Buyongoogleprograms$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Buyongoogleprograms$Get, options?: MethodOptions): GaxiosPromise<Schema$BuyOnGoogleProgramStatus>;
        get(params: Params$Resource$Buyongoogleprograms$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Buyongoogleprograms$Get, options: MethodOptions | BodyResponseCallback<Schema$BuyOnGoogleProgramStatus>, callback: BodyResponseCallback<Schema$BuyOnGoogleProgramStatus>): void;
        get(params: Params$Resource$Buyongoogleprograms$Get, callback: BodyResponseCallback<Schema$BuyOnGoogleProgramStatus>): void;
        get(callback: BodyResponseCallback<Schema$BuyOnGoogleProgramStatus>): void;
        /**
         * Onboards the BoG program in your Merchant Center account. By using this method, you agree to the [Terms of Service](https://merchants.google.com/mc/termsofservice/transactions/US/latest). Calling this method is only possible if the authenticated account is the same as the merchant id in the request. Calling this method multiple times will only accept Terms of Service if the latest version is not currently signed.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.buyongoogleprograms.onboard({
         *     // Required. The ID of the account.
         *     merchantId: 'placeholder-value',
         *     // The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         *     regionCode: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "customerServiceEmail": "my_customerServiceEmail"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        onboard(params: Params$Resource$Buyongoogleprograms$Onboard, options: StreamMethodOptions): GaxiosPromise<Readable>;
        onboard(params?: Params$Resource$Buyongoogleprograms$Onboard, options?: MethodOptions): GaxiosPromise<void>;
        onboard(params: Params$Resource$Buyongoogleprograms$Onboard, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        onboard(params: Params$Resource$Buyongoogleprograms$Onboard, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        onboard(params: Params$Resource$Buyongoogleprograms$Onboard, callback: BodyResponseCallback<void>): void;
        onboard(callback: BodyResponseCallback<void>): void;
        /**
         * Pauses the BoG program in your Merchant Center account. Important: This method is only whitelisted for selected merchants.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.buyongoogleprograms.pause({
         *     // Required. The ID of the account.
         *     merchantId: 'placeholder-value',
         *     // The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         *     regionCode: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {}
         *     },
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        pause(params: Params$Resource$Buyongoogleprograms$Pause, options: StreamMethodOptions): GaxiosPromise<Readable>;
        pause(params?: Params$Resource$Buyongoogleprograms$Pause, options?: MethodOptions): GaxiosPromise<void>;
        pause(params: Params$Resource$Buyongoogleprograms$Pause, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        pause(params: Params$Resource$Buyongoogleprograms$Pause, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        pause(params: Params$Resource$Buyongoogleprograms$Pause, callback: BodyResponseCallback<void>): void;
        pause(callback: BodyResponseCallback<void>): void;
        /**
         * Requests review and then activates the BoG program in your Merchant Center account for the first time. Moves the program to the REVIEW_PENDING state. Important: This method is only whitelisted for selected merchants.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.buyongoogleprograms.requestreview({
         *     // Required. The ID of the account.
         *     merchantId: 'placeholder-value',
         *     // The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         *     regionCode: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {}
         *     },
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        requestreview(params: Params$Resource$Buyongoogleprograms$Requestreview, options: StreamMethodOptions): GaxiosPromise<Readable>;
        requestreview(params?: Params$Resource$Buyongoogleprograms$Requestreview, options?: MethodOptions): GaxiosPromise<void>;
        requestreview(params: Params$Resource$Buyongoogleprograms$Requestreview, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        requestreview(params: Params$Resource$Buyongoogleprograms$Requestreview, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        requestreview(params: Params$Resource$Buyongoogleprograms$Requestreview, callback: BodyResponseCallback<void>): void;
        requestreview(callback: BodyResponseCallback<void>): void;
    }
    export interface Params$Resource$Buyongoogleprograms$Activate extends StandardParameters {
        /**
         * Required. The ID of the account.
         */
        merchantId?: string;
        /**
         * The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         */
        regionCode?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ActivateBuyOnGoogleProgramRequest;
    }
    export interface Params$Resource$Buyongoogleprograms$Get extends StandardParameters {
        /**
         * Required. The ID of the account.
         */
        merchantId?: string;
        /**
         * The Program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         */
        regionCode?: string;
    }
    export interface Params$Resource$Buyongoogleprograms$Onboard extends StandardParameters {
        /**
         * Required. The ID of the account.
         */
        merchantId?: string;
        /**
         * The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         */
        regionCode?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OnboardBuyOnGoogleProgramRequest;
    }
    export interface Params$Resource$Buyongoogleprograms$Pause extends StandardParameters {
        /**
         * Required. The ID of the account.
         */
        merchantId?: string;
        /**
         * The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         */
        regionCode?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$PauseBuyOnGoogleProgramRequest;
    }
    export interface Params$Resource$Buyongoogleprograms$Requestreview extends StandardParameters {
        /**
         * Required. The ID of the account.
         */
        merchantId?: string;
        /**
         * The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available.
         */
        regionCode?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$RequestReviewBuyOnGoogleProgramRequest;
    }
    export class Resource$Collections {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Uploads a collection to your Merchant Center account. If a collection with the same collectionId already exists, this method updates that entry. In each update, the collection is completely replaced by the fields in the body of the update request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.collections.create({
         *     // Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "customLabel0": "my_customLabel0",
         *       //   "customLabel1": "my_customLabel1",
         *       //   "customLabel2": "my_customLabel2",
         *       //   "customLabel3": "my_customLabel3",
         *       //   "customLabel4": "my_customLabel4",
         *       //   "featuredProduct": [],
         *       //   "headline": [],
         *       //   "id": "my_id",
         *       //   "imageLink": [],
         *       //   "language": "my_language",
         *       //   "link": "my_link",
         *       //   "mobileLink": "my_mobileLink",
         *       //   "productCountry": "my_productCountry"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "customLabel0": "my_customLabel0",
         *   //   "customLabel1": "my_customLabel1",
         *   //   "customLabel2": "my_customLabel2",
         *   //   "customLabel3": "my_customLabel3",
         *   //   "customLabel4": "my_customLabel4",
         *   //   "featuredProduct": [],
         *   //   "headline": [],
         *   //   "id": "my_id",
         *   //   "imageLink": [],
         *   //   "language": "my_language",
         *   //   "link": "my_link",
         *   //   "mobileLink": "my_mobileLink",
         *   //   "productCountry": "my_productCountry"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Collections$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Collections$Create, options?: MethodOptions): GaxiosPromise<Schema$Collection>;
        create(params: Params$Resource$Collections$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Collections$Create, options: MethodOptions | BodyResponseCallback<Schema$Collection>, callback: BodyResponseCallback<Schema$Collection>): void;
        create(params: Params$Resource$Collections$Create, callback: BodyResponseCallback<Schema$Collection>): void;
        create(callback: BodyResponseCallback<Schema$Collection>): void;
        /**
         * Deletes a collection from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.collections.delete({
         *     // Required. The collectionId of the collection. CollectionId is the same as the REST ID of the collection.
         *     collectionId: 'placeholder-value',
         *     // Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Collections$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Collections$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Collections$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Collections$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Collections$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves a collection from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.collections.get({
         *     // Required. The REST ID of the collection.
         *     collectionId: 'placeholder-value',
         *     // Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "customLabel0": "my_customLabel0",
         *   //   "customLabel1": "my_customLabel1",
         *   //   "customLabel2": "my_customLabel2",
         *   //   "customLabel3": "my_customLabel3",
         *   //   "customLabel4": "my_customLabel4",
         *   //   "featuredProduct": [],
         *   //   "headline": [],
         *   //   "id": "my_id",
         *   //   "imageLink": [],
         *   //   "language": "my_language",
         *   //   "link": "my_link",
         *   //   "mobileLink": "my_mobileLink",
         *   //   "productCountry": "my_productCountry"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Collections$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Collections$Get, options?: MethodOptions): GaxiosPromise<Schema$Collection>;
        get(params: Params$Resource$Collections$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Collections$Get, options: MethodOptions | BodyResponseCallback<Schema$Collection>, callback: BodyResponseCallback<Schema$Collection>): void;
        get(params: Params$Resource$Collections$Get, callback: BodyResponseCallback<Schema$Collection>): void;
        get(callback: BodyResponseCallback<Schema$Collection>): void;
        /**
         * Lists the collections in your Merchant Center account. The response might contain fewer items than specified by page_size. Rely on next_page_token to determine if there are more items to be requested.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.collections.list({
         *     // Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The maximum number of collections to return in the response, used for paging. Defaults to 50; values above 1000 will be coerced to 1000.
         *     pageSize: 'placeholder-value',
         *     // Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Collections$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Collections$List, options?: MethodOptions): GaxiosPromise<Schema$ListCollectionsResponse>;
        list(params: Params$Resource$Collections$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Collections$List, options: MethodOptions | BodyResponseCallback<Schema$ListCollectionsResponse>, callback: BodyResponseCallback<Schema$ListCollectionsResponse>): void;
        list(params: Params$Resource$Collections$List, callback: BodyResponseCallback<Schema$ListCollectionsResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListCollectionsResponse>): void;
    }
    export interface Params$Resource$Collections$Create extends StandardParameters {
        /**
         * Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Collection;
    }
    export interface Params$Resource$Collections$Delete extends StandardParameters {
        /**
         * Required. The collectionId of the collection. CollectionId is the same as the REST ID of the collection.
         */
        collectionId?: string;
        /**
         * Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Collections$Get extends StandardParameters {
        /**
         * Required. The REST ID of the collection.
         */
        collectionId?: string;
        /**
         * Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Collections$List extends StandardParameters {
        /**
         * Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The maximum number of collections to return in the response, used for paging. Defaults to 50; values above 1000 will be coerced to 1000.
         */
        pageSize?: number;
        /**
         * Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         */
        pageToken?: string;
    }
    export class Resource$Collectionstatuses {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Gets the status of a collection from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.collectionstatuses.get({
         *     // Required. The collectionId of the collection. CollectionId is the same as the REST ID of the collection.
         *     collectionId: 'placeholder-value',
         *     // Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "collectionLevelIssuses": [],
         *   //   "creationDate": "my_creationDate",
         *   //   "destinationStatuses": [],
         *   //   "id": "my_id",
         *   //   "lastUpdateDate": "my_lastUpdateDate"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Collectionstatuses$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Collectionstatuses$Get, options?: MethodOptions): GaxiosPromise<Schema$CollectionStatus>;
        get(params: Params$Resource$Collectionstatuses$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Collectionstatuses$Get, options: MethodOptions | BodyResponseCallback<Schema$CollectionStatus>, callback: BodyResponseCallback<Schema$CollectionStatus>): void;
        get(params: Params$Resource$Collectionstatuses$Get, callback: BodyResponseCallback<Schema$CollectionStatus>): void;
        get(callback: BodyResponseCallback<Schema$CollectionStatus>): void;
        /**
         * Lists the statuses of the collections in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.collectionstatuses.list({
         *     // Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The maximum number of collection statuses to return in the response, used for paging. Defaults to 50; values above 1000 will be coerced to 1000.
         *     pageSize: 'placeholder-value',
         *     // Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Collectionstatuses$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Collectionstatuses$List, options?: MethodOptions): GaxiosPromise<Schema$ListCollectionStatusesResponse>;
        list(params: Params$Resource$Collectionstatuses$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Collectionstatuses$List, options: MethodOptions | BodyResponseCallback<Schema$ListCollectionStatusesResponse>, callback: BodyResponseCallback<Schema$ListCollectionStatusesResponse>): void;
        list(params: Params$Resource$Collectionstatuses$List, callback: BodyResponseCallback<Schema$ListCollectionStatusesResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListCollectionStatusesResponse>): void;
    }
    export interface Params$Resource$Collectionstatuses$Get extends StandardParameters {
        /**
         * Required. The collectionId of the collection. CollectionId is the same as the REST ID of the collection.
         */
        collectionId?: string;
        /**
         * Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Collectionstatuses$List extends StandardParameters {
        /**
         * Required. The ID of the account that contains the collection. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The maximum number of collection statuses to return in the response, used for paging. Defaults to 50; values above 1000 will be coerced to 1000.
         */
        pageSize?: number;
        /**
         * Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         */
        pageToken?: string;
    }
    export class Resource$Csses {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves a single CSS domain by ID.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.csses.get({
         *     // Required. The ID of the CSS domain to return.
         *     cssDomainId: 'placeholder-value',
         *     // Required. The ID of the managing account. If this parameter is not the same as [cssDomainId](#cssDomainId), then this ID must be a CSS group ID and `cssDomainId` must be the ID of a CSS domain affiliated with this group.
         *     cssGroupId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cssDomainId": "my_cssDomainId",
         *   //   "cssGroupId": "my_cssGroupId",
         *   //   "displayName": "my_displayName",
         *   //   "fullName": "my_fullName",
         *   //   "homepageUri": "my_homepageUri",
         *   //   "labelIds": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Csses$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Csses$Get, options?: MethodOptions): GaxiosPromise<Schema$Css>;
        get(params: Params$Resource$Csses$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Csses$Get, options: MethodOptions | BodyResponseCallback<Schema$Css>, callback: BodyResponseCallback<Schema$Css>): void;
        get(params: Params$Resource$Csses$Get, callback: BodyResponseCallback<Schema$Css>): void;
        get(callback: BodyResponseCallback<Schema$Css>): void;
        /**
         * Lists CSS domains affiliated with a CSS group.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.csses.list({
         *     // Required. The CSS group ID of CSS domains to be listed.
         *     cssGroupId: 'placeholder-value',
         *     // The maximum number of CSS domains to return. The service may return fewer than this value. If unspecified, at most 50 CSS domains will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         *     pageSize: 'placeholder-value',
         *     // A page token, received from a previous `ListCsses` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListCsses` must match the call that provided the page token.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "csses": [],
         *   //   "nextPageToken": "my_nextPageToken"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Csses$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Csses$List, options?: MethodOptions): GaxiosPromise<Schema$ListCssesResponse>;
        list(params: Params$Resource$Csses$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Csses$List, options: MethodOptions | BodyResponseCallback<Schema$ListCssesResponse>, callback: BodyResponseCallback<Schema$ListCssesResponse>): void;
        list(params: Params$Resource$Csses$List, callback: BodyResponseCallback<Schema$ListCssesResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListCssesResponse>): void;
        /**
         * Updates labels that are assigned to a CSS domain by its CSS group.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.csses.updatelabels({
         *     // Required. The ID of the updated CSS domain.
         *     cssDomainId: 'placeholder-value',
         *     // Required. The CSS group ID of the updated CSS domain.
         *     cssGroupId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "labelIds": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cssDomainId": "my_cssDomainId",
         *   //   "cssGroupId": "my_cssGroupId",
         *   //   "displayName": "my_displayName",
         *   //   "fullName": "my_fullName",
         *   //   "homepageUri": "my_homepageUri",
         *   //   "labelIds": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        updatelabels(params: Params$Resource$Csses$Updatelabels, options: StreamMethodOptions): GaxiosPromise<Readable>;
        updatelabels(params?: Params$Resource$Csses$Updatelabels, options?: MethodOptions): GaxiosPromise<Schema$Css>;
        updatelabels(params: Params$Resource$Csses$Updatelabels, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        updatelabels(params: Params$Resource$Csses$Updatelabels, options: MethodOptions | BodyResponseCallback<Schema$Css>, callback: BodyResponseCallback<Schema$Css>): void;
        updatelabels(params: Params$Resource$Csses$Updatelabels, callback: BodyResponseCallback<Schema$Css>): void;
        updatelabels(callback: BodyResponseCallback<Schema$Css>): void;
    }
    export interface Params$Resource$Csses$Get extends StandardParameters {
        /**
         * Required. The ID of the CSS domain to return.
         */
        cssDomainId?: string;
        /**
         * Required. The ID of the managing account. If this parameter is not the same as [cssDomainId](#cssDomainId), then this ID must be a CSS group ID and `cssDomainId` must be the ID of a CSS domain affiliated with this group.
         */
        cssGroupId?: string;
    }
    export interface Params$Resource$Csses$List extends StandardParameters {
        /**
         * Required. The CSS group ID of CSS domains to be listed.
         */
        cssGroupId?: string;
        /**
         * The maximum number of CSS domains to return. The service may return fewer than this value. If unspecified, at most 50 CSS domains will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         */
        pageSize?: number;
        /**
         * A page token, received from a previous `ListCsses` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListCsses` must match the call that provided the page token.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Csses$Updatelabels extends StandardParameters {
        /**
         * Required. The ID of the updated CSS domain.
         */
        cssDomainId?: string;
        /**
         * Required. The CSS group ID of the updated CSS domain.
         */
        cssGroupId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$LabelIds;
    }
    export class Resource$Datafeeds {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Deletes, fetches, gets, inserts and updates multiple datafeeds in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Datafeeds$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Datafeeds$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$DatafeedsCustomBatchResponse>;
        custombatch(params: Params$Resource$Datafeeds$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Datafeeds$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$DatafeedsCustomBatchResponse>, callback: BodyResponseCallback<Schema$DatafeedsCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Datafeeds$Custombatch, callback: BodyResponseCallback<Schema$DatafeedsCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$DatafeedsCustomBatchResponse>): void;
        /**
         * Deletes a datafeed configuration from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.delete({
         *     // The ID of the datafeed.
         *     datafeedId: 'placeholder-value',
         *     // The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Datafeeds$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Datafeeds$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Datafeeds$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Datafeeds$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Datafeeds$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Invokes a fetch for the datafeed in your Merchant Center account. If you need to call this method more than once per day, we recommend you use the Products service to update your product data.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.fetchnow({
         *     // The ID of the datafeed to be fetched.
         *     datafeedId: 'placeholder-value',
         *     // The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        fetchnow(params: Params$Resource$Datafeeds$Fetchnow, options: StreamMethodOptions): GaxiosPromise<Readable>;
        fetchnow(params?: Params$Resource$Datafeeds$Fetchnow, options?: MethodOptions): GaxiosPromise<Schema$DatafeedsFetchNowResponse>;
        fetchnow(params: Params$Resource$Datafeeds$Fetchnow, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        fetchnow(params: Params$Resource$Datafeeds$Fetchnow, options: MethodOptions | BodyResponseCallback<Schema$DatafeedsFetchNowResponse>, callback: BodyResponseCallback<Schema$DatafeedsFetchNowResponse>): void;
        fetchnow(params: Params$Resource$Datafeeds$Fetchnow, callback: BodyResponseCallback<Schema$DatafeedsFetchNowResponse>): void;
        fetchnow(callback: BodyResponseCallback<Schema$DatafeedsFetchNowResponse>): void;
        /**
         * Retrieves a datafeed configuration from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.get({
         *     // The ID of the datafeed.
         *     datafeedId: 'placeholder-value',
         *     // The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "attributeLanguage": "my_attributeLanguage",
         *   //   "contentType": "my_contentType",
         *   //   "fetchSchedule": {},
         *   //   "fileName": "my_fileName",
         *   //   "format": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "name": "my_name",
         *   //   "targets": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Datafeeds$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Datafeeds$Get, options?: MethodOptions): GaxiosPromise<Schema$Datafeed>;
        get(params: Params$Resource$Datafeeds$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Datafeeds$Get, options: MethodOptions | BodyResponseCallback<Schema$Datafeed>, callback: BodyResponseCallback<Schema$Datafeed>): void;
        get(params: Params$Resource$Datafeeds$Get, callback: BodyResponseCallback<Schema$Datafeed>): void;
        get(callback: BodyResponseCallback<Schema$Datafeed>): void;
        /**
         * Registers a datafeed configuration with your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.insert({
         *     // The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "attributeLanguage": "my_attributeLanguage",
         *       //   "contentType": "my_contentType",
         *       //   "fetchSchedule": {},
         *       //   "fileName": "my_fileName",
         *       //   "format": {},
         *       //   "id": "my_id",
         *       //   "kind": "my_kind",
         *       //   "name": "my_name",
         *       //   "targets": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "attributeLanguage": "my_attributeLanguage",
         *   //   "contentType": "my_contentType",
         *   //   "fetchSchedule": {},
         *   //   "fileName": "my_fileName",
         *   //   "format": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "name": "my_name",
         *   //   "targets": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Datafeeds$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Datafeeds$Insert, options?: MethodOptions): GaxiosPromise<Schema$Datafeed>;
        insert(params: Params$Resource$Datafeeds$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Datafeeds$Insert, options: MethodOptions | BodyResponseCallback<Schema$Datafeed>, callback: BodyResponseCallback<Schema$Datafeed>): void;
        insert(params: Params$Resource$Datafeeds$Insert, callback: BodyResponseCallback<Schema$Datafeed>): void;
        insert(callback: BodyResponseCallback<Schema$Datafeed>): void;
        /**
         * Lists the configurations for datafeeds in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.list({
         *     // The maximum number of products to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that manages the datafeeds. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Datafeeds$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Datafeeds$List, options?: MethodOptions): GaxiosPromise<Schema$DatafeedsListResponse>;
        list(params: Params$Resource$Datafeeds$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Datafeeds$List, options: MethodOptions | BodyResponseCallback<Schema$DatafeedsListResponse>, callback: BodyResponseCallback<Schema$DatafeedsListResponse>): void;
        list(params: Params$Resource$Datafeeds$List, callback: BodyResponseCallback<Schema$DatafeedsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$DatafeedsListResponse>): void;
        /**
         * Updates a datafeed configuration of your Merchant Center account. Any fields that are not provided are deleted from the resource.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeeds.update({
         *     // The ID of the datafeed.
         *     datafeedId: 'placeholder-value',
         *     // The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "attributeLanguage": "my_attributeLanguage",
         *       //   "contentType": "my_contentType",
         *       //   "fetchSchedule": {},
         *       //   "fileName": "my_fileName",
         *       //   "format": {},
         *       //   "id": "my_id",
         *       //   "kind": "my_kind",
         *       //   "name": "my_name",
         *       //   "targets": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "attributeLanguage": "my_attributeLanguage",
         *   //   "contentType": "my_contentType",
         *   //   "fetchSchedule": {},
         *   //   "fileName": "my_fileName",
         *   //   "format": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "name": "my_name",
         *   //   "targets": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Datafeeds$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Datafeeds$Update, options?: MethodOptions): GaxiosPromise<Schema$Datafeed>;
        update(params: Params$Resource$Datafeeds$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Datafeeds$Update, options: MethodOptions | BodyResponseCallback<Schema$Datafeed>, callback: BodyResponseCallback<Schema$Datafeed>): void;
        update(params: Params$Resource$Datafeeds$Update, callback: BodyResponseCallback<Schema$Datafeed>): void;
        update(callback: BodyResponseCallback<Schema$Datafeed>): void;
    }
    export interface Params$Resource$Datafeeds$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$DatafeedsCustomBatchRequest;
    }
    export interface Params$Resource$Datafeeds$Delete extends StandardParameters {
        /**
         * The ID of the datafeed.
         */
        datafeedId?: string;
        /**
         * The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Datafeeds$Fetchnow extends StandardParameters {
        /**
         * The ID of the datafeed to be fetched.
         */
        datafeedId?: string;
        /**
         * The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Datafeeds$Get extends StandardParameters {
        /**
         * The ID of the datafeed.
         */
        datafeedId?: string;
        /**
         * The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Datafeeds$Insert extends StandardParameters {
        /**
         * The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Datafeed;
    }
    export interface Params$Resource$Datafeeds$List extends StandardParameters {
        /**
         * The maximum number of products to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the account that manages the datafeeds. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Datafeeds$Update extends StandardParameters {
        /**
         * The ID of the datafeed.
         */
        datafeedId?: string;
        /**
         * The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Datafeed;
    }
    export class Resource$Datafeedstatuses {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Gets multiple Merchant Center datafeed statuses in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeedstatuses.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Datafeedstatuses$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Datafeedstatuses$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$DatafeedstatusesCustomBatchResponse>;
        custombatch(params: Params$Resource$Datafeedstatuses$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Datafeedstatuses$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$DatafeedstatusesCustomBatchResponse>, callback: BodyResponseCallback<Schema$DatafeedstatusesCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Datafeedstatuses$Custombatch, callback: BodyResponseCallback<Schema$DatafeedstatusesCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$DatafeedstatusesCustomBatchResponse>): void;
        /**
         * Retrieves the status of a datafeed from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeedstatuses.get({
         *     // The country for which to get the datafeed status. If this parameter is provided then language must also be provided. Note that this parameter is required for feeds targeting multiple countries and languages, since a feed may have a different status for each target.
         *     country: 'placeholder-value',
         *     // The ID of the datafeed.
         *     datafeedId: 'placeholder-value',
         *     // The language for which to get the datafeed status. If this parameter is provided then country must also be provided. Note that this parameter is required for feeds targeting multiple countries and languages, since a feed may have a different status for each target.
         *     language: 'placeholder-value',
         *     // The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "country": "my_country",
         *   //   "datafeedId": "my_datafeedId",
         *   //   "errors": [],
         *   //   "itemsTotal": "my_itemsTotal",
         *   //   "itemsValid": "my_itemsValid",
         *   //   "kind": "my_kind",
         *   //   "language": "my_language",
         *   //   "lastUploadDate": "my_lastUploadDate",
         *   //   "processingStatus": "my_processingStatus",
         *   //   "warnings": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Datafeedstatuses$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Datafeedstatuses$Get, options?: MethodOptions): GaxiosPromise<Schema$DatafeedStatus>;
        get(params: Params$Resource$Datafeedstatuses$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Datafeedstatuses$Get, options: MethodOptions | BodyResponseCallback<Schema$DatafeedStatus>, callback: BodyResponseCallback<Schema$DatafeedStatus>): void;
        get(params: Params$Resource$Datafeedstatuses$Get, callback: BodyResponseCallback<Schema$DatafeedStatus>): void;
        get(callback: BodyResponseCallback<Schema$DatafeedStatus>): void;
        /**
         * Lists the statuses of the datafeeds in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.datafeedstatuses.list({
         *     // The maximum number of products to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that manages the datafeeds. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Datafeedstatuses$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Datafeedstatuses$List, options?: MethodOptions): GaxiosPromise<Schema$DatafeedstatusesListResponse>;
        list(params: Params$Resource$Datafeedstatuses$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Datafeedstatuses$List, options: MethodOptions | BodyResponseCallback<Schema$DatafeedstatusesListResponse>, callback: BodyResponseCallback<Schema$DatafeedstatusesListResponse>): void;
        list(params: Params$Resource$Datafeedstatuses$List, callback: BodyResponseCallback<Schema$DatafeedstatusesListResponse>): void;
        list(callback: BodyResponseCallback<Schema$DatafeedstatusesListResponse>): void;
    }
    export interface Params$Resource$Datafeedstatuses$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$DatafeedstatusesCustomBatchRequest;
    }
    export interface Params$Resource$Datafeedstatuses$Get extends StandardParameters {
        /**
         * The country for which to get the datafeed status. If this parameter is provided then language must also be provided. Note that this parameter is required for feeds targeting multiple countries and languages, since a feed may have a different status for each target.
         */
        country?: string;
        /**
         * The ID of the datafeed.
         */
        datafeedId?: string;
        /**
         * The language for which to get the datafeed status. If this parameter is provided then country must also be provided. Note that this parameter is required for feeds targeting multiple countries and languages, since a feed may have a different status for each target.
         */
        language?: string;
        /**
         * The ID of the account that manages the datafeed. This account cannot be a multi-client account.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Datafeedstatuses$List extends StandardParameters {
        /**
         * The maximum number of products to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the account that manages the datafeeds. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export class Resource$Liasettings {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves and/or updates the LIA settings of multiple accounts in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Liasettings$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Liasettings$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsCustomBatchResponse>;
        custombatch(params: Params$Resource$Liasettings$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Liasettings$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsCustomBatchResponse>, callback: BodyResponseCallback<Schema$LiasettingsCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Liasettings$Custombatch, callback: BodyResponseCallback<Schema$LiasettingsCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$LiasettingsCustomBatchResponse>): void;
        /**
         * Retrieves the LIA settings of the account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.get({
         *     // The ID of the account for which to get or update LIA settings.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "countrySettings": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Liasettings$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Liasettings$Get, options?: MethodOptions): GaxiosPromise<Schema$LiaSettings>;
        get(params: Params$Resource$Liasettings$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Liasettings$Get, options: MethodOptions | BodyResponseCallback<Schema$LiaSettings>, callback: BodyResponseCallback<Schema$LiaSettings>): void;
        get(params: Params$Resource$Liasettings$Get, callback: BodyResponseCallback<Schema$LiaSettings>): void;
        get(callback: BodyResponseCallback<Schema$LiaSettings>): void;
        /**
         * Retrieves the list of accessible Google My Business accounts.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.getaccessiblegmbaccounts({
         *     // The ID of the account for which to retrieve accessible Google My Business accounts.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "gmbAccounts": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        getaccessiblegmbaccounts(params: Params$Resource$Liasettings$Getaccessiblegmbaccounts, options: StreamMethodOptions): GaxiosPromise<Readable>;
        getaccessiblegmbaccounts(params?: Params$Resource$Liasettings$Getaccessiblegmbaccounts, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsGetAccessibleGmbAccountsResponse>;
        getaccessiblegmbaccounts(params: Params$Resource$Liasettings$Getaccessiblegmbaccounts, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        getaccessiblegmbaccounts(params: Params$Resource$Liasettings$Getaccessiblegmbaccounts, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsGetAccessibleGmbAccountsResponse>, callback: BodyResponseCallback<Schema$LiasettingsGetAccessibleGmbAccountsResponse>): void;
        getaccessiblegmbaccounts(params: Params$Resource$Liasettings$Getaccessiblegmbaccounts, callback: BodyResponseCallback<Schema$LiasettingsGetAccessibleGmbAccountsResponse>): void;
        getaccessiblegmbaccounts(callback: BodyResponseCallback<Schema$LiasettingsGetAccessibleGmbAccountsResponse>): void;
        /**
         * Lists the LIA settings of the sub-accounts in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.list({
         *     // The maximum number of LIA settings to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the managing account. This must be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Liasettings$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Liasettings$List, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsListResponse>;
        list(params: Params$Resource$Liasettings$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Liasettings$List, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsListResponse>, callback: BodyResponseCallback<Schema$LiasettingsListResponse>): void;
        list(params: Params$Resource$Liasettings$List, callback: BodyResponseCallback<Schema$LiasettingsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$LiasettingsListResponse>): void;
        /**
         * Retrieves the list of POS data providers that have active settings for the all eiligible countries.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.listposdataproviders({});
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "posDataProviders": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        listposdataproviders(params: Params$Resource$Liasettings$Listposdataproviders, options: StreamMethodOptions): GaxiosPromise<Readable>;
        listposdataproviders(params?: Params$Resource$Liasettings$Listposdataproviders, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsListPosDataProvidersResponse>;
        listposdataproviders(params: Params$Resource$Liasettings$Listposdataproviders, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        listposdataproviders(params: Params$Resource$Liasettings$Listposdataproviders, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsListPosDataProvidersResponse>, callback: BodyResponseCallback<Schema$LiasettingsListPosDataProvidersResponse>): void;
        listposdataproviders(params: Params$Resource$Liasettings$Listposdataproviders, callback: BodyResponseCallback<Schema$LiasettingsListPosDataProvidersResponse>): void;
        listposdataproviders(callback: BodyResponseCallback<Schema$LiasettingsListPosDataProvidersResponse>): void;
        /**
         * Requests access to a specified Google My Business account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.requestgmbaccess({
         *     // The ID of the account for which GMB access is requested.
         *     accountId: 'placeholder-value',
         *     // The email of the Google My Business account.
         *     gmbEmail: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        requestgmbaccess(params: Params$Resource$Liasettings$Requestgmbaccess, options: StreamMethodOptions): GaxiosPromise<Readable>;
        requestgmbaccess(params?: Params$Resource$Liasettings$Requestgmbaccess, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsRequestGmbAccessResponse>;
        requestgmbaccess(params: Params$Resource$Liasettings$Requestgmbaccess, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        requestgmbaccess(params: Params$Resource$Liasettings$Requestgmbaccess, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsRequestGmbAccessResponse>, callback: BodyResponseCallback<Schema$LiasettingsRequestGmbAccessResponse>): void;
        requestgmbaccess(params: Params$Resource$Liasettings$Requestgmbaccess, callback: BodyResponseCallback<Schema$LiasettingsRequestGmbAccessResponse>): void;
        requestgmbaccess(callback: BodyResponseCallback<Schema$LiasettingsRequestGmbAccessResponse>): void;
        /**
         * Requests inventory validation for the specified country.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.requestinventoryverification({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     accountId: 'placeholder-value',
         *     // The country for which inventory validation is requested.
         *     country: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        requestinventoryverification(params: Params$Resource$Liasettings$Requestinventoryverification, options: StreamMethodOptions): GaxiosPromise<Readable>;
        requestinventoryverification(params?: Params$Resource$Liasettings$Requestinventoryverification, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsRequestInventoryVerificationResponse>;
        requestinventoryverification(params: Params$Resource$Liasettings$Requestinventoryverification, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        requestinventoryverification(params: Params$Resource$Liasettings$Requestinventoryverification, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsRequestInventoryVerificationResponse>, callback: BodyResponseCallback<Schema$LiasettingsRequestInventoryVerificationResponse>): void;
        requestinventoryverification(params: Params$Resource$Liasettings$Requestinventoryverification, callback: BodyResponseCallback<Schema$LiasettingsRequestInventoryVerificationResponse>): void;
        requestinventoryverification(callback: BodyResponseCallback<Schema$LiasettingsRequestInventoryVerificationResponse>): void;
        /**
         * Sets the inventory verification contract for the specified country.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.setinventoryverificationcontact({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     accountId: 'placeholder-value',
         *     // The email of the inventory verification contact.
         *     contactEmail: 'placeholder-value',
         *     // The name of the inventory verification contact.
         *     contactName: 'placeholder-value',
         *     // The country for which inventory verification is requested.
         *     country: 'placeholder-value',
         *     // The language for which inventory verification is requested.
         *     language: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        setinventoryverificationcontact(params: Params$Resource$Liasettings$Setinventoryverificationcontact, options: StreamMethodOptions): GaxiosPromise<Readable>;
        setinventoryverificationcontact(params?: Params$Resource$Liasettings$Setinventoryverificationcontact, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsSetInventoryVerificationContactResponse>;
        setinventoryverificationcontact(params: Params$Resource$Liasettings$Setinventoryverificationcontact, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        setinventoryverificationcontact(params: Params$Resource$Liasettings$Setinventoryverificationcontact, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsSetInventoryVerificationContactResponse>, callback: BodyResponseCallback<Schema$LiasettingsSetInventoryVerificationContactResponse>): void;
        setinventoryverificationcontact(params: Params$Resource$Liasettings$Setinventoryverificationcontact, callback: BodyResponseCallback<Schema$LiasettingsSetInventoryVerificationContactResponse>): void;
        setinventoryverificationcontact(callback: BodyResponseCallback<Schema$LiasettingsSetInventoryVerificationContactResponse>): void;
        /**
         * Sets the POS data provider for the specified country.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.setposdataprovider({
         *     // The ID of the account for which to retrieve accessible Google My Business accounts.
         *     accountId: 'placeholder-value',
         *     // The country for which the POS data provider is selected.
         *     country: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *     // The ID of POS data provider.
         *     posDataProviderId: 'placeholder-value',
         *     // The account ID by which this merchant is known to the POS data provider.
         *     posExternalAccountId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        setposdataprovider(params: Params$Resource$Liasettings$Setposdataprovider, options: StreamMethodOptions): GaxiosPromise<Readable>;
        setposdataprovider(params?: Params$Resource$Liasettings$Setposdataprovider, options?: MethodOptions): GaxiosPromise<Schema$LiasettingsSetPosDataProviderResponse>;
        setposdataprovider(params: Params$Resource$Liasettings$Setposdataprovider, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        setposdataprovider(params: Params$Resource$Liasettings$Setposdataprovider, options: MethodOptions | BodyResponseCallback<Schema$LiasettingsSetPosDataProviderResponse>, callback: BodyResponseCallback<Schema$LiasettingsSetPosDataProviderResponse>): void;
        setposdataprovider(params: Params$Resource$Liasettings$Setposdataprovider, callback: BodyResponseCallback<Schema$LiasettingsSetPosDataProviderResponse>): void;
        setposdataprovider(callback: BodyResponseCallback<Schema$LiasettingsSetPosDataProviderResponse>): void;
        /**
         * Updates the LIA settings of the account. Any fields that are not provided are deleted from the resource.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.liasettings.update({
         *     // The ID of the account for which to get or update LIA settings.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "accountId": "my_accountId",
         *       //   "countrySettings": [],
         *       //   "kind": "my_kind"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "countrySettings": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Liasettings$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Liasettings$Update, options?: MethodOptions): GaxiosPromise<Schema$LiaSettings>;
        update(params: Params$Resource$Liasettings$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Liasettings$Update, options: MethodOptions | BodyResponseCallback<Schema$LiaSettings>, callback: BodyResponseCallback<Schema$LiaSettings>): void;
        update(params: Params$Resource$Liasettings$Update, callback: BodyResponseCallback<Schema$LiaSettings>): void;
        update(callback: BodyResponseCallback<Schema$LiaSettings>): void;
    }
    export interface Params$Resource$Liasettings$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$LiasettingsCustomBatchRequest;
    }
    export interface Params$Resource$Liasettings$Get extends StandardParameters {
        /**
         * The ID of the account for which to get or update LIA settings.
         */
        accountId?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Liasettings$Getaccessiblegmbaccounts extends StandardParameters {
        /**
         * The ID of the account for which to retrieve accessible Google My Business accounts.
         */
        accountId?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Liasettings$List extends StandardParameters {
        /**
         * The maximum number of LIA settings to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the managing account. This must be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Liasettings$Listposdataproviders extends StandardParameters {
    }
    export interface Params$Resource$Liasettings$Requestgmbaccess extends StandardParameters {
        /**
         * The ID of the account for which GMB access is requested.
         */
        accountId?: string;
        /**
         * The email of the Google My Business account.
         */
        gmbEmail?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Liasettings$Requestinventoryverification extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        accountId?: string;
        /**
         * The country for which inventory validation is requested.
         */
        country?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Liasettings$Setinventoryverificationcontact extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        accountId?: string;
        /**
         * The email of the inventory verification contact.
         */
        contactEmail?: string;
        /**
         * The name of the inventory verification contact.
         */
        contactName?: string;
        /**
         * The country for which inventory verification is requested.
         */
        country?: string;
        /**
         * The language for which inventory verification is requested.
         */
        language?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Liasettings$Setposdataprovider extends StandardParameters {
        /**
         * The ID of the account for which to retrieve accessible Google My Business accounts.
         */
        accountId?: string;
        /**
         * The country for which the POS data provider is selected.
         */
        country?: 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.
         */
        merchantId?: string;
        /**
         * The ID of POS data provider.
         */
        posDataProviderId?: string;
        /**
         * The account ID by which this merchant is known to the POS data provider.
         */
        posExternalAccountId?: string;
    }
    export interface Params$Resource$Liasettings$Update extends StandardParameters {
        /**
         * The ID of the account for which to get or update LIA settings.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$LiaSettings;
    }
    export class Resource$Localinventory {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Updates local inventory for multiple products or stores in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.localinventory.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Localinventory$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Localinventory$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$LocalinventoryCustomBatchResponse>;
        custombatch(params: Params$Resource$Localinventory$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Localinventory$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$LocalinventoryCustomBatchResponse>, callback: BodyResponseCallback<Schema$LocalinventoryCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Localinventory$Custombatch, callback: BodyResponseCallback<Schema$LocalinventoryCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$LocalinventoryCustomBatchResponse>): void;
        /**
         * Updates the local inventory of a product in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.localinventory.insert({
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The REST ID of the product for which to update local inventory.
         *     productId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "availability": "my_availability",
         *       //   "instoreProductLocation": "my_instoreProductLocation",
         *       //   "kind": "my_kind",
         *       //   "pickupMethod": "my_pickupMethod",
         *       //   "pickupSla": "my_pickupSla",
         *       //   "price": {},
         *       //   "quantity": 0,
         *       //   "salePrice": {},
         *       //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *       //   "storeCode": "my_storeCode"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "availability": "my_availability",
         *   //   "instoreProductLocation": "my_instoreProductLocation",
         *   //   "kind": "my_kind",
         *   //   "pickupMethod": "my_pickupMethod",
         *   //   "pickupSla": "my_pickupSla",
         *   //   "price": {},
         *   //   "quantity": 0,
         *   //   "salePrice": {},
         *   //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *   //   "storeCode": "my_storeCode"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Localinventory$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Localinventory$Insert, options?: MethodOptions): GaxiosPromise<Schema$LocalInventory>;
        insert(params: Params$Resource$Localinventory$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Localinventory$Insert, options: MethodOptions | BodyResponseCallback<Schema$LocalInventory>, callback: BodyResponseCallback<Schema$LocalInventory>): void;
        insert(params: Params$Resource$Localinventory$Insert, callback: BodyResponseCallback<Schema$LocalInventory>): void;
        insert(callback: BodyResponseCallback<Schema$LocalInventory>): void;
    }
    export interface Params$Resource$Localinventory$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$LocalinventoryCustomBatchRequest;
    }
    export interface Params$Resource$Localinventory$Insert extends StandardParameters {
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The REST ID of the product for which to update local inventory.
         */
        productId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$LocalInventory;
    }
    export class Resource$Orderinvoices {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Creates a charge invoice for a shipment group, and triggers a charge capture for orderinvoice enabled orders.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderinvoices.createchargeinvoice({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "invoiceId": "my_invoiceId",
         *       //   "invoiceSummary": {},
         *       //   "lineItemInvoices": [],
         *       //   "operationId": "my_operationId",
         *       //   "shipmentGroupId": "my_shipmentGroupId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        createchargeinvoice(params: Params$Resource$Orderinvoices$Createchargeinvoice, options: StreamMethodOptions): GaxiosPromise<Readable>;
        createchargeinvoice(params?: Params$Resource$Orderinvoices$Createchargeinvoice, options?: MethodOptions): GaxiosPromise<Schema$OrderinvoicesCreateChargeInvoiceResponse>;
        createchargeinvoice(params: Params$Resource$Orderinvoices$Createchargeinvoice, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        createchargeinvoice(params: Params$Resource$Orderinvoices$Createchargeinvoice, options: MethodOptions | BodyResponseCallback<Schema$OrderinvoicesCreateChargeInvoiceResponse>, callback: BodyResponseCallback<Schema$OrderinvoicesCreateChargeInvoiceResponse>): void;
        createchargeinvoice(params: Params$Resource$Orderinvoices$Createchargeinvoice, callback: BodyResponseCallback<Schema$OrderinvoicesCreateChargeInvoiceResponse>): void;
        createchargeinvoice(callback: BodyResponseCallback<Schema$OrderinvoicesCreateChargeInvoiceResponse>): void;
        /**
         * Creates a refund invoice for one or more shipment groups, and triggers a refund for orderinvoice enabled orders. This can only be used for line items that have previously been charged using `createChargeInvoice`. All amounts (except for the summary) are incremental with respect to the previous invoice.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderinvoices.createrefundinvoice({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "invoiceId": "my_invoiceId",
         *       //   "operationId": "my_operationId",
         *       //   "refundOnlyOption": {},
         *       //   "returnOption": {},
         *       //   "shipmentInvoices": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        createrefundinvoice(params: Params$Resource$Orderinvoices$Createrefundinvoice, options: StreamMethodOptions): GaxiosPromise<Readable>;
        createrefundinvoice(params?: Params$Resource$Orderinvoices$Createrefundinvoice, options?: MethodOptions): GaxiosPromise<Schema$OrderinvoicesCreateRefundInvoiceResponse>;
        createrefundinvoice(params: Params$Resource$Orderinvoices$Createrefundinvoice, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        createrefundinvoice(params: Params$Resource$Orderinvoices$Createrefundinvoice, options: MethodOptions | BodyResponseCallback<Schema$OrderinvoicesCreateRefundInvoiceResponse>, callback: BodyResponseCallback<Schema$OrderinvoicesCreateRefundInvoiceResponse>): void;
        createrefundinvoice(params: Params$Resource$Orderinvoices$Createrefundinvoice, callback: BodyResponseCallback<Schema$OrderinvoicesCreateRefundInvoiceResponse>): void;
        createrefundinvoice(callback: BodyResponseCallback<Schema$OrderinvoicesCreateRefundInvoiceResponse>): void;
    }
    export interface Params$Resource$Orderinvoices$Createchargeinvoice extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrderinvoicesCreateChargeInvoiceRequest;
    }
    export interface Params$Resource$Orderinvoices$Createrefundinvoice extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrderinvoicesCreateRefundInvoiceRequest;
    }
    export class Resource$Orderreports {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves a report for disbursements from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreports.listdisbursements({
         *     // The last date which disbursements occurred. In ISO 8601 format. Default: current date.
         *     disbursementEndDate: 'placeholder-value',
         *     // The first date which disbursements occurred. In ISO 8601 format.
         *     disbursementStartDate: 'placeholder-value',
         *     // The maximum number of disbursements to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "disbursements": [],
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        listdisbursements(params: Params$Resource$Orderreports$Listdisbursements, options: StreamMethodOptions): GaxiosPromise<Readable>;
        listdisbursements(params?: Params$Resource$Orderreports$Listdisbursements, options?: MethodOptions): GaxiosPromise<Schema$OrderreportsListDisbursementsResponse>;
        listdisbursements(params: Params$Resource$Orderreports$Listdisbursements, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        listdisbursements(params: Params$Resource$Orderreports$Listdisbursements, options: MethodOptions | BodyResponseCallback<Schema$OrderreportsListDisbursementsResponse>, callback: BodyResponseCallback<Schema$OrderreportsListDisbursementsResponse>): void;
        listdisbursements(params: Params$Resource$Orderreports$Listdisbursements, callback: BodyResponseCallback<Schema$OrderreportsListDisbursementsResponse>): void;
        listdisbursements(callback: BodyResponseCallback<Schema$OrderreportsListDisbursementsResponse>): void;
        /**
         * Retrieves a list of transactions for a disbursement from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreports.listtransactions({
         *     // The Google-provided ID of the disbursement (found in Wallet).
         *     disbursementId: 'placeholder-value',
         *     // The maximum number of disbursements to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *     // The last date in which transaction occurred. In ISO 8601 format. Default: current date.
         *     transactionEndDate: 'placeholder-value',
         *     // The first date in which transaction occurred. In ISO 8601 format.
         *     transactionStartDate: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "transactions": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        listtransactions(params: Params$Resource$Orderreports$Listtransactions, options: StreamMethodOptions): GaxiosPromise<Readable>;
        listtransactions(params?: Params$Resource$Orderreports$Listtransactions, options?: MethodOptions): GaxiosPromise<Schema$OrderreportsListTransactionsResponse>;
        listtransactions(params: Params$Resource$Orderreports$Listtransactions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        listtransactions(params: Params$Resource$Orderreports$Listtransactions, options: MethodOptions | BodyResponseCallback<Schema$OrderreportsListTransactionsResponse>, callback: BodyResponseCallback<Schema$OrderreportsListTransactionsResponse>): void;
        listtransactions(params: Params$Resource$Orderreports$Listtransactions, callback: BodyResponseCallback<Schema$OrderreportsListTransactionsResponse>): void;
        listtransactions(callback: BodyResponseCallback<Schema$OrderreportsListTransactionsResponse>): void;
    }
    export interface Params$Resource$Orderreports$Listdisbursements extends StandardParameters {
        /**
         * The last date which disbursements occurred. In ISO 8601 format. Default: current date.
         */
        disbursementEndDate?: string;
        /**
         * The first date which disbursements occurred. In ISO 8601 format.
         */
        disbursementStartDate?: string;
        /**
         * The maximum number of disbursements to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Orderreports$Listtransactions extends StandardParameters {
        /**
         * The Google-provided ID of the disbursement (found in Wallet).
         */
        disbursementId?: string;
        /**
         * The maximum number of disbursements to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
        /**
         * The last date in which transaction occurred. In ISO 8601 format. Default: current date.
         */
        transactionEndDate?: string;
        /**
         * The first date in which transaction occurred. In ISO 8601 format.
         */
        transactionStartDate?: string;
    }
    export class Resource$Orderreturns {
        context: APIRequestContext;
        labels: Resource$Orderreturns$Labels;
        constructor(context: APIRequestContext);
        /**
         * Acks an order return in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreturns.acknowledge({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the return.
         *     returnId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "operationId": "my_operationId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        acknowledge(params: Params$Resource$Orderreturns$Acknowledge, options: StreamMethodOptions): GaxiosPromise<Readable>;
        acknowledge(params?: Params$Resource$Orderreturns$Acknowledge, options?: MethodOptions): GaxiosPromise<Schema$OrderreturnsAcknowledgeResponse>;
        acknowledge(params: Params$Resource$Orderreturns$Acknowledge, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        acknowledge(params: Params$Resource$Orderreturns$Acknowledge, options: MethodOptions | BodyResponseCallback<Schema$OrderreturnsAcknowledgeResponse>, callback: BodyResponseCallback<Schema$OrderreturnsAcknowledgeResponse>): void;
        acknowledge(params: Params$Resource$Orderreturns$Acknowledge, callback: BodyResponseCallback<Schema$OrderreturnsAcknowledgeResponse>): void;
        acknowledge(callback: BodyResponseCallback<Schema$OrderreturnsAcknowledgeResponse>): void;
        /**
         * Create return in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreturns.createorderreturn({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "lineItems": [],
         *       //   "operationId": "my_operationId",
         *       //   "orderId": "my_orderId",
         *       //   "returnMethodType": "my_returnMethodType"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind",
         *   //   "orderReturn": {}
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        createorderreturn(params: Params$Resource$Orderreturns$Createorderreturn, options: StreamMethodOptions): GaxiosPromise<Readable>;
        createorderreturn(params?: Params$Resource$Orderreturns$Createorderreturn, options?: MethodOptions): GaxiosPromise<Schema$OrderreturnsCreateOrderReturnResponse>;
        createorderreturn(params: Params$Resource$Orderreturns$Createorderreturn, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        createorderreturn(params: Params$Resource$Orderreturns$Createorderreturn, options: MethodOptions | BodyResponseCallback<Schema$OrderreturnsCreateOrderReturnResponse>, callback: BodyResponseCallback<Schema$OrderreturnsCreateOrderReturnResponse>): void;
        createorderreturn(params: Params$Resource$Orderreturns$Createorderreturn, callback: BodyResponseCallback<Schema$OrderreturnsCreateOrderReturnResponse>): void;
        createorderreturn(callback: BodyResponseCallback<Schema$OrderreturnsCreateOrderReturnResponse>): void;
        /**
         * Retrieves an order return from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreturns.get({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // Merchant order return ID generated by Google.
         *     returnId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "creationDate": "my_creationDate",
         *   //   "merchantOrderId": "my_merchantOrderId",
         *   //   "orderId": "my_orderId",
         *   //   "orderReturnId": "my_orderReturnId",
         *   //   "returnItems": [],
         *   //   "returnPricingInfo": {},
         *   //   "returnShipments": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Orderreturns$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Orderreturns$Get, options?: MethodOptions): GaxiosPromise<Schema$MerchantOrderReturn>;
        get(params: Params$Resource$Orderreturns$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Orderreturns$Get, options: MethodOptions | BodyResponseCallback<Schema$MerchantOrderReturn>, callback: BodyResponseCallback<Schema$MerchantOrderReturn>): void;
        get(params: Params$Resource$Orderreturns$Get, callback: BodyResponseCallback<Schema$MerchantOrderReturn>): void;
        get(callback: BodyResponseCallback<Schema$MerchantOrderReturn>): void;
        /**
         * Lists order returns in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreturns.list({
         *     // Obtains order returns that match the acknowledgement status. When set to true, obtains order returns that have been acknowledged. When false, obtains order returns that have not been acknowledged. When not provided, obtains order returns regardless of their acknowledgement status. We recommend using this filter set to `false`, in conjunction with the `acknowledge` call, such that only un-acknowledged order returns are returned.
         *     acknowledged: 'placeholder-value',
         *     // Obtains order returns created before this date (inclusively), in ISO 8601 format.
         *     createdEndDate: 'placeholder-value',
         *     // Obtains order returns created after this date (inclusively), in ISO 8601 format.
         *     createdStartDate: 'placeholder-value',
         *     // Obtains order returns with the specified order ids. If this parameter is provided, createdStartDate, createdEndDate, shipmentType, shipmentStatus, shipmentState and acknowledged parameters must be not set. Note: if googleOrderId and shipmentTrackingNumber parameters are provided, the obtained results will include all order returns that either match the specified order id or the specified tracking number.
         *     googleOrderIds: 'placeholder-value',
         *     // The maximum number of order returns to return in the response, used for paging. The default value is 25 returns per page, and the maximum allowed value is 250 returns per page.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // Return the results in the specified order.
         *     orderBy: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *     // Obtains order returns that match any shipment state provided in this parameter. When this parameter is not provided, order returns are obtained regardless of their shipment states.
         *     shipmentStates: 'placeholder-value',
         *     // Obtains order returns that match any shipment status provided in this parameter. When this parameter is not provided, order returns are obtained regardless of their shipment statuses.
         *     shipmentStatus: 'placeholder-value',
         *     // Obtains order returns with the specified tracking numbers. If this parameter is provided, createdStartDate, createdEndDate, shipmentType, shipmentStatus, shipmentState and acknowledged parameters must be not set. Note: if googleOrderId and shipmentTrackingNumber parameters are provided, the obtained results will include all order returns that either match the specified order id or the specified tracking number.
         *     shipmentTrackingNumbers: 'placeholder-value',
         *     // Obtains order returns that match any shipment type provided in this parameter. When this parameter is not provided, order returns are obtained regardless of their shipment types.
         *     shipmentTypes: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Orderreturns$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Orderreturns$List, options?: MethodOptions): GaxiosPromise<Schema$OrderreturnsListResponse>;
        list(params: Params$Resource$Orderreturns$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Orderreturns$List, options: MethodOptions | BodyResponseCallback<Schema$OrderreturnsListResponse>, callback: BodyResponseCallback<Schema$OrderreturnsListResponse>): void;
        list(params: Params$Resource$Orderreturns$List, callback: BodyResponseCallback<Schema$OrderreturnsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$OrderreturnsListResponse>): void;
        /**
         * Processes return in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreturns.process({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the return.
         *     returnId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "fullChargeReturnShippingCost": false,
         *       //   "operationId": "my_operationId",
         *       //   "refundShippingFee": {},
         *       //   "returnItems": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        process(params: Params$Resource$Orderreturns$Process, options: StreamMethodOptions): GaxiosPromise<Readable>;
        process(params?: Params$Resource$Orderreturns$Process, options?: MethodOptions): GaxiosPromise<Schema$OrderreturnsProcessResponse>;
        process(params: Params$Resource$Orderreturns$Process, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        process(params: Params$Resource$Orderreturns$Process, options: MethodOptions | BodyResponseCallback<Schema$OrderreturnsProcessResponse>, callback: BodyResponseCallback<Schema$OrderreturnsProcessResponse>): void;
        process(params: Params$Resource$Orderreturns$Process, callback: BodyResponseCallback<Schema$OrderreturnsProcessResponse>): void;
        process(callback: BodyResponseCallback<Schema$OrderreturnsProcessResponse>): void;
    }
    export interface Params$Resource$Orderreturns$Acknowledge extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the return.
         */
        returnId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrderreturnsAcknowledgeRequest;
    }
    export interface Params$Resource$Orderreturns$Createorderreturn extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrderreturnsCreateOrderReturnRequest;
    }
    export interface Params$Resource$Orderreturns$Get extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Merchant order return ID generated by Google.
         */
        returnId?: string;
    }
    export interface Params$Resource$Orderreturns$List extends StandardParameters {
        /**
         * Obtains order returns that match the acknowledgement status. When set to true, obtains order returns that have been acknowledged. When false, obtains order returns that have not been acknowledged. When not provided, obtains order returns regardless of their acknowledgement status. We recommend using this filter set to `false`, in conjunction with the `acknowledge` call, such that only un-acknowledged order returns are returned.
         */
        acknowledged?: boolean;
        /**
         * Obtains order returns created before this date (inclusively), in ISO 8601 format.
         */
        createdEndDate?: string;
        /**
         * Obtains order returns created after this date (inclusively), in ISO 8601 format.
         */
        createdStartDate?: string;
        /**
         * Obtains order returns with the specified order ids. If this parameter is provided, createdStartDate, createdEndDate, shipmentType, shipmentStatus, shipmentState and acknowledged parameters must be not set. Note: if googleOrderId and shipmentTrackingNumber parameters are provided, the obtained results will include all order returns that either match the specified order id or the specified tracking number.
         */
        googleOrderIds?: string[];
        /**
         * The maximum number of order returns to return in the response, used for paging. The default value is 25 returns per page, and the maximum allowed value is 250 returns per page.
         */
        maxResults?: number;
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Return the results in the specified order.
         */
        orderBy?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
        /**
         * Obtains order returns that match any shipment state provided in this parameter. When this parameter is not provided, order returns are obtained regardless of their shipment states.
         */
        shipmentStates?: string[];
        /**
         * Obtains order returns that match any shipment status provided in this parameter. When this parameter is not provided, order returns are obtained regardless of their shipment statuses.
         */
        shipmentStatus?: string[];
        /**
         * Obtains order returns with the specified tracking numbers. If this parameter is provided, createdStartDate, createdEndDate, shipmentType, shipmentStatus, shipmentState and acknowledged parameters must be not set. Note: if googleOrderId and shipmentTrackingNumber parameters are provided, the obtained results will include all order returns that either match the specified order id or the specified tracking number.
         */
        shipmentTrackingNumbers?: string[];
        /**
         * Obtains order returns that match any shipment type provided in this parameter. When this parameter is not provided, order returns are obtained regardless of their shipment types.
         */
        shipmentTypes?: string[];
    }
    export interface Params$Resource$Orderreturns$Process extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the return.
         */
        returnId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrderreturnsProcessRequest;
    }
    export class Resource$Orderreturns$Labels {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Links a return shipping label to a return id. You can only create one return label per return id. Since the label is sent to the buyer, the linked return label cannot be updated or deleted. If you try to create multiple return shipping labels for a single return id, every create request except the first will fail.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orderreturns.labels.create({
         *     // Required. The merchant the Return Shipping Label belongs to.
         *     merchantId: 'placeholder-value',
         *     // Required. Provide the Google-generated merchant order return ID.
         *     returnId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "carrier": "my_carrier",
         *       //   "labelUri": "my_labelUri",
         *       //   "trackingId": "my_trackingId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "carrier": "my_carrier",
         *   //   "labelUri": "my_labelUri",
         *   //   "trackingId": "my_trackingId"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Orderreturns$Labels$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Orderreturns$Labels$Create, options?: MethodOptions): GaxiosPromise<Schema$ReturnShippingLabel>;
        create(params: Params$Resource$Orderreturns$Labels$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Orderreturns$Labels$Create, options: MethodOptions | BodyResponseCallback<Schema$ReturnShippingLabel>, callback: BodyResponseCallback<Schema$ReturnShippingLabel>): void;
        create(params: Params$Resource$Orderreturns$Labels$Create, callback: BodyResponseCallback<Schema$ReturnShippingLabel>): void;
        create(callback: BodyResponseCallback<Schema$ReturnShippingLabel>): void;
    }
    export interface Params$Resource$Orderreturns$Labels$Create extends StandardParameters {
        /**
         * Required. The merchant the Return Shipping Label belongs to.
         */
        merchantId?: string;
        /**
         * Required. Provide the Google-generated merchant order return ID.
         */
        returnId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnShippingLabel;
    }
    export class Resource$Orders {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Marks an order as acknowledged.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.acknowledge({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "operationId": "my_operationId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        acknowledge(params: Params$Resource$Orders$Acknowledge, options: StreamMethodOptions): GaxiosPromise<Readable>;
        acknowledge(params?: Params$Resource$Orders$Acknowledge, options?: MethodOptions): GaxiosPromise<Schema$OrdersAcknowledgeResponse>;
        acknowledge(params: Params$Resource$Orders$Acknowledge, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        acknowledge(params: Params$Resource$Orders$Acknowledge, options: MethodOptions | BodyResponseCallback<Schema$OrdersAcknowledgeResponse>, callback: BodyResponseCallback<Schema$OrdersAcknowledgeResponse>): void;
        acknowledge(params: Params$Resource$Orders$Acknowledge, callback: BodyResponseCallback<Schema$OrdersAcknowledgeResponse>): void;
        acknowledge(callback: BodyResponseCallback<Schema$OrdersAcknowledgeResponse>): void;
        /**
         * Sandbox only. Moves a test order from state "`inProgress`" to state "`pendingShipment`".
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.advancetestorder({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the test order to modify.
         *     orderId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        advancetestorder(params: Params$Resource$Orders$Advancetestorder, options: StreamMethodOptions): GaxiosPromise<Readable>;
        advancetestorder(params?: Params$Resource$Orders$Advancetestorder, options?: MethodOptions): GaxiosPromise<Schema$OrdersAdvanceTestOrderResponse>;
        advancetestorder(params: Params$Resource$Orders$Advancetestorder, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        advancetestorder(params: Params$Resource$Orders$Advancetestorder, options: MethodOptions | BodyResponseCallback<Schema$OrdersAdvanceTestOrderResponse>, callback: BodyResponseCallback<Schema$OrdersAdvanceTestOrderResponse>): void;
        advancetestorder(params: Params$Resource$Orders$Advancetestorder, callback: BodyResponseCallback<Schema$OrdersAdvanceTestOrderResponse>): void;
        advancetestorder(callback: BodyResponseCallback<Schema$OrdersAdvanceTestOrderResponse>): void;
        /**
         * Cancels all line items in an order, making a full refund.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.cancel({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order to cancel.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "operationId": "my_operationId",
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        cancel(params: Params$Resource$Orders$Cancel, options: StreamMethodOptions): GaxiosPromise<Readable>;
        cancel(params?: Params$Resource$Orders$Cancel, options?: MethodOptions): GaxiosPromise<Schema$OrdersCancelResponse>;
        cancel(params: Params$Resource$Orders$Cancel, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        cancel(params: Params$Resource$Orders$Cancel, options: MethodOptions | BodyResponseCallback<Schema$OrdersCancelResponse>, callback: BodyResponseCallback<Schema$OrdersCancelResponse>): void;
        cancel(params: Params$Resource$Orders$Cancel, callback: BodyResponseCallback<Schema$OrdersCancelResponse>): void;
        cancel(callback: BodyResponseCallback<Schema$OrdersCancelResponse>): void;
        /**
         * Cancels a line item, making a full refund.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.cancellineitem({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "lineItemId": "my_lineItemId",
         *       //   "operationId": "my_operationId",
         *       //   "productId": "my_productId",
         *       //   "quantity": 0,
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        cancellineitem(params: Params$Resource$Orders$Cancellineitem, options: StreamMethodOptions): GaxiosPromise<Readable>;
        cancellineitem(params?: Params$Resource$Orders$Cancellineitem, options?: MethodOptions): GaxiosPromise<Schema$OrdersCancelLineItemResponse>;
        cancellineitem(params: Params$Resource$Orders$Cancellineitem, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        cancellineitem(params: Params$Resource$Orders$Cancellineitem, options: MethodOptions | BodyResponseCallback<Schema$OrdersCancelLineItemResponse>, callback: BodyResponseCallback<Schema$OrdersCancelLineItemResponse>): void;
        cancellineitem(params: Params$Resource$Orders$Cancellineitem, callback: BodyResponseCallback<Schema$OrdersCancelLineItemResponse>): void;
        cancellineitem(callback: BodyResponseCallback<Schema$OrdersCancelLineItemResponse>): void;
        /**
         * Sandbox only. Cancels a test order for customer-initiated cancellation.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.canceltestorderbycustomer({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the test order to cancel.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "reason": "my_reason"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        canceltestorderbycustomer(params: Params$Resource$Orders$Canceltestorderbycustomer, options: StreamMethodOptions): GaxiosPromise<Readable>;
        canceltestorderbycustomer(params?: Params$Resource$Orders$Canceltestorderbycustomer, options?: MethodOptions): GaxiosPromise<Schema$OrdersCancelTestOrderByCustomerResponse>;
        canceltestorderbycustomer(params: Params$Resource$Orders$Canceltestorderbycustomer, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        canceltestorderbycustomer(params: Params$Resource$Orders$Canceltestorderbycustomer, options: MethodOptions | BodyResponseCallback<Schema$OrdersCancelTestOrderByCustomerResponse>, callback: BodyResponseCallback<Schema$OrdersCancelTestOrderByCustomerResponse>): void;
        canceltestorderbycustomer(params: Params$Resource$Orders$Canceltestorderbycustomer, callback: BodyResponseCallback<Schema$OrdersCancelTestOrderByCustomerResponse>): void;
        canceltestorderbycustomer(callback: BodyResponseCallback<Schema$OrdersCancelTestOrderByCustomerResponse>): void;
        /**
         * Sandbox only. Creates a test order.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.createtestorder({
         *     // The ID of the account that should manage the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "country": "my_country",
         *       //   "templateName": "my_templateName",
         *       //   "testOrder": {}
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "orderId": "my_orderId"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        createtestorder(params: Params$Resource$Orders$Createtestorder, options: StreamMethodOptions): GaxiosPromise<Readable>;
        createtestorder(params?: Params$Resource$Orders$Createtestorder, options?: MethodOptions): GaxiosPromise<Schema$OrdersCreateTestOrderResponse>;
        createtestorder(params: Params$Resource$Orders$Createtestorder, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        createtestorder(params: Params$Resource$Orders$Createtestorder, options: MethodOptions | BodyResponseCallback<Schema$OrdersCreateTestOrderResponse>, callback: BodyResponseCallback<Schema$OrdersCreateTestOrderResponse>): void;
        createtestorder(params: Params$Resource$Orders$Createtestorder, callback: BodyResponseCallback<Schema$OrdersCreateTestOrderResponse>): void;
        createtestorder(callback: BodyResponseCallback<Schema$OrdersCreateTestOrderResponse>): void;
        /**
         * Sandbox only. Creates a test return.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.createtestreturn({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "items": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "returnId": "my_returnId"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        createtestreturn(params: Params$Resource$Orders$Createtestreturn, options: StreamMethodOptions): GaxiosPromise<Readable>;
        createtestreturn(params?: Params$Resource$Orders$Createtestreturn, options?: MethodOptions): GaxiosPromise<Schema$OrdersCreateTestReturnResponse>;
        createtestreturn(params: Params$Resource$Orders$Createtestreturn, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        createtestreturn(params: Params$Resource$Orders$Createtestreturn, options: MethodOptions | BodyResponseCallback<Schema$OrdersCreateTestReturnResponse>, callback: BodyResponseCallback<Schema$OrdersCreateTestReturnResponse>): void;
        createtestreturn(params: Params$Resource$Orders$Createtestreturn, callback: BodyResponseCallback<Schema$OrdersCreateTestReturnResponse>): void;
        createtestreturn(callback: BodyResponseCallback<Schema$OrdersCreateTestReturnResponse>): void;
        /**
         * Retrieves an order from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.get({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "acknowledged": false,
         *   //   "annotations": [],
         *   //   "billingAddress": {},
         *   //   "customer": {},
         *   //   "deliveryDetails": {},
         *   //   "id": "my_id",
         *   //   "kind": "my_kind",
         *   //   "lineItems": [],
         *   //   "merchantId": "my_merchantId",
         *   //   "merchantOrderId": "my_merchantOrderId",
         *   //   "netPriceAmount": {},
         *   //   "netTaxAmount": {},
         *   //   "paymentStatus": "my_paymentStatus",
         *   //   "pickupDetails": {},
         *   //   "placedDate": "my_placedDate",
         *   //   "promotions": [],
         *   //   "refunds": [],
         *   //   "shipments": [],
         *   //   "shippingCost": {},
         *   //   "shippingCostTax": {},
         *   //   "status": "my_status",
         *   //   "taxCollector": "my_taxCollector"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Orders$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Orders$Get, options?: MethodOptions): GaxiosPromise<Schema$Order>;
        get(params: Params$Resource$Orders$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Orders$Get, options: MethodOptions | BodyResponseCallback<Schema$Order>, callback: BodyResponseCallback<Schema$Order>): void;
        get(params: Params$Resource$Orders$Get, callback: BodyResponseCallback<Schema$Order>): void;
        get(callback: BodyResponseCallback<Schema$Order>): void;
        /**
         * Retrieves an order using merchant order ID.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.getbymerchantorderid({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The merchant order ID to be looked for.
         *     merchantOrderId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "order": {}
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        getbymerchantorderid(params: Params$Resource$Orders$Getbymerchantorderid, options: StreamMethodOptions): GaxiosPromise<Readable>;
        getbymerchantorderid(params?: Params$Resource$Orders$Getbymerchantorderid, options?: MethodOptions): GaxiosPromise<Schema$OrdersGetByMerchantOrderIdResponse>;
        getbymerchantorderid(params: Params$Resource$Orders$Getbymerchantorderid, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        getbymerchantorderid(params: Params$Resource$Orders$Getbymerchantorderid, options: MethodOptions | BodyResponseCallback<Schema$OrdersGetByMerchantOrderIdResponse>, callback: BodyResponseCallback<Schema$OrdersGetByMerchantOrderIdResponse>): void;
        getbymerchantorderid(params: Params$Resource$Orders$Getbymerchantorderid, callback: BodyResponseCallback<Schema$OrdersGetByMerchantOrderIdResponse>): void;
        getbymerchantorderid(callback: BodyResponseCallback<Schema$OrdersGetByMerchantOrderIdResponse>): void;
        /**
         * Sandbox only. Retrieves an order template that can be used to quickly create a new order in sandbox.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.gettestordertemplate({
         *     // The country of the template to retrieve. Defaults to `US`.
         *     country: 'placeholder-value',
         *     // The ID of the account that should manage the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The name of the template to retrieve.
         *     templateName: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "template": {}
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        gettestordertemplate(params: Params$Resource$Orders$Gettestordertemplate, options: StreamMethodOptions): GaxiosPromise<Readable>;
        gettestordertemplate(params?: Params$Resource$Orders$Gettestordertemplate, options?: MethodOptions): GaxiosPromise<Schema$OrdersGetTestOrderTemplateResponse>;
        gettestordertemplate(params: Params$Resource$Orders$Gettestordertemplate, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        gettestordertemplate(params: Params$Resource$Orders$Gettestordertemplate, options: MethodOptions | BodyResponseCallback<Schema$OrdersGetTestOrderTemplateResponse>, callback: BodyResponseCallback<Schema$OrdersGetTestOrderTemplateResponse>): void;
        gettestordertemplate(params: Params$Resource$Orders$Gettestordertemplate, callback: BodyResponseCallback<Schema$OrdersGetTestOrderTemplateResponse>): void;
        gettestordertemplate(callback: BodyResponseCallback<Schema$OrdersGetTestOrderTemplateResponse>): void;
        /**
         * Deprecated. Notifies that item return and refund was handled directly by merchant outside of Google payments processing (e.g. cash refund done in store). Note: We recommend calling the returnrefundlineitem method to refund in-store returns. We will issue the refund directly to the customer. This helps to prevent possible differences arising between merchant and Google transaction records. We also recommend having the point of sale system communicate with Google to ensure that customers do not receive a double refund by first refunding via Google then via an in-store return.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.instorerefundlineitem({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "lineItemId": "my_lineItemId",
         *       //   "operationId": "my_operationId",
         *       //   "priceAmount": {},
         *       //   "productId": "my_productId",
         *       //   "quantity": 0,
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText",
         *       //   "taxAmount": {}
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        instorerefundlineitem(params: Params$Resource$Orders$Instorerefundlineitem, options: StreamMethodOptions): GaxiosPromise<Readable>;
        instorerefundlineitem(params?: Params$Resource$Orders$Instorerefundlineitem, options?: MethodOptions): GaxiosPromise<Schema$OrdersInStoreRefundLineItemResponse>;
        instorerefundlineitem(params: Params$Resource$Orders$Instorerefundlineitem, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        instorerefundlineitem(params: Params$Resource$Orders$Instorerefundlineitem, options: MethodOptions | BodyResponseCallback<Schema$OrdersInStoreRefundLineItemResponse>, callback: BodyResponseCallback<Schema$OrdersInStoreRefundLineItemResponse>): void;
        instorerefundlineitem(params: Params$Resource$Orders$Instorerefundlineitem, callback: BodyResponseCallback<Schema$OrdersInStoreRefundLineItemResponse>): void;
        instorerefundlineitem(callback: BodyResponseCallback<Schema$OrdersInStoreRefundLineItemResponse>): void;
        /**
         * Lists the orders in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.list({
         *     // Obtains orders that match the acknowledgement status. When set to true, obtains orders that have been acknowledged. When false, obtains orders that have not been acknowledged. We recommend using this filter set to `false`, in conjunction with the `acknowledge` call, such that only un-acknowledged orders are returned.
         *     acknowledged: 'placeholder-value',
         *     // The maximum number of orders to return in the response, used for paging. The default value is 25 orders per page, and the maximum allowed value is 250 orders per page.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // Order results by placement date in descending or ascending order. Acceptable values are: - placedDateAsc - placedDateDesc
         *     orderBy: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *     // Obtains orders placed before this date (exclusively), in ISO 8601 format.
         *     placedDateEnd: 'placeholder-value',
         *     // Obtains orders placed after this date (inclusively), in ISO 8601 format.
         *     placedDateStart: 'placeholder-value',
         *     // Obtains orders that match any of the specified statuses. Please note that `active` is a shortcut for `pendingShipment` and `partiallyShipped`, and `completed` is a shortcut for `shipped`, `partiallyDelivered`, `delivered`, `partiallyReturned`, `returned`, and `canceled`.
         *     statuses: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Orders$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Orders$List, options?: MethodOptions): GaxiosPromise<Schema$OrdersListResponse>;
        list(params: Params$Resource$Orders$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Orders$List, options: MethodOptions | BodyResponseCallback<Schema$OrdersListResponse>, callback: BodyResponseCallback<Schema$OrdersListResponse>): void;
        list(params: Params$Resource$Orders$List, callback: BodyResponseCallback<Schema$OrdersListResponse>): void;
        list(callback: BodyResponseCallback<Schema$OrdersListResponse>): void;
        /**
         * Issues a partial or total refund for items and shipment.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.refunditem({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order to refund.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "items": [],
         *       //   "operationId": "my_operationId",
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText",
         *       //   "shipping": {}
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        refunditem(params: Params$Resource$Orders$Refunditem, options: StreamMethodOptions): GaxiosPromise<Readable>;
        refunditem(params?: Params$Resource$Orders$Refunditem, options?: MethodOptions): GaxiosPromise<Schema$OrdersRefundItemResponse>;
        refunditem(params: Params$Resource$Orders$Refunditem, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        refunditem(params: Params$Resource$Orders$Refunditem, options: MethodOptions | BodyResponseCallback<Schema$OrdersRefundItemResponse>, callback: BodyResponseCallback<Schema$OrdersRefundItemResponse>): void;
        refunditem(params: Params$Resource$Orders$Refunditem, callback: BodyResponseCallback<Schema$OrdersRefundItemResponse>): void;
        refunditem(callback: BodyResponseCallback<Schema$OrdersRefundItemResponse>): void;
        /**
         * Issues a partial or total refund for an order.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.refundorder({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order to refund.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "amount": {},
         *       //   "fullRefund": false,
         *       //   "operationId": "my_operationId",
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        refundorder(params: Params$Resource$Orders$Refundorder, options: StreamMethodOptions): GaxiosPromise<Readable>;
        refundorder(params?: Params$Resource$Orders$Refundorder, options?: MethodOptions): GaxiosPromise<Schema$OrdersRefundOrderResponse>;
        refundorder(params: Params$Resource$Orders$Refundorder, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        refundorder(params: Params$Resource$Orders$Refundorder, options: MethodOptions | BodyResponseCallback<Schema$OrdersRefundOrderResponse>, callback: BodyResponseCallback<Schema$OrdersRefundOrderResponse>): void;
        refundorder(params: Params$Resource$Orders$Refundorder, callback: BodyResponseCallback<Schema$OrdersRefundOrderResponse>): void;
        refundorder(callback: BodyResponseCallback<Schema$OrdersRefundOrderResponse>): void;
        /**
         * Rejects return on an line item.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.rejectreturnlineitem({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "lineItemId": "my_lineItemId",
         *       //   "operationId": "my_operationId",
         *       //   "productId": "my_productId",
         *       //   "quantity": 0,
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        rejectreturnlineitem(params: Params$Resource$Orders$Rejectreturnlineitem, options: StreamMethodOptions): GaxiosPromise<Readable>;
        rejectreturnlineitem(params?: Params$Resource$Orders$Rejectreturnlineitem, options?: MethodOptions): GaxiosPromise<Schema$OrdersRejectReturnLineItemResponse>;
        rejectreturnlineitem(params: Params$Resource$Orders$Rejectreturnlineitem, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        rejectreturnlineitem(params: Params$Resource$Orders$Rejectreturnlineitem, options: MethodOptions | BodyResponseCallback<Schema$OrdersRejectReturnLineItemResponse>, callback: BodyResponseCallback<Schema$OrdersRejectReturnLineItemResponse>): void;
        rejectreturnlineitem(params: Params$Resource$Orders$Rejectreturnlineitem, callback: BodyResponseCallback<Schema$OrdersRejectReturnLineItemResponse>): void;
        rejectreturnlineitem(callback: BodyResponseCallback<Schema$OrdersRejectReturnLineItemResponse>): void;
        /**
         * Returns and refunds a line item. Note that this method can only be called on fully shipped orders. Please also note that the Orderreturns API is the preferred way to handle returns after you receive a return from a customer. You can use Orderreturns.list or Orderreturns.get to search for the return, and then use Orderreturns.processreturn to issue the refund. If the return cannot be found, then we recommend using this API to issue a refund.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.returnrefundlineitem({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "lineItemId": "my_lineItemId",
         *       //   "operationId": "my_operationId",
         *       //   "priceAmount": {},
         *       //   "productId": "my_productId",
         *       //   "quantity": 0,
         *       //   "reason": "my_reason",
         *       //   "reasonText": "my_reasonText",
         *       //   "taxAmount": {}
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        returnrefundlineitem(params: Params$Resource$Orders$Returnrefundlineitem, options: StreamMethodOptions): GaxiosPromise<Readable>;
        returnrefundlineitem(params?: Params$Resource$Orders$Returnrefundlineitem, options?: MethodOptions): GaxiosPromise<Schema$OrdersReturnRefundLineItemResponse>;
        returnrefundlineitem(params: Params$Resource$Orders$Returnrefundlineitem, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        returnrefundlineitem(params: Params$Resource$Orders$Returnrefundlineitem, options: MethodOptions | BodyResponseCallback<Schema$OrdersReturnRefundLineItemResponse>, callback: BodyResponseCallback<Schema$OrdersReturnRefundLineItemResponse>): void;
        returnrefundlineitem(params: Params$Resource$Orders$Returnrefundlineitem, callback: BodyResponseCallback<Schema$OrdersReturnRefundLineItemResponse>): void;
        returnrefundlineitem(callback: BodyResponseCallback<Schema$OrdersReturnRefundLineItemResponse>): void;
        /**
         * Sets (or overrides if it already exists) merchant provided annotations in the form of key-value pairs. A common use case would be to supply us with additional structured information about a line item that cannot be provided via other methods. Submitted key-value pairs can be retrieved as part of the orders resource.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.setlineitemmetadata({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "annotations": [],
         *       //   "lineItemId": "my_lineItemId",
         *       //   "operationId": "my_operationId",
         *       //   "productId": "my_productId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        setlineitemmetadata(params: Params$Resource$Orders$Setlineitemmetadata, options: StreamMethodOptions): GaxiosPromise<Readable>;
        setlineitemmetadata(params?: Params$Resource$Orders$Setlineitemmetadata, options?: MethodOptions): GaxiosPromise<Schema$OrdersSetLineItemMetadataResponse>;
        setlineitemmetadata(params: Params$Resource$Orders$Setlineitemmetadata, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        setlineitemmetadata(params: Params$Resource$Orders$Setlineitemmetadata, options: MethodOptions | BodyResponseCallback<Schema$OrdersSetLineItemMetadataResponse>, callback: BodyResponseCallback<Schema$OrdersSetLineItemMetadataResponse>): void;
        setlineitemmetadata(params: Params$Resource$Orders$Setlineitemmetadata, callback: BodyResponseCallback<Schema$OrdersSetLineItemMetadataResponse>): void;
        setlineitemmetadata(callback: BodyResponseCallback<Schema$OrdersSetLineItemMetadataResponse>): void;
        /**
         * Marks line item(s) as shipped.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.shiplineitems({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "lineItems": [],
         *       //   "operationId": "my_operationId",
         *       //   "shipmentGroupId": "my_shipmentGroupId",
         *       //   "shipmentInfos": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        shiplineitems(params: Params$Resource$Orders$Shiplineitems, options: StreamMethodOptions): GaxiosPromise<Readable>;
        shiplineitems(params?: Params$Resource$Orders$Shiplineitems, options?: MethodOptions): GaxiosPromise<Schema$OrdersShipLineItemsResponse>;
        shiplineitems(params: Params$Resource$Orders$Shiplineitems, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        shiplineitems(params: Params$Resource$Orders$Shiplineitems, options: MethodOptions | BodyResponseCallback<Schema$OrdersShipLineItemsResponse>, callback: BodyResponseCallback<Schema$OrdersShipLineItemsResponse>): void;
        shiplineitems(params: Params$Resource$Orders$Shiplineitems, callback: BodyResponseCallback<Schema$OrdersShipLineItemsResponse>): void;
        shiplineitems(callback: BodyResponseCallback<Schema$OrdersShipLineItemsResponse>): void;
        /**
         * Updates ship by and delivery by dates for a line item.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.updatelineitemshippingdetails({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "deliverByDate": "my_deliverByDate",
         *       //   "lineItemId": "my_lineItemId",
         *       //   "operationId": "my_operationId",
         *       //   "productId": "my_productId",
         *       //   "shipByDate": "my_shipByDate"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        updatelineitemshippingdetails(params: Params$Resource$Orders$Updatelineitemshippingdetails, options: StreamMethodOptions): GaxiosPromise<Readable>;
        updatelineitemshippingdetails(params?: Params$Resource$Orders$Updatelineitemshippingdetails, options?: MethodOptions): GaxiosPromise<Schema$OrdersUpdateLineItemShippingDetailsResponse>;
        updatelineitemshippingdetails(params: Params$Resource$Orders$Updatelineitemshippingdetails, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        updatelineitemshippingdetails(params: Params$Resource$Orders$Updatelineitemshippingdetails, options: MethodOptions | BodyResponseCallback<Schema$OrdersUpdateLineItemShippingDetailsResponse>, callback: BodyResponseCallback<Schema$OrdersUpdateLineItemShippingDetailsResponse>): void;
        updatelineitemshippingdetails(params: Params$Resource$Orders$Updatelineitemshippingdetails, callback: BodyResponseCallback<Schema$OrdersUpdateLineItemShippingDetailsResponse>): void;
        updatelineitemshippingdetails(callback: BodyResponseCallback<Schema$OrdersUpdateLineItemShippingDetailsResponse>): void;
        /**
         * Updates the merchant order ID for a given order.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.updatemerchantorderid({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "merchantOrderId": "my_merchantOrderId",
         *       //   "operationId": "my_operationId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        updatemerchantorderid(params: Params$Resource$Orders$Updatemerchantorderid, options: StreamMethodOptions): GaxiosPromise<Readable>;
        updatemerchantorderid(params?: Params$Resource$Orders$Updatemerchantorderid, options?: MethodOptions): GaxiosPromise<Schema$OrdersUpdateMerchantOrderIdResponse>;
        updatemerchantorderid(params: Params$Resource$Orders$Updatemerchantorderid, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        updatemerchantorderid(params: Params$Resource$Orders$Updatemerchantorderid, options: MethodOptions | BodyResponseCallback<Schema$OrdersUpdateMerchantOrderIdResponse>, callback: BodyResponseCallback<Schema$OrdersUpdateMerchantOrderIdResponse>): void;
        updatemerchantorderid(params: Params$Resource$Orders$Updatemerchantorderid, callback: BodyResponseCallback<Schema$OrdersUpdateMerchantOrderIdResponse>): void;
        updatemerchantorderid(callback: BodyResponseCallback<Schema$OrdersUpdateMerchantOrderIdResponse>): void;
        /**
         * Updates a shipment's status, carrier, and/or tracking ID.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.orders.updateshipment({
         *     // The ID of the account that manages the order. This cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The ID of the order.
         *     orderId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "carrier": "my_carrier",
         *       //   "deliveryDate": "my_deliveryDate",
         *       //   "lastPickupDate": "my_lastPickupDate",
         *       //   "operationId": "my_operationId",
         *       //   "readyPickupDate": "my_readyPickupDate",
         *       //   "scheduledDeliveryDetails": {},
         *       //   "shipmentId": "my_shipmentId",
         *       //   "status": "my_status",
         *       //   "trackingId": "my_trackingId",
         *       //   "undeliveredDate": "my_undeliveredDate"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "executionStatus": "my_executionStatus",
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        updateshipment(params: Params$Resource$Orders$Updateshipment, options: StreamMethodOptions): GaxiosPromise<Readable>;
        updateshipment(params?: Params$Resource$Orders$Updateshipment, options?: MethodOptions): GaxiosPromise<Schema$OrdersUpdateShipmentResponse>;
        updateshipment(params: Params$Resource$Orders$Updateshipment, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        updateshipment(params: Params$Resource$Orders$Updateshipment, options: MethodOptions | BodyResponseCallback<Schema$OrdersUpdateShipmentResponse>, callback: BodyResponseCallback<Schema$OrdersUpdateShipmentResponse>): void;
        updateshipment(params: Params$Resource$Orders$Updateshipment, callback: BodyResponseCallback<Schema$OrdersUpdateShipmentResponse>): void;
        updateshipment(callback: BodyResponseCallback<Schema$OrdersUpdateShipmentResponse>): void;
    }
    export interface Params$Resource$Orders$Acknowledge extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersAcknowledgeRequest;
    }
    export interface Params$Resource$Orders$Advancetestorder extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the test order to modify.
         */
        orderId?: string;
    }
    export interface Params$Resource$Orders$Cancel extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order to cancel.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersCancelRequest;
    }
    export interface Params$Resource$Orders$Cancellineitem extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersCancelLineItemRequest;
    }
    export interface Params$Resource$Orders$Canceltestorderbycustomer extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the test order to cancel.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersCancelTestOrderByCustomerRequest;
    }
    export interface Params$Resource$Orders$Createtestorder extends StandardParameters {
        /**
         * The ID of the account that should manage the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersCreateTestOrderRequest;
    }
    export interface Params$Resource$Orders$Createtestreturn extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersCreateTestReturnRequest;
    }
    export interface Params$Resource$Orders$Get extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
    }
    export interface Params$Resource$Orders$Getbymerchantorderid extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The merchant order ID to be looked for.
         */
        merchantOrderId?: string;
    }
    export interface Params$Resource$Orders$Gettestordertemplate extends StandardParameters {
        /**
         * The country of the template to retrieve. Defaults to `US`.
         */
        country?: string;
        /**
         * The ID of the account that should manage the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The name of the template to retrieve.
         */
        templateName?: string;
    }
    export interface Params$Resource$Orders$Instorerefundlineitem extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersInStoreRefundLineItemRequest;
    }
    export interface Params$Resource$Orders$List extends StandardParameters {
        /**
         * Obtains orders that match the acknowledgement status. When set to true, obtains orders that have been acknowledged. When false, obtains orders that have not been acknowledged. We recommend using this filter set to `false`, in conjunction with the `acknowledge` call, such that only un-acknowledged orders are returned.
         */
        acknowledged?: boolean;
        /**
         * The maximum number of orders to return in the response, used for paging. The default value is 25 orders per page, and the maximum allowed value is 250 orders per page.
         */
        maxResults?: number;
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Order results by placement date in descending or ascending order. Acceptable values are: - placedDateAsc - placedDateDesc
         */
        orderBy?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
        /**
         * Obtains orders placed before this date (exclusively), in ISO 8601 format.
         */
        placedDateEnd?: string;
        /**
         * Obtains orders placed after this date (inclusively), in ISO 8601 format.
         */
        placedDateStart?: string;
        /**
         * Obtains orders that match any of the specified statuses. Please note that `active` is a shortcut for `pendingShipment` and `partiallyShipped`, and `completed` is a shortcut for `shipped`, `partiallyDelivered`, `delivered`, `partiallyReturned`, `returned`, and `canceled`.
         */
        statuses?: string[];
    }
    export interface Params$Resource$Orders$Refunditem extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order to refund.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersRefundItemRequest;
    }
    export interface Params$Resource$Orders$Refundorder extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order to refund.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersRefundOrderRequest;
    }
    export interface Params$Resource$Orders$Rejectreturnlineitem extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersRejectReturnLineItemRequest;
    }
    export interface Params$Resource$Orders$Returnrefundlineitem extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersReturnRefundLineItemRequest;
    }
    export interface Params$Resource$Orders$Setlineitemmetadata extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersSetLineItemMetadataRequest;
    }
    export interface Params$Resource$Orders$Shiplineitems extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersShipLineItemsRequest;
    }
    export interface Params$Resource$Orders$Updatelineitemshippingdetails extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersUpdateLineItemShippingDetailsRequest;
    }
    export interface Params$Resource$Orders$Updatemerchantorderid extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersUpdateMerchantOrderIdRequest;
    }
    export interface Params$Resource$Orders$Updateshipment extends StandardParameters {
        /**
         * The ID of the account that manages the order. This cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The ID of the order.
         */
        orderId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrdersUpdateShipmentRequest;
    }
    export class Resource$Ordertrackingsignals {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Creates new order tracking signal.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.ordertrackingsignals.create({
         *     // The ID of the merchant for which the order signal is created.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "customerShippingFee": {},
         *       //   "deliveryPostalCode": "my_deliveryPostalCode",
         *       //   "deliveryRegionCode": "my_deliveryRegionCode",
         *       //   "lineItems": [],
         *       //   "merchantId": "my_merchantId",
         *       //   "orderCreatedTime": {},
         *       //   "orderId": "my_orderId",
         *       //   "orderTrackingSignalId": "my_orderTrackingSignalId",
         *       //   "shipmentLineItemMapping": [],
         *       //   "shippingInfo": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "customerShippingFee": {},
         *   //   "deliveryPostalCode": "my_deliveryPostalCode",
         *   //   "deliveryRegionCode": "my_deliveryRegionCode",
         *   //   "lineItems": [],
         *   //   "merchantId": "my_merchantId",
         *   //   "orderCreatedTime": {},
         *   //   "orderId": "my_orderId",
         *   //   "orderTrackingSignalId": "my_orderTrackingSignalId",
         *   //   "shipmentLineItemMapping": [],
         *   //   "shippingInfo": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Ordertrackingsignals$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Ordertrackingsignals$Create, options?: MethodOptions): GaxiosPromise<Schema$OrderTrackingSignal>;
        create(params: Params$Resource$Ordertrackingsignals$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Ordertrackingsignals$Create, options: MethodOptions | BodyResponseCallback<Schema$OrderTrackingSignal>, callback: BodyResponseCallback<Schema$OrderTrackingSignal>): void;
        create(params: Params$Resource$Ordertrackingsignals$Create, callback: BodyResponseCallback<Schema$OrderTrackingSignal>): void;
        create(callback: BodyResponseCallback<Schema$OrderTrackingSignal>): void;
    }
    export interface Params$Resource$Ordertrackingsignals$Create extends StandardParameters {
        /**
         * The ID of the merchant for which the order signal is created.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$OrderTrackingSignal;
    }
    export class Resource$Pos {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Batches multiple POS-related calls in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Pos$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Pos$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$PosCustomBatchResponse>;
        custombatch(params: Params$Resource$Pos$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Pos$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$PosCustomBatchResponse>, callback: BodyResponseCallback<Schema$PosCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Pos$Custombatch, callback: BodyResponseCallback<Schema$PosCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$PosCustomBatchResponse>): void;
        /**
         * Deletes a store for the given merchant.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.delete({
         *     // The ID of the POS or inventory data provider.
         *     merchantId: 'placeholder-value',
         *     // A store code that is unique per merchant.
         *     storeCode: 'placeholder-value',
         *     // The ID of the target merchant.
         *     targetMerchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Pos$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Pos$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Pos$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Pos$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Pos$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves information about the given store.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.get({
         *     // The ID of the POS or inventory data provider.
         *     merchantId: 'placeholder-value',
         *     // A store code that is unique per merchant.
         *     storeCode: 'placeholder-value',
         *     // The ID of the target merchant.
         *     targetMerchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "storeAddress": "my_storeAddress",
         *   //   "storeCode": "my_storeCode"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Pos$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Pos$Get, options?: MethodOptions): GaxiosPromise<Schema$PosStore>;
        get(params: Params$Resource$Pos$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Pos$Get, options: MethodOptions | BodyResponseCallback<Schema$PosStore>, callback: BodyResponseCallback<Schema$PosStore>): void;
        get(params: Params$Resource$Pos$Get, callback: BodyResponseCallback<Schema$PosStore>): void;
        get(callback: BodyResponseCallback<Schema$PosStore>): void;
        /**
         * Creates a store for the given merchant.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.insert({
         *     // The ID of the POS or inventory data provider.
         *     merchantId: 'placeholder-value',
         *     // The ID of the target merchant.
         *     targetMerchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "kind": "my_kind",
         *       //   "storeAddress": "my_storeAddress",
         *       //   "storeCode": "my_storeCode"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "storeAddress": "my_storeAddress",
         *   //   "storeCode": "my_storeCode"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Pos$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Pos$Insert, options?: MethodOptions): GaxiosPromise<Schema$PosStore>;
        insert(params: Params$Resource$Pos$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Pos$Insert, options: MethodOptions | BodyResponseCallback<Schema$PosStore>, callback: BodyResponseCallback<Schema$PosStore>): void;
        insert(params: Params$Resource$Pos$Insert, callback: BodyResponseCallback<Schema$PosStore>): void;
        insert(callback: BodyResponseCallback<Schema$PosStore>): void;
        /**
         * Submit inventory for the given merchant.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.inventory({
         *     // The ID of the POS or inventory data provider.
         *     merchantId: 'placeholder-value',
         *     // The ID of the target merchant.
         *     targetMerchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "contentLanguage": "my_contentLanguage",
         *       //   "gtin": "my_gtin",
         *       //   "itemId": "my_itemId",
         *       //   "price": {},
         *       //   "quantity": "my_quantity",
         *       //   "storeCode": "my_storeCode",
         *       //   "targetCountry": "my_targetCountry",
         *       //   "timestamp": "my_timestamp"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "contentLanguage": "my_contentLanguage",
         *   //   "gtin": "my_gtin",
         *   //   "itemId": "my_itemId",
         *   //   "kind": "my_kind",
         *   //   "price": {},
         *   //   "quantity": "my_quantity",
         *   //   "storeCode": "my_storeCode",
         *   //   "targetCountry": "my_targetCountry",
         *   //   "timestamp": "my_timestamp"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        inventory(params: Params$Resource$Pos$Inventory, options: StreamMethodOptions): GaxiosPromise<Readable>;
        inventory(params?: Params$Resource$Pos$Inventory, options?: MethodOptions): GaxiosPromise<Schema$PosInventoryResponse>;
        inventory(params: Params$Resource$Pos$Inventory, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        inventory(params: Params$Resource$Pos$Inventory, options: MethodOptions | BodyResponseCallback<Schema$PosInventoryResponse>, callback: BodyResponseCallback<Schema$PosInventoryResponse>): void;
        inventory(params: Params$Resource$Pos$Inventory, callback: BodyResponseCallback<Schema$PosInventoryResponse>): void;
        inventory(callback: BodyResponseCallback<Schema$PosInventoryResponse>): void;
        /**
         * Lists the stores of the target merchant.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.list({
         *     // The ID of the POS or inventory data provider.
         *     merchantId: 'placeholder-value',
         *     // The ID of the target merchant.
         *     targetMerchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Pos$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Pos$List, options?: MethodOptions): GaxiosPromise<Schema$PosListResponse>;
        list(params: Params$Resource$Pos$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Pos$List, options: MethodOptions | BodyResponseCallback<Schema$PosListResponse>, callback: BodyResponseCallback<Schema$PosListResponse>): void;
        list(params: Params$Resource$Pos$List, callback: BodyResponseCallback<Schema$PosListResponse>): void;
        list(callback: BodyResponseCallback<Schema$PosListResponse>): void;
        /**
         * Submit a sale event for the given merchant.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pos.sale({
         *     // The ID of the POS or inventory data provider.
         *     merchantId: 'placeholder-value',
         *     // The ID of the target merchant.
         *     targetMerchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "contentLanguage": "my_contentLanguage",
         *       //   "gtin": "my_gtin",
         *       //   "itemId": "my_itemId",
         *       //   "price": {},
         *       //   "quantity": "my_quantity",
         *       //   "saleId": "my_saleId",
         *       //   "storeCode": "my_storeCode",
         *       //   "targetCountry": "my_targetCountry",
         *       //   "timestamp": "my_timestamp"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "contentLanguage": "my_contentLanguage",
         *   //   "gtin": "my_gtin",
         *   //   "itemId": "my_itemId",
         *   //   "kind": "my_kind",
         *   //   "price": {},
         *   //   "quantity": "my_quantity",
         *   //   "saleId": "my_saleId",
         *   //   "storeCode": "my_storeCode",
         *   //   "targetCountry": "my_targetCountry",
         *   //   "timestamp": "my_timestamp"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        sale(params: Params$Resource$Pos$Sale, options: StreamMethodOptions): GaxiosPromise<Readable>;
        sale(params?: Params$Resource$Pos$Sale, options?: MethodOptions): GaxiosPromise<Schema$PosSaleResponse>;
        sale(params: Params$Resource$Pos$Sale, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        sale(params: Params$Resource$Pos$Sale, options: MethodOptions | BodyResponseCallback<Schema$PosSaleResponse>, callback: BodyResponseCallback<Schema$PosSaleResponse>): void;
        sale(params: Params$Resource$Pos$Sale, callback: BodyResponseCallback<Schema$PosSaleResponse>): void;
        sale(callback: BodyResponseCallback<Schema$PosSaleResponse>): void;
    }
    export interface Params$Resource$Pos$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$PosCustomBatchRequest;
    }
    export interface Params$Resource$Pos$Delete extends StandardParameters {
        /**
         * The ID of the POS or inventory data provider.
         */
        merchantId?: string;
        /**
         * A store code that is unique per merchant.
         */
        storeCode?: string;
        /**
         * The ID of the target merchant.
         */
        targetMerchantId?: string;
    }
    export interface Params$Resource$Pos$Get extends StandardParameters {
        /**
         * The ID of the POS or inventory data provider.
         */
        merchantId?: string;
        /**
         * A store code that is unique per merchant.
         */
        storeCode?: string;
        /**
         * The ID of the target merchant.
         */
        targetMerchantId?: string;
    }
    export interface Params$Resource$Pos$Insert extends StandardParameters {
        /**
         * The ID of the POS or inventory data provider.
         */
        merchantId?: string;
        /**
         * The ID of the target merchant.
         */
        targetMerchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$PosStore;
    }
    export interface Params$Resource$Pos$Inventory extends StandardParameters {
        /**
         * The ID of the POS or inventory data provider.
         */
        merchantId?: string;
        /**
         * The ID of the target merchant.
         */
        targetMerchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$PosInventoryRequest;
    }
    export interface Params$Resource$Pos$List extends StandardParameters {
        /**
         * The ID of the POS or inventory data provider.
         */
        merchantId?: string;
        /**
         * The ID of the target merchant.
         */
        targetMerchantId?: string;
    }
    export interface Params$Resource$Pos$Sale extends StandardParameters {
        /**
         * The ID of the POS or inventory data provider.
         */
        merchantId?: string;
        /**
         * The ID of the target merchant.
         */
        targetMerchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$PosSaleRequest;
    }
    export class Resource$Products {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves, inserts, and deletes multiple products in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.products.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Products$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Products$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$ProductsCustomBatchResponse>;
        custombatch(params: Params$Resource$Products$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Products$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$ProductsCustomBatchResponse>, callback: BodyResponseCallback<Schema$ProductsCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Products$Custombatch, callback: BodyResponseCallback<Schema$ProductsCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$ProductsCustomBatchResponse>): void;
        /**
         * Deletes a product from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.products.delete({
         *     // The Content API Supplemental Feed ID.
         *     feedId: 'placeholder-value',
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The REST ID of the product.
         *     productId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Products$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Products$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Products$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Products$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Products$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves a product from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.products.get({
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The REST ID of the product.
         *     productId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "additionalImageLinks": [],
         *   //   "additionalSizeType": "my_additionalSizeType",
         *   //   "adsGrouping": "my_adsGrouping",
         *   //   "adsLabels": [],
         *   //   "adsRedirect": "my_adsRedirect",
         *   //   "adult": false,
         *   //   "ageGroup": "my_ageGroup",
         *   //   "availability": "my_availability",
         *   //   "availabilityDate": "my_availabilityDate",
         *   //   "brand": "my_brand",
         *   //   "canonicalLink": "my_canonicalLink",
         *   //   "channel": "my_channel",
         *   //   "color": "my_color",
         *   //   "condition": "my_condition",
         *   //   "contentLanguage": "my_contentLanguage",
         *   //   "costOfGoodsSold": {},
         *   //   "customAttributes": [],
         *   //   "customLabel0": "my_customLabel0",
         *   //   "customLabel1": "my_customLabel1",
         *   //   "customLabel2": "my_customLabel2",
         *   //   "customLabel3": "my_customLabel3",
         *   //   "customLabel4": "my_customLabel4",
         *   //   "description": "my_description",
         *   //   "displayAdsId": "my_displayAdsId",
         *   //   "displayAdsLink": "my_displayAdsLink",
         *   //   "displayAdsSimilarIds": [],
         *   //   "displayAdsTitle": "my_displayAdsTitle",
         *   //   "displayAdsValue": {},
         *   //   "energyEfficiencyClass": "my_energyEfficiencyClass",
         *   //   "excludedDestinations": [],
         *   //   "expirationDate": "my_expirationDate",
         *   //   "gender": "my_gender",
         *   //   "googleProductCategory": "my_googleProductCategory",
         *   //   "gtin": "my_gtin",
         *   //   "id": "my_id",
         *   //   "identifierExists": false,
         *   //   "imageLink": "my_imageLink",
         *   //   "includedDestinations": [],
         *   //   "installment": {},
         *   //   "isBundle": false,
         *   //   "itemGroupId": "my_itemGroupId",
         *   //   "kind": "my_kind",
         *   //   "link": "my_link",
         *   //   "linkTemplate": "my_linkTemplate",
         *   //   "loyaltyPoints": {},
         *   //   "material": "my_material",
         *   //   "maxEnergyEfficiencyClass": "my_maxEnergyEfficiencyClass",
         *   //   "maxHandlingTime": "my_maxHandlingTime",
         *   //   "minEnergyEfficiencyClass": "my_minEnergyEfficiencyClass",
         *   //   "minHandlingTime": "my_minHandlingTime",
         *   //   "mobileLink": "my_mobileLink",
         *   //   "mobileLinkTemplate": "my_mobileLinkTemplate",
         *   //   "mpn": "my_mpn",
         *   //   "multipack": "my_multipack",
         *   //   "offerId": "my_offerId",
         *   //   "pattern": "my_pattern",
         *   //   "pickupMethod": "my_pickupMethod",
         *   //   "pickupSla": "my_pickupSla",
         *   //   "price": {},
         *   //   "productDetails": [],
         *   //   "productHighlights": [],
         *   //   "productTypes": [],
         *   //   "promotionIds": [],
         *   //   "salePrice": {},
         *   //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *   //   "sellOnGoogleQuantity": "my_sellOnGoogleQuantity",
         *   //   "shipping": [],
         *   //   "shippingHeight": {},
         *   //   "shippingLabel": "my_shippingLabel",
         *   //   "shippingLength": {},
         *   //   "shippingWeight": {},
         *   //   "shippingWidth": {},
         *   //   "shoppingAdsExcludedCountries": [],
         *   //   "sizeSystem": "my_sizeSystem",
         *   //   "sizeType": "my_sizeType",
         *   //   "sizes": [],
         *   //   "source": "my_source",
         *   //   "subscriptionCost": {},
         *   //   "targetCountry": "my_targetCountry",
         *   //   "taxCategory": "my_taxCategory",
         *   //   "taxes": [],
         *   //   "title": "my_title",
         *   //   "transitTimeLabel": "my_transitTimeLabel",
         *   //   "unitPricingBaseMeasure": {},
         *   //   "unitPricingMeasure": {}
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Products$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Products$Get, options?: MethodOptions): GaxiosPromise<Schema$Product>;
        get(params: Params$Resource$Products$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Products$Get, options: MethodOptions | BodyResponseCallback<Schema$Product>, callback: BodyResponseCallback<Schema$Product>): void;
        get(params: Params$Resource$Products$Get, callback: BodyResponseCallback<Schema$Product>): void;
        get(callback: BodyResponseCallback<Schema$Product>): void;
        /**
         * Uploads a product to your Merchant Center account. If an item with the same channel, contentLanguage, offerId, and targetCountry already exists, this method updates that entry.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.products.insert({
         *     // The Content API Supplemental Feed ID.
         *     feedId: 'placeholder-value',
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "additionalImageLinks": [],
         *       //   "additionalSizeType": "my_additionalSizeType",
         *       //   "adsGrouping": "my_adsGrouping",
         *       //   "adsLabels": [],
         *       //   "adsRedirect": "my_adsRedirect",
         *       //   "adult": false,
         *       //   "ageGroup": "my_ageGroup",
         *       //   "availability": "my_availability",
         *       //   "availabilityDate": "my_availabilityDate",
         *       //   "brand": "my_brand",
         *       //   "canonicalLink": "my_canonicalLink",
         *       //   "channel": "my_channel",
         *       //   "color": "my_color",
         *       //   "condition": "my_condition",
         *       //   "contentLanguage": "my_contentLanguage",
         *       //   "costOfGoodsSold": {},
         *       //   "customAttributes": [],
         *       //   "customLabel0": "my_customLabel0",
         *       //   "customLabel1": "my_customLabel1",
         *       //   "customLabel2": "my_customLabel2",
         *       //   "customLabel3": "my_customLabel3",
         *       //   "customLabel4": "my_customLabel4",
         *       //   "description": "my_description",
         *       //   "displayAdsId": "my_displayAdsId",
         *       //   "displayAdsLink": "my_displayAdsLink",
         *       //   "displayAdsSimilarIds": [],
         *       //   "displayAdsTitle": "my_displayAdsTitle",
         *       //   "displayAdsValue": {},
         *       //   "energyEfficiencyClass": "my_energyEfficiencyClass",
         *       //   "excludedDestinations": [],
         *       //   "expirationDate": "my_expirationDate",
         *       //   "gender": "my_gender",
         *       //   "googleProductCategory": "my_googleProductCategory",
         *       //   "gtin": "my_gtin",
         *       //   "id": "my_id",
         *       //   "identifierExists": false,
         *       //   "imageLink": "my_imageLink",
         *       //   "includedDestinations": [],
         *       //   "installment": {},
         *       //   "isBundle": false,
         *       //   "itemGroupId": "my_itemGroupId",
         *       //   "kind": "my_kind",
         *       //   "link": "my_link",
         *       //   "linkTemplate": "my_linkTemplate",
         *       //   "loyaltyPoints": {},
         *       //   "material": "my_material",
         *       //   "maxEnergyEfficiencyClass": "my_maxEnergyEfficiencyClass",
         *       //   "maxHandlingTime": "my_maxHandlingTime",
         *       //   "minEnergyEfficiencyClass": "my_minEnergyEfficiencyClass",
         *       //   "minHandlingTime": "my_minHandlingTime",
         *       //   "mobileLink": "my_mobileLink",
         *       //   "mobileLinkTemplate": "my_mobileLinkTemplate",
         *       //   "mpn": "my_mpn",
         *       //   "multipack": "my_multipack",
         *       //   "offerId": "my_offerId",
         *       //   "pattern": "my_pattern",
         *       //   "pickupMethod": "my_pickupMethod",
         *       //   "pickupSla": "my_pickupSla",
         *       //   "price": {},
         *       //   "productDetails": [],
         *       //   "productHighlights": [],
         *       //   "productTypes": [],
         *       //   "promotionIds": [],
         *       //   "salePrice": {},
         *       //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *       //   "sellOnGoogleQuantity": "my_sellOnGoogleQuantity",
         *       //   "shipping": [],
         *       //   "shippingHeight": {},
         *       //   "shippingLabel": "my_shippingLabel",
         *       //   "shippingLength": {},
         *       //   "shippingWeight": {},
         *       //   "shippingWidth": {},
         *       //   "shoppingAdsExcludedCountries": [],
         *       //   "sizeSystem": "my_sizeSystem",
         *       //   "sizeType": "my_sizeType",
         *       //   "sizes": [],
         *       //   "source": "my_source",
         *       //   "subscriptionCost": {},
         *       //   "targetCountry": "my_targetCountry",
         *       //   "taxCategory": "my_taxCategory",
         *       //   "taxes": [],
         *       //   "title": "my_title",
         *       //   "transitTimeLabel": "my_transitTimeLabel",
         *       //   "unitPricingBaseMeasure": {},
         *       //   "unitPricingMeasure": {}
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "additionalImageLinks": [],
         *   //   "additionalSizeType": "my_additionalSizeType",
         *   //   "adsGrouping": "my_adsGrouping",
         *   //   "adsLabels": [],
         *   //   "adsRedirect": "my_adsRedirect",
         *   //   "adult": false,
         *   //   "ageGroup": "my_ageGroup",
         *   //   "availability": "my_availability",
         *   //   "availabilityDate": "my_availabilityDate",
         *   //   "brand": "my_brand",
         *   //   "canonicalLink": "my_canonicalLink",
         *   //   "channel": "my_channel",
         *   //   "color": "my_color",
         *   //   "condition": "my_condition",
         *   //   "contentLanguage": "my_contentLanguage",
         *   //   "costOfGoodsSold": {},
         *   //   "customAttributes": [],
         *   //   "customLabel0": "my_customLabel0",
         *   //   "customLabel1": "my_customLabel1",
         *   //   "customLabel2": "my_customLabel2",
         *   //   "customLabel3": "my_customLabel3",
         *   //   "customLabel4": "my_customLabel4",
         *   //   "description": "my_description",
         *   //   "displayAdsId": "my_displayAdsId",
         *   //   "displayAdsLink": "my_displayAdsLink",
         *   //   "displayAdsSimilarIds": [],
         *   //   "displayAdsTitle": "my_displayAdsTitle",
         *   //   "displayAdsValue": {},
         *   //   "energyEfficiencyClass": "my_energyEfficiencyClass",
         *   //   "excludedDestinations": [],
         *   //   "expirationDate": "my_expirationDate",
         *   //   "gender": "my_gender",
         *   //   "googleProductCategory": "my_googleProductCategory",
         *   //   "gtin": "my_gtin",
         *   //   "id": "my_id",
         *   //   "identifierExists": false,
         *   //   "imageLink": "my_imageLink",
         *   //   "includedDestinations": [],
         *   //   "installment": {},
         *   //   "isBundle": false,
         *   //   "itemGroupId": "my_itemGroupId",
         *   //   "kind": "my_kind",
         *   //   "link": "my_link",
         *   //   "linkTemplate": "my_linkTemplate",
         *   //   "loyaltyPoints": {},
         *   //   "material": "my_material",
         *   //   "maxEnergyEfficiencyClass": "my_maxEnergyEfficiencyClass",
         *   //   "maxHandlingTime": "my_maxHandlingTime",
         *   //   "minEnergyEfficiencyClass": "my_minEnergyEfficiencyClass",
         *   //   "minHandlingTime": "my_minHandlingTime",
         *   //   "mobileLink": "my_mobileLink",
         *   //   "mobileLinkTemplate": "my_mobileLinkTemplate",
         *   //   "mpn": "my_mpn",
         *   //   "multipack": "my_multipack",
         *   //   "offerId": "my_offerId",
         *   //   "pattern": "my_pattern",
         *   //   "pickupMethod": "my_pickupMethod",
         *   //   "pickupSla": "my_pickupSla",
         *   //   "price": {},
         *   //   "productDetails": [],
         *   //   "productHighlights": [],
         *   //   "productTypes": [],
         *   //   "promotionIds": [],
         *   //   "salePrice": {},
         *   //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *   //   "sellOnGoogleQuantity": "my_sellOnGoogleQuantity",
         *   //   "shipping": [],
         *   //   "shippingHeight": {},
         *   //   "shippingLabel": "my_shippingLabel",
         *   //   "shippingLength": {},
         *   //   "shippingWeight": {},
         *   //   "shippingWidth": {},
         *   //   "shoppingAdsExcludedCountries": [],
         *   //   "sizeSystem": "my_sizeSystem",
         *   //   "sizeType": "my_sizeType",
         *   //   "sizes": [],
         *   //   "source": "my_source",
         *   //   "subscriptionCost": {},
         *   //   "targetCountry": "my_targetCountry",
         *   //   "taxCategory": "my_taxCategory",
         *   //   "taxes": [],
         *   //   "title": "my_title",
         *   //   "transitTimeLabel": "my_transitTimeLabel",
         *   //   "unitPricingBaseMeasure": {},
         *   //   "unitPricingMeasure": {}
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Products$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Products$Insert, options?: MethodOptions): GaxiosPromise<Schema$Product>;
        insert(params: Params$Resource$Products$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Products$Insert, options: MethodOptions | BodyResponseCallback<Schema$Product>, callback: BodyResponseCallback<Schema$Product>): void;
        insert(params: Params$Resource$Products$Insert, callback: BodyResponseCallback<Schema$Product>): void;
        insert(callback: BodyResponseCallback<Schema$Product>): void;
        /**
         * Lists the products in your Merchant Center account. The response might contain fewer items than specified by maxResults. Rely on nextPageToken to determine if there are more items to be requested.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.products.list({
         *     // The maximum number of products to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that contains the products. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Products$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Products$List, options?: MethodOptions): GaxiosPromise<Schema$ProductsListResponse>;
        list(params: Params$Resource$Products$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Products$List, options: MethodOptions | BodyResponseCallback<Schema$ProductsListResponse>, callback: BodyResponseCallback<Schema$ProductsListResponse>): void;
        list(params: Params$Resource$Products$List, callback: BodyResponseCallback<Schema$ProductsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$ProductsListResponse>): void;
        /**
         * Updates an existing product in your Merchant Center account. Only updates attributes provided in the request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.products.update({
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The REST ID of the product for which to update.
         *     productId: 'placeholder-value',
         *     // The comma-separated list of product attributes to be updated. Example: `"title,salePrice"`. Attributes specified in the update mask without a value specified in the body will be deleted from the product. Only top-level product attributes can be updated. If not defined, product attributes with set values will be updated and other attributes will stay unchanged.
         *     updateMask: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "additionalImageLinks": [],
         *       //   "additionalSizeType": "my_additionalSizeType",
         *       //   "adsGrouping": "my_adsGrouping",
         *       //   "adsLabels": [],
         *       //   "adsRedirect": "my_adsRedirect",
         *       //   "adult": false,
         *       //   "ageGroup": "my_ageGroup",
         *       //   "availability": "my_availability",
         *       //   "availabilityDate": "my_availabilityDate",
         *       //   "brand": "my_brand",
         *       //   "canonicalLink": "my_canonicalLink",
         *       //   "channel": "my_channel",
         *       //   "color": "my_color",
         *       //   "condition": "my_condition",
         *       //   "contentLanguage": "my_contentLanguage",
         *       //   "costOfGoodsSold": {},
         *       //   "customAttributes": [],
         *       //   "customLabel0": "my_customLabel0",
         *       //   "customLabel1": "my_customLabel1",
         *       //   "customLabel2": "my_customLabel2",
         *       //   "customLabel3": "my_customLabel3",
         *       //   "customLabel4": "my_customLabel4",
         *       //   "description": "my_description",
         *       //   "displayAdsId": "my_displayAdsId",
         *       //   "displayAdsLink": "my_displayAdsLink",
         *       //   "displayAdsSimilarIds": [],
         *       //   "displayAdsTitle": "my_displayAdsTitle",
         *       //   "displayAdsValue": {},
         *       //   "energyEfficiencyClass": "my_energyEfficiencyClass",
         *       //   "excludedDestinations": [],
         *       //   "expirationDate": "my_expirationDate",
         *       //   "gender": "my_gender",
         *       //   "googleProductCategory": "my_googleProductCategory",
         *       //   "gtin": "my_gtin",
         *       //   "id": "my_id",
         *       //   "identifierExists": false,
         *       //   "imageLink": "my_imageLink",
         *       //   "includedDestinations": [],
         *       //   "installment": {},
         *       //   "isBundle": false,
         *       //   "itemGroupId": "my_itemGroupId",
         *       //   "kind": "my_kind",
         *       //   "link": "my_link",
         *       //   "linkTemplate": "my_linkTemplate",
         *       //   "loyaltyPoints": {},
         *       //   "material": "my_material",
         *       //   "maxEnergyEfficiencyClass": "my_maxEnergyEfficiencyClass",
         *       //   "maxHandlingTime": "my_maxHandlingTime",
         *       //   "minEnergyEfficiencyClass": "my_minEnergyEfficiencyClass",
         *       //   "minHandlingTime": "my_minHandlingTime",
         *       //   "mobileLink": "my_mobileLink",
         *       //   "mobileLinkTemplate": "my_mobileLinkTemplate",
         *       //   "mpn": "my_mpn",
         *       //   "multipack": "my_multipack",
         *       //   "offerId": "my_offerId",
         *       //   "pattern": "my_pattern",
         *       //   "pickupMethod": "my_pickupMethod",
         *       //   "pickupSla": "my_pickupSla",
         *       //   "price": {},
         *       //   "productDetails": [],
         *       //   "productHighlights": [],
         *       //   "productTypes": [],
         *       //   "promotionIds": [],
         *       //   "salePrice": {},
         *       //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *       //   "sellOnGoogleQuantity": "my_sellOnGoogleQuantity",
         *       //   "shipping": [],
         *       //   "shippingHeight": {},
         *       //   "shippingLabel": "my_shippingLabel",
         *       //   "shippingLength": {},
         *       //   "shippingWeight": {},
         *       //   "shippingWidth": {},
         *       //   "shoppingAdsExcludedCountries": [],
         *       //   "sizeSystem": "my_sizeSystem",
         *       //   "sizeType": "my_sizeType",
         *       //   "sizes": [],
         *       //   "source": "my_source",
         *       //   "subscriptionCost": {},
         *       //   "targetCountry": "my_targetCountry",
         *       //   "taxCategory": "my_taxCategory",
         *       //   "taxes": [],
         *       //   "title": "my_title",
         *       //   "transitTimeLabel": "my_transitTimeLabel",
         *       //   "unitPricingBaseMeasure": {},
         *       //   "unitPricingMeasure": {}
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "additionalImageLinks": [],
         *   //   "additionalSizeType": "my_additionalSizeType",
         *   //   "adsGrouping": "my_adsGrouping",
         *   //   "adsLabels": [],
         *   //   "adsRedirect": "my_adsRedirect",
         *   //   "adult": false,
         *   //   "ageGroup": "my_ageGroup",
         *   //   "availability": "my_availability",
         *   //   "availabilityDate": "my_availabilityDate",
         *   //   "brand": "my_brand",
         *   //   "canonicalLink": "my_canonicalLink",
         *   //   "channel": "my_channel",
         *   //   "color": "my_color",
         *   //   "condition": "my_condition",
         *   //   "contentLanguage": "my_contentLanguage",
         *   //   "costOfGoodsSold": {},
         *   //   "customAttributes": [],
         *   //   "customLabel0": "my_customLabel0",
         *   //   "customLabel1": "my_customLabel1",
         *   //   "customLabel2": "my_customLabel2",
         *   //   "customLabel3": "my_customLabel3",
         *   //   "customLabel4": "my_customLabel4",
         *   //   "description": "my_description",
         *   //   "displayAdsId": "my_displayAdsId",
         *   //   "displayAdsLink": "my_displayAdsLink",
         *   //   "displayAdsSimilarIds": [],
         *   //   "displayAdsTitle": "my_displayAdsTitle",
         *   //   "displayAdsValue": {},
         *   //   "energyEfficiencyClass": "my_energyEfficiencyClass",
         *   //   "excludedDestinations": [],
         *   //   "expirationDate": "my_expirationDate",
         *   //   "gender": "my_gender",
         *   //   "googleProductCategory": "my_googleProductCategory",
         *   //   "gtin": "my_gtin",
         *   //   "id": "my_id",
         *   //   "identifierExists": false,
         *   //   "imageLink": "my_imageLink",
         *   //   "includedDestinations": [],
         *   //   "installment": {},
         *   //   "isBundle": false,
         *   //   "itemGroupId": "my_itemGroupId",
         *   //   "kind": "my_kind",
         *   //   "link": "my_link",
         *   //   "linkTemplate": "my_linkTemplate",
         *   //   "loyaltyPoints": {},
         *   //   "material": "my_material",
         *   //   "maxEnergyEfficiencyClass": "my_maxEnergyEfficiencyClass",
         *   //   "maxHandlingTime": "my_maxHandlingTime",
         *   //   "minEnergyEfficiencyClass": "my_minEnergyEfficiencyClass",
         *   //   "minHandlingTime": "my_minHandlingTime",
         *   //   "mobileLink": "my_mobileLink",
         *   //   "mobileLinkTemplate": "my_mobileLinkTemplate",
         *   //   "mpn": "my_mpn",
         *   //   "multipack": "my_multipack",
         *   //   "offerId": "my_offerId",
         *   //   "pattern": "my_pattern",
         *   //   "pickupMethod": "my_pickupMethod",
         *   //   "pickupSla": "my_pickupSla",
         *   //   "price": {},
         *   //   "productDetails": [],
         *   //   "productHighlights": [],
         *   //   "productTypes": [],
         *   //   "promotionIds": [],
         *   //   "salePrice": {},
         *   //   "salePriceEffectiveDate": "my_salePriceEffectiveDate",
         *   //   "sellOnGoogleQuantity": "my_sellOnGoogleQuantity",
         *   //   "shipping": [],
         *   //   "shippingHeight": {},
         *   //   "shippingLabel": "my_shippingLabel",
         *   //   "shippingLength": {},
         *   //   "shippingWeight": {},
         *   //   "shippingWidth": {},
         *   //   "shoppingAdsExcludedCountries": [],
         *   //   "sizeSystem": "my_sizeSystem",
         *   //   "sizeType": "my_sizeType",
         *   //   "sizes": [],
         *   //   "source": "my_source",
         *   //   "subscriptionCost": {},
         *   //   "targetCountry": "my_targetCountry",
         *   //   "taxCategory": "my_taxCategory",
         *   //   "taxes": [],
         *   //   "title": "my_title",
         *   //   "transitTimeLabel": "my_transitTimeLabel",
         *   //   "unitPricingBaseMeasure": {},
         *   //   "unitPricingMeasure": {}
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Products$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Products$Update, options?: MethodOptions): GaxiosPromise<Schema$Product>;
        update(params: Params$Resource$Products$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Products$Update, options: MethodOptions | BodyResponseCallback<Schema$Product>, callback: BodyResponseCallback<Schema$Product>): void;
        update(params: Params$Resource$Products$Update, callback: BodyResponseCallback<Schema$Product>): void;
        update(callback: BodyResponseCallback<Schema$Product>): void;
    }
    export interface Params$Resource$Products$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$ProductsCustomBatchRequest;
    }
    export interface Params$Resource$Products$Delete extends StandardParameters {
        /**
         * The Content API Supplemental Feed ID.
         */
        feedId?: string;
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The REST ID of the product.
         */
        productId?: string;
    }
    export interface Params$Resource$Products$Get extends StandardParameters {
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The REST ID of the product.
         */
        productId?: string;
    }
    export interface Params$Resource$Products$Insert extends StandardParameters {
        /**
         * The Content API Supplemental Feed ID.
         */
        feedId?: string;
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Product;
    }
    export interface Params$Resource$Products$List extends StandardParameters {
        /**
         * The maximum number of products to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the account that contains the products. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Products$Update extends StandardParameters {
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The REST ID of the product for which to update.
         */
        productId?: string;
        /**
         * The comma-separated list of product attributes to be updated. Example: `"title,salePrice"`. Attributes specified in the update mask without a value specified in the body will be deleted from the product. Only top-level product attributes can be updated. If not defined, product attributes with set values will be updated and other attributes will stay unchanged.
         */
        updateMask?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Product;
    }
    export class Resource$Productstatuses {
        context: APIRequestContext;
        repricingreports: Resource$Productstatuses$Repricingreports;
        constructor(context: APIRequestContext);
        /**
         * Gets the statuses of multiple products in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.productstatuses.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Productstatuses$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Productstatuses$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$ProductstatusesCustomBatchResponse>;
        custombatch(params: Params$Resource$Productstatuses$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Productstatuses$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$ProductstatusesCustomBatchResponse>, callback: BodyResponseCallback<Schema$ProductstatusesCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Productstatuses$Custombatch, callback: BodyResponseCallback<Schema$ProductstatusesCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$ProductstatusesCustomBatchResponse>): void;
        /**
         * Gets the status of a product from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.productstatuses.get({
         *     // If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         *     destinations: 'placeholder-value',
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The REST ID of the product.
         *     productId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "creationDate": "my_creationDate",
         *   //   "destinationStatuses": [],
         *   //   "googleExpirationDate": "my_googleExpirationDate",
         *   //   "itemLevelIssues": [],
         *   //   "kind": "my_kind",
         *   //   "lastUpdateDate": "my_lastUpdateDate",
         *   //   "link": "my_link",
         *   //   "productId": "my_productId",
         *   //   "title": "my_title"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Productstatuses$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Productstatuses$Get, options?: MethodOptions): GaxiosPromise<Schema$ProductStatus>;
        get(params: Params$Resource$Productstatuses$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Productstatuses$Get, options: MethodOptions | BodyResponseCallback<Schema$ProductStatus>, callback: BodyResponseCallback<Schema$ProductStatus>): void;
        get(params: Params$Resource$Productstatuses$Get, callback: BodyResponseCallback<Schema$ProductStatus>): void;
        get(callback: BodyResponseCallback<Schema$ProductStatus>): void;
        /**
         * Lists the statuses of the products in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.productstatuses.list({
         *     // If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         *     destinations: 'placeholder-value',
         *     // The maximum number of product statuses to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the account that contains the products. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Productstatuses$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Productstatuses$List, options?: MethodOptions): GaxiosPromise<Schema$ProductstatusesListResponse>;
        list(params: Params$Resource$Productstatuses$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Productstatuses$List, options: MethodOptions | BodyResponseCallback<Schema$ProductstatusesListResponse>, callback: BodyResponseCallback<Schema$ProductstatusesListResponse>): void;
        list(params: Params$Resource$Productstatuses$List, callback: BodyResponseCallback<Schema$ProductstatusesListResponse>): void;
        list(callback: BodyResponseCallback<Schema$ProductstatusesListResponse>): void;
    }
    export interface Params$Resource$Productstatuses$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$ProductstatusesCustomBatchRequest;
    }
    export interface Params$Resource$Productstatuses$Get extends StandardParameters {
        /**
         * If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         */
        destinations?: string[];
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The REST ID of the product.
         */
        productId?: string;
    }
    export interface Params$Resource$Productstatuses$List extends StandardParameters {
        /**
         * If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.
         */
        destinations?: string[];
        /**
         * The maximum number of product statuses to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the account that contains the products. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export class Resource$Productstatuses$Repricingreports {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Lists the metrics report for a given Repricing product.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.productstatuses.repricingreports.list({
         *     // Gets Repricing reports on and before this date in the merchant's timezone. You can only retrieve data up to 7 days ago (default) or earlier. Format is YYYY-MM-DD.
         *     endDate: 'placeholder-value',
         *     // Required. Id of the merchant who owns the Repricing rule.
         *     merchantId: 'placeholder-value',
         *     // Maximum number of days of reports to return. There can be more than one rule report returned per day. For example, if 3 rule types got applied to the same product within a 24-hour period, then a page_size of 1 will return 3 rule reports. The page size defaults to 50 and values above 1000 are coerced to 1000. This service may return fewer days of reports than this value, for example, if the time between your start and end date is less than the page size.
         *     pageSize: 'placeholder-value',
         *     // Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         *     pageToken: 'placeholder-value',
         *     // Required. Id of the Repricing product. Also known as the [REST_ID](https://developers.google.com/shopping-content/reference/rest/v2.1/products#Product.FIELDS.id)
         *     productId: 'placeholder-value',
         *     // Id of the Repricing rule. If specified, only gets this rule's reports.
         *     ruleId: 'placeholder-value',
         *     // Gets Repricing reports on and after this date in the merchant's timezone, up to one year ago. Do not use a start date later than 7 days ago (default). Format is YYYY-MM-DD.
         *     startDate: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "repricingProductReports": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Productstatuses$Repricingreports$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Productstatuses$Repricingreports$List, options?: MethodOptions): GaxiosPromise<Schema$ListRepricingProductReportsResponse>;
        list(params: Params$Resource$Productstatuses$Repricingreports$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Productstatuses$Repricingreports$List, options: MethodOptions | BodyResponseCallback<Schema$ListRepricingProductReportsResponse>, callback: BodyResponseCallback<Schema$ListRepricingProductReportsResponse>): void;
        list(params: Params$Resource$Productstatuses$Repricingreports$List, callback: BodyResponseCallback<Schema$ListRepricingProductReportsResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListRepricingProductReportsResponse>): void;
    }
    export interface Params$Resource$Productstatuses$Repricingreports$List extends StandardParameters {
        /**
         * Gets Repricing reports on and before this date in the merchant's timezone. You can only retrieve data up to 7 days ago (default) or earlier. Format is YYYY-MM-DD.
         */
        endDate?: string;
        /**
         * Required. Id of the merchant who owns the Repricing rule.
         */
        merchantId?: string;
        /**
         * Maximum number of days of reports to return. There can be more than one rule report returned per day. For example, if 3 rule types got applied to the same product within a 24-hour period, then a page_size of 1 will return 3 rule reports. The page size defaults to 50 and values above 1000 are coerced to 1000. This service may return fewer days of reports than this value, for example, if the time between your start and end date is less than the page size.
         */
        pageSize?: number;
        /**
         * Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         */
        pageToken?: string;
        /**
         * Required. Id of the Repricing product. Also known as the [REST_ID](https://developers.google.com/shopping-content/reference/rest/v2.1/products#Product.FIELDS.id)
         */
        productId?: string;
        /**
         * Id of the Repricing rule. If specified, only gets this rule's reports.
         */
        ruleId?: string;
        /**
         * Gets Repricing reports on and after this date in the merchant's timezone, up to one year ago. Do not use a start date later than 7 days ago (default). Format is YYYY-MM-DD.
         */
        startDate?: string;
    }
    export class Resource$Pubsubnotificationsettings {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves a Merchant Center account's pubsub notification settings.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pubsubnotificationsettings.get({
         *     // The ID of the account for which to get pubsub notification settings.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cloudTopicName": "my_cloudTopicName",
         *   //   "kind": "my_kind",
         *   //   "registeredEvents": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Pubsubnotificationsettings$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Pubsubnotificationsettings$Get, options?: MethodOptions): GaxiosPromise<Schema$PubsubNotificationSettings>;
        get(params: Params$Resource$Pubsubnotificationsettings$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Pubsubnotificationsettings$Get, options: MethodOptions | BodyResponseCallback<Schema$PubsubNotificationSettings>, callback: BodyResponseCallback<Schema$PubsubNotificationSettings>): void;
        get(params: Params$Resource$Pubsubnotificationsettings$Get, callback: BodyResponseCallback<Schema$PubsubNotificationSettings>): void;
        get(callback: BodyResponseCallback<Schema$PubsubNotificationSettings>): void;
        /**
         * Register a Merchant Center account for pubsub notifications. Note that cloud topic name should not be provided as part of the request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.pubsubnotificationsettings.update({
         *     // The ID of the account.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "cloudTopicName": "my_cloudTopicName",
         *       //   "kind": "my_kind",
         *       //   "registeredEvents": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cloudTopicName": "my_cloudTopicName",
         *   //   "kind": "my_kind",
         *   //   "registeredEvents": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Pubsubnotificationsettings$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Pubsubnotificationsettings$Update, options?: MethodOptions): GaxiosPromise<Schema$PubsubNotificationSettings>;
        update(params: Params$Resource$Pubsubnotificationsettings$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Pubsubnotificationsettings$Update, options: MethodOptions | BodyResponseCallback<Schema$PubsubNotificationSettings>, callback: BodyResponseCallback<Schema$PubsubNotificationSettings>): void;
        update(params: Params$Resource$Pubsubnotificationsettings$Update, callback: BodyResponseCallback<Schema$PubsubNotificationSettings>): void;
        update(callback: BodyResponseCallback<Schema$PubsubNotificationSettings>): void;
    }
    export interface Params$Resource$Pubsubnotificationsettings$Get extends StandardParameters {
        /**
         * The ID of the account for which to get pubsub notification settings.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Pubsubnotificationsettings$Update extends StandardParameters {
        /**
         * The ID of the account.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$PubsubNotificationSettings;
    }
    export class Resource$Regionalinventory {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Updates regional inventory for multiple products or regions in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regionalinventory.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Regionalinventory$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Regionalinventory$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$RegionalinventoryCustomBatchResponse>;
        custombatch(params: Params$Resource$Regionalinventory$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Regionalinventory$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$RegionalinventoryCustomBatchResponse>, callback: BodyResponseCallback<Schema$RegionalinventoryCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Regionalinventory$Custombatch, callback: BodyResponseCallback<Schema$RegionalinventoryCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$RegionalinventoryCustomBatchResponse>): void;
        /**
         * Update the regional inventory of a product in your Merchant Center account. If a regional inventory with the same region ID already exists, this method updates that entry.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regionalinventory.insert({
         *     // The ID of the account that contains the product. This account cannot be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The REST ID of the product for which to update the regional inventory.
         *     productId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "availability": "my_availability",
         *       //   "customAttributes": [],
         *       //   "kind": "my_kind",
         *       //   "price": {},
         *       //   "regionId": "my_regionId",
         *       //   "salePrice": {},
         *       //   "salePriceEffectiveDate": "my_salePriceEffectiveDate"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "availability": "my_availability",
         *   //   "customAttributes": [],
         *   //   "kind": "my_kind",
         *   //   "price": {},
         *   //   "regionId": "my_regionId",
         *   //   "salePrice": {},
         *   //   "salePriceEffectiveDate": "my_salePriceEffectiveDate"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Regionalinventory$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Regionalinventory$Insert, options?: MethodOptions): GaxiosPromise<Schema$RegionalInventory>;
        insert(params: Params$Resource$Regionalinventory$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Regionalinventory$Insert, options: MethodOptions | BodyResponseCallback<Schema$RegionalInventory>, callback: BodyResponseCallback<Schema$RegionalInventory>): void;
        insert(params: Params$Resource$Regionalinventory$Insert, callback: BodyResponseCallback<Schema$RegionalInventory>): void;
        insert(callback: BodyResponseCallback<Schema$RegionalInventory>): void;
    }
    export interface Params$Resource$Regionalinventory$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$RegionalinventoryCustomBatchRequest;
    }
    export interface Params$Resource$Regionalinventory$Insert extends StandardParameters {
        /**
         * The ID of the account that contains the product. This account cannot be a multi-client account.
         */
        merchantId?: string;
        /**
         * The REST ID of the product for which to update the regional inventory.
         */
        productId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$RegionalInventory;
    }
    export class Resource$Regions {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Creates a region definition in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regions.create({
         *     // Required. The id of the merchant for which to create region definition.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the region to create.
         *     regionId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "displayName": "my_displayName",
         *       //   "geotargetArea": {},
         *       //   "merchantId": "my_merchantId",
         *       //   "postalCodeArea": {},
         *       //   "regionId": "my_regionId",
         *       //   "regionalInventoryEligible": false,
         *       //   "shippingEligible": false
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "displayName": "my_displayName",
         *   //   "geotargetArea": {},
         *   //   "merchantId": "my_merchantId",
         *   //   "postalCodeArea": {},
         *   //   "regionId": "my_regionId",
         *   //   "regionalInventoryEligible": false,
         *   //   "shippingEligible": false
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Regions$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Regions$Create, options?: MethodOptions): GaxiosPromise<Schema$Region>;
        create(params: Params$Resource$Regions$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Regions$Create, options: MethodOptions | BodyResponseCallback<Schema$Region>, callback: BodyResponseCallback<Schema$Region>): void;
        create(params: Params$Resource$Regions$Create, callback: BodyResponseCallback<Schema$Region>): void;
        create(callback: BodyResponseCallback<Schema$Region>): void;
        /**
         * Deletes a region definition from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regions.delete({
         *     // Required. The id of the merchant for which to delete region definition.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the region to delete.
         *     regionId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Regions$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Regions$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Regions$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Regions$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Regions$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves a region defined in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regions.get({
         *     // Required. The id of the merchant for which to retrieve region definition.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the region to retrieve.
         *     regionId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "displayName": "my_displayName",
         *   //   "geotargetArea": {},
         *   //   "merchantId": "my_merchantId",
         *   //   "postalCodeArea": {},
         *   //   "regionId": "my_regionId",
         *   //   "regionalInventoryEligible": false,
         *   //   "shippingEligible": false
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Regions$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Regions$Get, options?: MethodOptions): GaxiosPromise<Schema$Region>;
        get(params: Params$Resource$Regions$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Regions$Get, options: MethodOptions | BodyResponseCallback<Schema$Region>, callback: BodyResponseCallback<Schema$Region>): void;
        get(params: Params$Resource$Regions$Get, callback: BodyResponseCallback<Schema$Region>): void;
        get(callback: BodyResponseCallback<Schema$Region>): void;
        /**
         * Lists the regions in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regions.list({
         *     // Required. The id of the merchant for which to list region definitions.
         *     merchantId: 'placeholder-value',
         *     // The maximum number of regions to return. The service may return fewer than this value. If unspecified, at most 50 rules will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         *     pageSize: 'placeholder-value',
         *     // A page token, received from a previous `ListRegions` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListRegions` must match the call that provided the page token.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "regions": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Regions$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Regions$List, options?: MethodOptions): GaxiosPromise<Schema$ListRegionsResponse>;
        list(params: Params$Resource$Regions$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Regions$List, options: MethodOptions | BodyResponseCallback<Schema$ListRegionsResponse>, callback: BodyResponseCallback<Schema$ListRegionsResponse>): void;
        list(params: Params$Resource$Regions$List, callback: BodyResponseCallback<Schema$ListRegionsResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListRegionsResponse>): void;
        /**
         * Updates a region definition in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.regions.patch({
         *     // Required. The id of the merchant for which to update region definition.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the region to update.
         *     regionId: 'placeholder-value',
         *     // Optional. The comma-separated field mask indicating the fields to update. Example: `"displayName,postalCodeArea.regionCode"`.
         *     updateMask: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "displayName": "my_displayName",
         *       //   "geotargetArea": {},
         *       //   "merchantId": "my_merchantId",
         *       //   "postalCodeArea": {},
         *       //   "regionId": "my_regionId",
         *       //   "regionalInventoryEligible": false,
         *       //   "shippingEligible": false
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "displayName": "my_displayName",
         *   //   "geotargetArea": {},
         *   //   "merchantId": "my_merchantId",
         *   //   "postalCodeArea": {},
         *   //   "regionId": "my_regionId",
         *   //   "regionalInventoryEligible": false,
         *   //   "shippingEligible": false
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        patch(params: Params$Resource$Regions$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        patch(params?: Params$Resource$Regions$Patch, options?: MethodOptions): GaxiosPromise<Schema$Region>;
        patch(params: Params$Resource$Regions$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        patch(params: Params$Resource$Regions$Patch, options: MethodOptions | BodyResponseCallback<Schema$Region>, callback: BodyResponseCallback<Schema$Region>): void;
        patch(params: Params$Resource$Regions$Patch, callback: BodyResponseCallback<Schema$Region>): void;
        patch(callback: BodyResponseCallback<Schema$Region>): void;
    }
    export interface Params$Resource$Regions$Create extends StandardParameters {
        /**
         * Required. The id of the merchant for which to create region definition.
         */
        merchantId?: string;
        /**
         * Required. The id of the region to create.
         */
        regionId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Region;
    }
    export interface Params$Resource$Regions$Delete extends StandardParameters {
        /**
         * Required. The id of the merchant for which to delete region definition.
         */
        merchantId?: string;
        /**
         * Required. The id of the region to delete.
         */
        regionId?: string;
    }
    export interface Params$Resource$Regions$Get extends StandardParameters {
        /**
         * Required. The id of the merchant for which to retrieve region definition.
         */
        merchantId?: string;
        /**
         * Required. The id of the region to retrieve.
         */
        regionId?: string;
    }
    export interface Params$Resource$Regions$List extends StandardParameters {
        /**
         * Required. The id of the merchant for which to list region definitions.
         */
        merchantId?: string;
        /**
         * The maximum number of regions to return. The service may return fewer than this value. If unspecified, at most 50 rules will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         */
        pageSize?: number;
        /**
         * A page token, received from a previous `ListRegions` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListRegions` must match the call that provided the page token.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Regions$Patch extends StandardParameters {
        /**
         * Required. The id of the merchant for which to update region definition.
         */
        merchantId?: string;
        /**
         * Required. The id of the region to update.
         */
        regionId?: string;
        /**
         * Optional. The comma-separated field mask indicating the fields to update. Example: `"displayName,postalCodeArea.regionCode"`.
         */
        updateMask?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Region;
    }
    export class Resource$Reports {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves merchant performance mertrics matching the search query and optionally segmented by selected dimensions.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.reports.search({
         *     // Required. Id of the merchant making the call. Must be a standalone account or an MCA subaccount.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "pageSize": 0,
         *       //   "pageToken": "my_pageToken",
         *       //   "query": "my_query"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "results": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        search(params: Params$Resource$Reports$Search, options: StreamMethodOptions): GaxiosPromise<Readable>;
        search(params?: Params$Resource$Reports$Search, options?: MethodOptions): GaxiosPromise<Schema$SearchResponse>;
        search(params: Params$Resource$Reports$Search, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        search(params: Params$Resource$Reports$Search, options: MethodOptions | BodyResponseCallback<Schema$SearchResponse>, callback: BodyResponseCallback<Schema$SearchResponse>): void;
        search(params: Params$Resource$Reports$Search, callback: BodyResponseCallback<Schema$SearchResponse>): void;
        search(callback: BodyResponseCallback<Schema$SearchResponse>): void;
    }
    export interface Params$Resource$Reports$Search extends StandardParameters {
        /**
         * Required. Id of the merchant making the call. Must be a standalone account or an MCA subaccount.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$SearchRequest;
    }
    export class Resource$Repricingrules {
        context: APIRequestContext;
        repricingreports: Resource$Repricingrules$Repricingreports;
        constructor(context: APIRequestContext);
        /**
         * Creates a repricing rule for your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.repricingrules.create({
         *     // Required. The id of the merchant who owns the repricing rule.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the rule to create.
         *     ruleId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "cogsBasedRule": {},
         *       //   "countryCode": "my_countryCode",
         *       //   "effectiveTimePeriod": {},
         *       //   "eligibleOfferMatcher": {},
         *       //   "languageCode": "my_languageCode",
         *       //   "merchantId": "my_merchantId",
         *       //   "paused": false,
         *       //   "restriction": {},
         *       //   "ruleId": "my_ruleId",
         *       //   "statsBasedRule": {},
         *       //   "title": "my_title",
         *       //   "type": "my_type"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cogsBasedRule": {},
         *   //   "countryCode": "my_countryCode",
         *   //   "effectiveTimePeriod": {},
         *   //   "eligibleOfferMatcher": {},
         *   //   "languageCode": "my_languageCode",
         *   //   "merchantId": "my_merchantId",
         *   //   "paused": false,
         *   //   "restriction": {},
         *   //   "ruleId": "my_ruleId",
         *   //   "statsBasedRule": {},
         *   //   "title": "my_title",
         *   //   "type": "my_type"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Repricingrules$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Repricingrules$Create, options?: MethodOptions): GaxiosPromise<Schema$RepricingRule>;
        create(params: Params$Resource$Repricingrules$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Repricingrules$Create, options: MethodOptions | BodyResponseCallback<Schema$RepricingRule>, callback: BodyResponseCallback<Schema$RepricingRule>): void;
        create(params: Params$Resource$Repricingrules$Create, callback: BodyResponseCallback<Schema$RepricingRule>): void;
        create(callback: BodyResponseCallback<Schema$RepricingRule>): void;
        /**
         * Deletes a repricing rule in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.repricingrules.delete({
         *     // Required. The id of the merchant who owns the repricing rule.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the rule to Delete.
         *     ruleId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Repricingrules$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Repricingrules$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Repricingrules$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Repricingrules$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Repricingrules$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Retrieves a repricing rule from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.repricingrules.get({
         *     // Required. The id of the merchant who owns the repricing rule.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the rule to retrieve.
         *     ruleId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cogsBasedRule": {},
         *   //   "countryCode": "my_countryCode",
         *   //   "effectiveTimePeriod": {},
         *   //   "eligibleOfferMatcher": {},
         *   //   "languageCode": "my_languageCode",
         *   //   "merchantId": "my_merchantId",
         *   //   "paused": false,
         *   //   "restriction": {},
         *   //   "ruleId": "my_ruleId",
         *   //   "statsBasedRule": {},
         *   //   "title": "my_title",
         *   //   "type": "my_type"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Repricingrules$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Repricingrules$Get, options?: MethodOptions): GaxiosPromise<Schema$RepricingRule>;
        get(params: Params$Resource$Repricingrules$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Repricingrules$Get, options: MethodOptions | BodyResponseCallback<Schema$RepricingRule>, callback: BodyResponseCallback<Schema$RepricingRule>): void;
        get(params: Params$Resource$Repricingrules$Get, callback: BodyResponseCallback<Schema$RepricingRule>): void;
        get(callback: BodyResponseCallback<Schema$RepricingRule>): void;
        /**
         * Lists the repricing rules in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.repricingrules.list({
         *     // [CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (e.g. "US"), used as a filter on repricing rules.
         *     countryCode: 'placeholder-value',
         *     // The two-letter ISO 639-1 language code associated with the repricing rule, used as a filter.
         *     languageCode: 'placeholder-value',
         *     // Required. The id of the merchant who owns the repricing rule.
         *     merchantId: 'placeholder-value',
         *     // The maximum number of repricing rules to return. The service may return fewer than this value. If unspecified, at most 50 rules will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         *     pageSize: 'placeholder-value',
         *     // A page token, received from a previous `ListRepricingRules` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListRepricingRules` must match the call that provided the page token.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "repricingRules": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Repricingrules$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Repricingrules$List, options?: MethodOptions): GaxiosPromise<Schema$ListRepricingRulesResponse>;
        list(params: Params$Resource$Repricingrules$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Repricingrules$List, options: MethodOptions | BodyResponseCallback<Schema$ListRepricingRulesResponse>, callback: BodyResponseCallback<Schema$ListRepricingRulesResponse>): void;
        list(params: Params$Resource$Repricingrules$List, callback: BodyResponseCallback<Schema$ListRepricingRulesResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListRepricingRulesResponse>): void;
        /**
         * Updates a repricing rule in your Merchant Center account. All mutable fields will be overwritten in each update request. In each update, you must provide all required mutable fields, or an error will be thrown. If you do not provide an optional field in the update request, if that field currently exists, it will be deleted from the rule.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.repricingrules.patch({
         *     // Required. The id of the merchant who owns the repricing rule.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the rule to update.
         *     ruleId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "cogsBasedRule": {},
         *       //   "countryCode": "my_countryCode",
         *       //   "effectiveTimePeriod": {},
         *       //   "eligibleOfferMatcher": {},
         *       //   "languageCode": "my_languageCode",
         *       //   "merchantId": "my_merchantId",
         *       //   "paused": false,
         *       //   "restriction": {},
         *       //   "ruleId": "my_ruleId",
         *       //   "statsBasedRule": {},
         *       //   "title": "my_title",
         *       //   "type": "my_type"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "cogsBasedRule": {},
         *   //   "countryCode": "my_countryCode",
         *   //   "effectiveTimePeriod": {},
         *   //   "eligibleOfferMatcher": {},
         *   //   "languageCode": "my_languageCode",
         *   //   "merchantId": "my_merchantId",
         *   //   "paused": false,
         *   //   "restriction": {},
         *   //   "ruleId": "my_ruleId",
         *   //   "statsBasedRule": {},
         *   //   "title": "my_title",
         *   //   "type": "my_type"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        patch(params: Params$Resource$Repricingrules$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        patch(params?: Params$Resource$Repricingrules$Patch, options?: MethodOptions): GaxiosPromise<Schema$RepricingRule>;
        patch(params: Params$Resource$Repricingrules$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        patch(params: Params$Resource$Repricingrules$Patch, options: MethodOptions | BodyResponseCallback<Schema$RepricingRule>, callback: BodyResponseCallback<Schema$RepricingRule>): void;
        patch(params: Params$Resource$Repricingrules$Patch, callback: BodyResponseCallback<Schema$RepricingRule>): void;
        patch(callback: BodyResponseCallback<Schema$RepricingRule>): void;
    }
    export interface Params$Resource$Repricingrules$Create extends StandardParameters {
        /**
         * Required. The id of the merchant who owns the repricing rule.
         */
        merchantId?: string;
        /**
         * Required. The id of the rule to create.
         */
        ruleId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$RepricingRule;
    }
    export interface Params$Resource$Repricingrules$Delete extends StandardParameters {
        /**
         * Required. The id of the merchant who owns the repricing rule.
         */
        merchantId?: string;
        /**
         * Required. The id of the rule to Delete.
         */
        ruleId?: string;
    }
    export interface Params$Resource$Repricingrules$Get extends StandardParameters {
        /**
         * Required. The id of the merchant who owns the repricing rule.
         */
        merchantId?: string;
        /**
         * Required. The id of the rule to retrieve.
         */
        ruleId?: string;
    }
    export interface Params$Resource$Repricingrules$List extends StandardParameters {
        /**
         * [CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (e.g. "US"), used as a filter on repricing rules.
         */
        countryCode?: string;
        /**
         * The two-letter ISO 639-1 language code associated with the repricing rule, used as a filter.
         */
        languageCode?: string;
        /**
         * Required. The id of the merchant who owns the repricing rule.
         */
        merchantId?: string;
        /**
         * The maximum number of repricing rules to return. The service may return fewer than this value. If unspecified, at most 50 rules will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
         */
        pageSize?: number;
        /**
         * A page token, received from a previous `ListRepricingRules` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListRepricingRules` must match the call that provided the page token.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Repricingrules$Patch extends StandardParameters {
        /**
         * Required. The id of the merchant who owns the repricing rule.
         */
        merchantId?: string;
        /**
         * Required. The id of the rule to update.
         */
        ruleId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$RepricingRule;
    }
    export class Resource$Repricingrules$Repricingreports {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Lists the metrics report for a given Repricing rule.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.repricingrules.repricingreports.list({
         *     // Gets Repricing reports on and before this date in the merchant's timezone. You can only retrieve data up to 7 days ago (default) or earlier. Format: YYYY-MM-DD.
         *     endDate: 'placeholder-value',
         *     // Required. Id of the merchant who owns the Repricing rule.
         *     merchantId: 'placeholder-value',
         *     // Maximum number of daily reports to return. Each report includes data from a single 24-hour period. The page size defaults to 50 and values above 1000 are coerced to 1000. This service may return fewer days than this value, for example, if the time between your start and end date is less than page size.
         *     pageSize: 'placeholder-value',
         *     // Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         *     pageToken: 'placeholder-value',
         *     // Required. Id of the Repricing rule.
         *     ruleId: 'placeholder-value',
         *     // Gets Repricing reports on and after this date in the merchant's timezone, up to one year ago. Do not use a start date later than 7 days ago (default). Format: YYYY-MM-DD.
         *     startDate: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "repricingRuleReports": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Repricingrules$Repricingreports$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Repricingrules$Repricingreports$List, options?: MethodOptions): GaxiosPromise<Schema$ListRepricingRuleReportsResponse>;
        list(params: Params$Resource$Repricingrules$Repricingreports$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Repricingrules$Repricingreports$List, options: MethodOptions | BodyResponseCallback<Schema$ListRepricingRuleReportsResponse>, callback: BodyResponseCallback<Schema$ListRepricingRuleReportsResponse>): void;
        list(params: Params$Resource$Repricingrules$Repricingreports$List, callback: BodyResponseCallback<Schema$ListRepricingRuleReportsResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListRepricingRuleReportsResponse>): void;
    }
    export interface Params$Resource$Repricingrules$Repricingreports$List extends StandardParameters {
        /**
         * Gets Repricing reports on and before this date in the merchant's timezone. You can only retrieve data up to 7 days ago (default) or earlier. Format: YYYY-MM-DD.
         */
        endDate?: string;
        /**
         * Required. Id of the merchant who owns the Repricing rule.
         */
        merchantId?: string;
        /**
         * Maximum number of daily reports to return. Each report includes data from a single 24-hour period. The page size defaults to 50 and values above 1000 are coerced to 1000. This service may return fewer days than this value, for example, if the time between your start and end date is less than page size.
         */
        pageSize?: number;
        /**
         * Token (if provided) to retrieve the subsequent page. All other parameters must match the original call that provided the page token.
         */
        pageToken?: string;
        /**
         * Required. Id of the Repricing rule.
         */
        ruleId?: string;
        /**
         * Gets Repricing reports on and after this date in the merchant's timezone, up to one year ago. Do not use a start date later than 7 days ago (default). Format: YYYY-MM-DD.
         */
        startDate?: string;
    }
    export class Resource$Returnaddress {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Batches multiple return address related calls in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnaddress.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Returnaddress$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Returnaddress$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$ReturnaddressCustomBatchResponse>;
        custombatch(params: Params$Resource$Returnaddress$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Returnaddress$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$ReturnaddressCustomBatchResponse>, callback: BodyResponseCallback<Schema$ReturnaddressCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Returnaddress$Custombatch, callback: BodyResponseCallback<Schema$ReturnaddressCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$ReturnaddressCustomBatchResponse>): void;
        /**
         * Deletes a return address for the given Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnaddress.delete({
         *     // The Merchant Center account from which to delete the given return address.
         *     merchantId: 'placeholder-value',
         *     // Return address ID generated by Google.
         *     returnAddressId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Returnaddress$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Returnaddress$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Returnaddress$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Returnaddress$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Returnaddress$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Gets a return address of the Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnaddress.get({
         *     // The Merchant Center account to get a return address for.
         *     merchantId: 'placeholder-value',
         *     // Return address ID generated by Google.
         *     returnAddressId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "address": {},
         *   //   "country": "my_country",
         *   //   "kind": "my_kind",
         *   //   "label": "my_label",
         *   //   "phoneNumber": "my_phoneNumber",
         *   //   "returnAddressId": "my_returnAddressId"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Returnaddress$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Returnaddress$Get, options?: MethodOptions): GaxiosPromise<Schema$ReturnAddress>;
        get(params: Params$Resource$Returnaddress$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Returnaddress$Get, options: MethodOptions | BodyResponseCallback<Schema$ReturnAddress>, callback: BodyResponseCallback<Schema$ReturnAddress>): void;
        get(params: Params$Resource$Returnaddress$Get, callback: BodyResponseCallback<Schema$ReturnAddress>): void;
        get(callback: BodyResponseCallback<Schema$ReturnAddress>): void;
        /**
         * Inserts a return address for the Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnaddress.insert({
         *     // The Merchant Center account to insert a return address for.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "address": {},
         *       //   "country": "my_country",
         *       //   "kind": "my_kind",
         *       //   "label": "my_label",
         *       //   "phoneNumber": "my_phoneNumber",
         *       //   "returnAddressId": "my_returnAddressId"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "address": {},
         *   //   "country": "my_country",
         *   //   "kind": "my_kind",
         *   //   "label": "my_label",
         *   //   "phoneNumber": "my_phoneNumber",
         *   //   "returnAddressId": "my_returnAddressId"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Returnaddress$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Returnaddress$Insert, options?: MethodOptions): GaxiosPromise<Schema$ReturnAddress>;
        insert(params: Params$Resource$Returnaddress$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Returnaddress$Insert, options: MethodOptions | BodyResponseCallback<Schema$ReturnAddress>, callback: BodyResponseCallback<Schema$ReturnAddress>): void;
        insert(params: Params$Resource$Returnaddress$Insert, callback: BodyResponseCallback<Schema$ReturnAddress>): void;
        insert(callback: BodyResponseCallback<Schema$ReturnAddress>): void;
        /**
         * Lists the return addresses of the Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnaddress.list({
         *     // List only return addresses applicable to the given country of sale. When omitted, all return addresses are listed.
         *     country: 'placeholder-value',
         *     // The maximum number of addresses in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The Merchant Center account to list return addresses for.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Returnaddress$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Returnaddress$List, options?: MethodOptions): GaxiosPromise<Schema$ReturnaddressListResponse>;
        list(params: Params$Resource$Returnaddress$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Returnaddress$List, options: MethodOptions | BodyResponseCallback<Schema$ReturnaddressListResponse>, callback: BodyResponseCallback<Schema$ReturnaddressListResponse>): void;
        list(params: Params$Resource$Returnaddress$List, callback: BodyResponseCallback<Schema$ReturnaddressListResponse>): void;
        list(callback: BodyResponseCallback<Schema$ReturnaddressListResponse>): void;
    }
    export interface Params$Resource$Returnaddress$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnaddressCustomBatchRequest;
    }
    export interface Params$Resource$Returnaddress$Delete extends StandardParameters {
        /**
         * The Merchant Center account from which to delete the given return address.
         */
        merchantId?: string;
        /**
         * Return address ID generated by Google.
         */
        returnAddressId?: string;
    }
    export interface Params$Resource$Returnaddress$Get extends StandardParameters {
        /**
         * The Merchant Center account to get a return address for.
         */
        merchantId?: string;
        /**
         * Return address ID generated by Google.
         */
        returnAddressId?: string;
    }
    export interface Params$Resource$Returnaddress$Insert extends StandardParameters {
        /**
         * The Merchant Center account to insert a return address for.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnAddress;
    }
    export interface Params$Resource$Returnaddress$List extends StandardParameters {
        /**
         * List only return addresses applicable to the given country of sale. When omitted, all return addresses are listed.
         */
        country?: string;
        /**
         * The maximum number of addresses in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The Merchant Center account to list return addresses for.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export class Resource$Returnpolicy {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Batches multiple return policy related calls in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicy.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Returnpolicy$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Returnpolicy$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$ReturnpolicyCustomBatchResponse>;
        custombatch(params: Params$Resource$Returnpolicy$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Returnpolicy$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$ReturnpolicyCustomBatchResponse>, callback: BodyResponseCallback<Schema$ReturnpolicyCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Returnpolicy$Custombatch, callback: BodyResponseCallback<Schema$ReturnpolicyCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$ReturnpolicyCustomBatchResponse>): void;
        /**
         * Deletes a return policy for the given Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicy.delete({
         *     // The Merchant Center account from which to delete the given return policy.
         *     merchantId: 'placeholder-value',
         *     // Return policy ID generated by Google.
         *     returnPolicyId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Returnpolicy$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Returnpolicy$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Returnpolicy$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Returnpolicy$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Returnpolicy$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Gets a return policy of the Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicy.get({
         *     // The Merchant Center account to get a return policy for.
         *     merchantId: 'placeholder-value',
         *     // Return policy ID generated by Google.
         *     returnPolicyId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "country": "my_country",
         *   //   "kind": "my_kind",
         *   //   "label": "my_label",
         *   //   "name": "my_name",
         *   //   "nonFreeReturnReasons": [],
         *   //   "policy": {},
         *   //   "returnPolicyId": "my_returnPolicyId",
         *   //   "returnShippingFee": {},
         *   //   "seasonalOverrides": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Returnpolicy$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Returnpolicy$Get, options?: MethodOptions): GaxiosPromise<Schema$ReturnPolicy>;
        get(params: Params$Resource$Returnpolicy$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Returnpolicy$Get, options: MethodOptions | BodyResponseCallback<Schema$ReturnPolicy>, callback: BodyResponseCallback<Schema$ReturnPolicy>): void;
        get(params: Params$Resource$Returnpolicy$Get, callback: BodyResponseCallback<Schema$ReturnPolicy>): void;
        get(callback: BodyResponseCallback<Schema$ReturnPolicy>): void;
        /**
         * Inserts a return policy for the Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicy.insert({
         *     // The Merchant Center account to insert a return policy for.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "country": "my_country",
         *       //   "kind": "my_kind",
         *       //   "label": "my_label",
         *       //   "name": "my_name",
         *       //   "nonFreeReturnReasons": [],
         *       //   "policy": {},
         *       //   "returnPolicyId": "my_returnPolicyId",
         *       //   "returnShippingFee": {},
         *       //   "seasonalOverrides": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "country": "my_country",
         *   //   "kind": "my_kind",
         *   //   "label": "my_label",
         *   //   "name": "my_name",
         *   //   "nonFreeReturnReasons": [],
         *   //   "policy": {},
         *   //   "returnPolicyId": "my_returnPolicyId",
         *   //   "returnShippingFee": {},
         *   //   "seasonalOverrides": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        insert(params: Params$Resource$Returnpolicy$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
        insert(params?: Params$Resource$Returnpolicy$Insert, options?: MethodOptions): GaxiosPromise<Schema$ReturnPolicy>;
        insert(params: Params$Resource$Returnpolicy$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        insert(params: Params$Resource$Returnpolicy$Insert, options: MethodOptions | BodyResponseCallback<Schema$ReturnPolicy>, callback: BodyResponseCallback<Schema$ReturnPolicy>): void;
        insert(params: Params$Resource$Returnpolicy$Insert, callback: BodyResponseCallback<Schema$ReturnPolicy>): void;
        insert(callback: BodyResponseCallback<Schema$ReturnPolicy>): void;
        /**
         * Lists the return policies of the Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicy.list({
         *     // The Merchant Center account to list return policies for.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Returnpolicy$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Returnpolicy$List, options?: MethodOptions): GaxiosPromise<Schema$ReturnpolicyListResponse>;
        list(params: Params$Resource$Returnpolicy$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Returnpolicy$List, options: MethodOptions | BodyResponseCallback<Schema$ReturnpolicyListResponse>, callback: BodyResponseCallback<Schema$ReturnpolicyListResponse>): void;
        list(params: Params$Resource$Returnpolicy$List, callback: BodyResponseCallback<Schema$ReturnpolicyListResponse>): void;
        list(callback: BodyResponseCallback<Schema$ReturnpolicyListResponse>): void;
    }
    export interface Params$Resource$Returnpolicy$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnpolicyCustomBatchRequest;
    }
    export interface Params$Resource$Returnpolicy$Delete extends StandardParameters {
        /**
         * The Merchant Center account from which to delete the given return policy.
         */
        merchantId?: string;
        /**
         * Return policy ID generated by Google.
         */
        returnPolicyId?: string;
    }
    export interface Params$Resource$Returnpolicy$Get extends StandardParameters {
        /**
         * The Merchant Center account to get a return policy for.
         */
        merchantId?: string;
        /**
         * Return policy ID generated by Google.
         */
        returnPolicyId?: string;
    }
    export interface Params$Resource$Returnpolicy$Insert extends StandardParameters {
        /**
         * The Merchant Center account to insert a return policy for.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnPolicy;
    }
    export interface Params$Resource$Returnpolicy$List extends StandardParameters {
        /**
         * The Merchant Center account to list return policies for.
         */
        merchantId?: string;
    }
    export class Resource$Returnpolicyonline {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Creates a new return policy.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicyonline.create({
         *     // Required. The id of the merchant for which to retrieve the return policy online object.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "countries": [],
         *       //   "itemConditions": [],
         *       //   "label": "my_label",
         *       //   "name": "my_name",
         *       //   "policy": {},
         *       //   "restockingFee": {},
         *       //   "returnMethods": [],
         *       //   "returnPolicyId": "my_returnPolicyId",
         *       //   "returnPolicyUri": "my_returnPolicyUri",
         *       //   "returnReasonCategoryInfo": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "countries": [],
         *   //   "itemConditions": [],
         *   //   "label": "my_label",
         *   //   "name": "my_name",
         *   //   "policy": {},
         *   //   "restockingFee": {},
         *   //   "returnMethods": [],
         *   //   "returnPolicyId": "my_returnPolicyId",
         *   //   "returnPolicyUri": "my_returnPolicyUri",
         *   //   "returnReasonCategoryInfo": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Returnpolicyonline$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Returnpolicyonline$Create, options?: MethodOptions): GaxiosPromise<Schema$ReturnPolicyOnline>;
        create(params: Params$Resource$Returnpolicyonline$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Returnpolicyonline$Create, options: MethodOptions | BodyResponseCallback<Schema$ReturnPolicyOnline>, callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        create(params: Params$Resource$Returnpolicyonline$Create, callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        create(callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        /**
         * Deletes an existing return policy.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicyonline.delete({
         *     // Required. The id of the merchant for which to retrieve the return policy online object.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the return policy to delete.
         *     returnPolicyId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Returnpolicyonline$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Returnpolicyonline$Delete, options?: MethodOptions): GaxiosPromise<void>;
        delete(params: Params$Resource$Returnpolicyonline$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Returnpolicyonline$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
        delete(params: Params$Resource$Returnpolicyonline$Delete, callback: BodyResponseCallback<void>): void;
        delete(callback: BodyResponseCallback<void>): void;
        /**
         * Gets an existing return policy.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicyonline.get({
         *     // Required. The id of the merchant for which to retrieve the return policy online object.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the return policy to retrieve.
         *     returnPolicyId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "countries": [],
         *   //   "itemConditions": [],
         *   //   "label": "my_label",
         *   //   "name": "my_name",
         *   //   "policy": {},
         *   //   "restockingFee": {},
         *   //   "returnMethods": [],
         *   //   "returnPolicyId": "my_returnPolicyId",
         *   //   "returnPolicyUri": "my_returnPolicyUri",
         *   //   "returnReasonCategoryInfo": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Returnpolicyonline$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Returnpolicyonline$Get, options?: MethodOptions): GaxiosPromise<Schema$ReturnPolicyOnline>;
        get(params: Params$Resource$Returnpolicyonline$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Returnpolicyonline$Get, options: MethodOptions | BodyResponseCallback<Schema$ReturnPolicyOnline>, callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        get(params: Params$Resource$Returnpolicyonline$Get, callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        get(callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        /**
         * Lists all existing return policies.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicyonline.list({
         *     // Required. The id of the merchant for which to retrieve the return policy online object.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "returnPolicies": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Returnpolicyonline$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Returnpolicyonline$List, options?: MethodOptions): GaxiosPromise<Schema$ListReturnPolicyOnlineResponse>;
        list(params: Params$Resource$Returnpolicyonline$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Returnpolicyonline$List, options: MethodOptions | BodyResponseCallback<Schema$ListReturnPolicyOnlineResponse>, callback: BodyResponseCallback<Schema$ListReturnPolicyOnlineResponse>): void;
        list(params: Params$Resource$Returnpolicyonline$List, callback: BodyResponseCallback<Schema$ListReturnPolicyOnlineResponse>): void;
        list(callback: BodyResponseCallback<Schema$ListReturnPolicyOnlineResponse>): void;
        /**
         * Updates an existing return policy.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.returnpolicyonline.patch({
         *     // Required. The id of the merchant for which to retrieve the return policy online object.
         *     merchantId: 'placeholder-value',
         *     // Required. The id of the return policy to update.
         *     returnPolicyId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "countries": [],
         *       //   "itemConditions": [],
         *       //   "label": "my_label",
         *       //   "name": "my_name",
         *       //   "policy": {},
         *       //   "restockingFee": {},
         *       //   "returnMethods": [],
         *       //   "returnPolicyId": "my_returnPolicyId",
         *       //   "returnPolicyUri": "my_returnPolicyUri",
         *       //   "returnReasonCategoryInfo": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "countries": [],
         *   //   "itemConditions": [],
         *   //   "label": "my_label",
         *   //   "name": "my_name",
         *   //   "policy": {},
         *   //   "restockingFee": {},
         *   //   "returnMethods": [],
         *   //   "returnPolicyId": "my_returnPolicyId",
         *   //   "returnPolicyUri": "my_returnPolicyUri",
         *   //   "returnReasonCategoryInfo": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        patch(params: Params$Resource$Returnpolicyonline$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        patch(params?: Params$Resource$Returnpolicyonline$Patch, options?: MethodOptions): GaxiosPromise<Schema$ReturnPolicyOnline>;
        patch(params: Params$Resource$Returnpolicyonline$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        patch(params: Params$Resource$Returnpolicyonline$Patch, options: MethodOptions | BodyResponseCallback<Schema$ReturnPolicyOnline>, callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        patch(params: Params$Resource$Returnpolicyonline$Patch, callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
        patch(callback: BodyResponseCallback<Schema$ReturnPolicyOnline>): void;
    }
    export interface Params$Resource$Returnpolicyonline$Create extends StandardParameters {
        /**
         * Required. The id of the merchant for which to retrieve the return policy online object.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnPolicyOnline;
    }
    export interface Params$Resource$Returnpolicyonline$Delete extends StandardParameters {
        /**
         * Required. The id of the merchant for which to retrieve the return policy online object.
         */
        merchantId?: string;
        /**
         * Required. The id of the return policy to delete.
         */
        returnPolicyId?: string;
    }
    export interface Params$Resource$Returnpolicyonline$Get extends StandardParameters {
        /**
         * Required. The id of the merchant for which to retrieve the return policy online object.
         */
        merchantId?: string;
        /**
         * Required. The id of the return policy to retrieve.
         */
        returnPolicyId?: string;
    }
    export interface Params$Resource$Returnpolicyonline$List extends StandardParameters {
        /**
         * Required. The id of the merchant for which to retrieve the return policy online object.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Returnpolicyonline$Patch extends StandardParameters {
        /**
         * Required. The id of the merchant for which to retrieve the return policy online object.
         */
        merchantId?: string;
        /**
         * Required. The id of the return policy to update.
         */
        returnPolicyId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ReturnPolicyOnline;
    }
    export class Resource$Settlementreports {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves a settlement report from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.settlementreports.get({
         *     // The Merchant Center account of the settlement report.
         *     merchantId: 'placeholder-value',
         *     // The Google-provided ID of the settlement.
         *     settlementId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "endDate": "my_endDate",
         *   //   "kind": "my_kind",
         *   //   "previousBalance": {},
         *   //   "settlementId": "my_settlementId",
         *   //   "startDate": "my_startDate",
         *   //   "transferAmount": {},
         *   //   "transferDate": "my_transferDate",
         *   //   "transferIds": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Settlementreports$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Settlementreports$Get, options?: MethodOptions): GaxiosPromise<Schema$SettlementReport>;
        get(params: Params$Resource$Settlementreports$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Settlementreports$Get, options: MethodOptions | BodyResponseCallback<Schema$SettlementReport>, callback: BodyResponseCallback<Schema$SettlementReport>): void;
        get(params: Params$Resource$Settlementreports$Get, callback: BodyResponseCallback<Schema$SettlementReport>): void;
        get(callback: BodyResponseCallback<Schema$SettlementReport>): void;
        /**
         * Retrieves a list of settlement reports from your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.settlementreports.list({
         *     // The maximum number of settlements to return in the response, used for paging. The default value is 200 returns per page, and the maximum allowed value is 5000 returns per page.
         *     maxResults: 'placeholder-value',
         *     // The Merchant Center account to list settlements for.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *     // Obtains settlements which have transactions before this date (inclusively), in ISO 8601 format.
         *     transferEndDate: 'placeholder-value',
         *     // Obtains settlements which have transactions after this date (inclusively), in ISO 8601 format.
         *     transferStartDate: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Settlementreports$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Settlementreports$List, options?: MethodOptions): GaxiosPromise<Schema$SettlementreportsListResponse>;
        list(params: Params$Resource$Settlementreports$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Settlementreports$List, options: MethodOptions | BodyResponseCallback<Schema$SettlementreportsListResponse>, callback: BodyResponseCallback<Schema$SettlementreportsListResponse>): void;
        list(params: Params$Resource$Settlementreports$List, callback: BodyResponseCallback<Schema$SettlementreportsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$SettlementreportsListResponse>): void;
    }
    export interface Params$Resource$Settlementreports$Get extends StandardParameters {
        /**
         * The Merchant Center account of the settlement report.
         */
        merchantId?: string;
        /**
         * The Google-provided ID of the settlement.
         */
        settlementId?: string;
    }
    export interface Params$Resource$Settlementreports$List extends StandardParameters {
        /**
         * The maximum number of settlements to return in the response, used for paging. The default value is 200 returns per page, and the maximum allowed value is 5000 returns per page.
         */
        maxResults?: number;
        /**
         * The Merchant Center account to list settlements for.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
        /**
         * Obtains settlements which have transactions before this date (inclusively), in ISO 8601 format.
         */
        transferEndDate?: string;
        /**
         * Obtains settlements which have transactions after this date (inclusively), in ISO 8601 format.
         */
        transferStartDate?: string;
    }
    export class Resource$Settlementtransactions {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves a list of transactions for the settlement.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.settlementtransactions.list({
         *     // The maximum number of transactions to return in the response, used for paging. The default value is 200 transactions per page, and the maximum allowed value is 5000 transactions per page.
         *     maxResults: 'placeholder-value',
         *     // The Merchant Center account to list transactions for.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *     // The Google-provided ID of the settlement.
         *     settlementId: 'placeholder-value',
         *     // The list of transactions to return. If not set, all transactions will be returned.
         *     transactionIds: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Settlementtransactions$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Settlementtransactions$List, options?: MethodOptions): GaxiosPromise<Schema$SettlementtransactionsListResponse>;
        list(params: Params$Resource$Settlementtransactions$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Settlementtransactions$List, options: MethodOptions | BodyResponseCallback<Schema$SettlementtransactionsListResponse>, callback: BodyResponseCallback<Schema$SettlementtransactionsListResponse>): void;
        list(params: Params$Resource$Settlementtransactions$List, callback: BodyResponseCallback<Schema$SettlementtransactionsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$SettlementtransactionsListResponse>): void;
    }
    export interface Params$Resource$Settlementtransactions$List extends StandardParameters {
        /**
         * The maximum number of transactions to return in the response, used for paging. The default value is 200 transactions per page, and the maximum allowed value is 5000 transactions per page.
         */
        maxResults?: number;
        /**
         * The Merchant Center account to list transactions for.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
        /**
         * The Google-provided ID of the settlement.
         */
        settlementId?: string;
        /**
         * The list of transactions to return. If not set, all transactions will be returned.
         */
        transactionIds?: string[];
    }
    export class Resource$Shippingsettings {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Retrieves and updates the shipping settings of multiple accounts in a single request.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.custombatch({
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "entries": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "entries": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        custombatch(params: Params$Resource$Shippingsettings$Custombatch, options: StreamMethodOptions): GaxiosPromise<Readable>;
        custombatch(params?: Params$Resource$Shippingsettings$Custombatch, options?: MethodOptions): GaxiosPromise<Schema$ShippingsettingsCustomBatchResponse>;
        custombatch(params: Params$Resource$Shippingsettings$Custombatch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        custombatch(params: Params$Resource$Shippingsettings$Custombatch, options: MethodOptions | BodyResponseCallback<Schema$ShippingsettingsCustomBatchResponse>, callback: BodyResponseCallback<Schema$ShippingsettingsCustomBatchResponse>): void;
        custombatch(params: Params$Resource$Shippingsettings$Custombatch, callback: BodyResponseCallback<Schema$ShippingsettingsCustomBatchResponse>): void;
        custombatch(callback: BodyResponseCallback<Schema$ShippingsettingsCustomBatchResponse>): void;
        /**
         * Retrieves the shipping settings of the account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.get({
         *     // The ID of the account for which to get/update shipping settings.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "postalCodeGroups": [],
         *   //   "services": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Shippingsettings$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Shippingsettings$Get, options?: MethodOptions): GaxiosPromise<Schema$ShippingSettings>;
        get(params: Params$Resource$Shippingsettings$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Shippingsettings$Get, options: MethodOptions | BodyResponseCallback<Schema$ShippingSettings>, callback: BodyResponseCallback<Schema$ShippingSettings>): void;
        get(params: Params$Resource$Shippingsettings$Get, callback: BodyResponseCallback<Schema$ShippingSettings>): void;
        get(callback: BodyResponseCallback<Schema$ShippingSettings>): void;
        /**
         * Retrieves supported carriers and carrier services for an account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.getsupportedcarriers({
         *     // The ID of the account for which to retrieve the supported carriers.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "carriers": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        getsupportedcarriers(params: Params$Resource$Shippingsettings$Getsupportedcarriers, options: StreamMethodOptions): GaxiosPromise<Readable>;
        getsupportedcarriers(params?: Params$Resource$Shippingsettings$Getsupportedcarriers, options?: MethodOptions): GaxiosPromise<Schema$ShippingsettingsGetSupportedCarriersResponse>;
        getsupportedcarriers(params: Params$Resource$Shippingsettings$Getsupportedcarriers, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        getsupportedcarriers(params: Params$Resource$Shippingsettings$Getsupportedcarriers, options: MethodOptions | BodyResponseCallback<Schema$ShippingsettingsGetSupportedCarriersResponse>, callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedCarriersResponse>): void;
        getsupportedcarriers(params: Params$Resource$Shippingsettings$Getsupportedcarriers, callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedCarriersResponse>): void;
        getsupportedcarriers(callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedCarriersResponse>): void;
        /**
         * Retrieves supported holidays for an account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.getsupportedholidays({
         *     // The ID of the account for which to retrieve the supported holidays.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "holidays": [],
         *   //   "kind": "my_kind"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        getsupportedholidays(params: Params$Resource$Shippingsettings$Getsupportedholidays, options: StreamMethodOptions): GaxiosPromise<Readable>;
        getsupportedholidays(params?: Params$Resource$Shippingsettings$Getsupportedholidays, options?: MethodOptions): GaxiosPromise<Schema$ShippingsettingsGetSupportedHolidaysResponse>;
        getsupportedholidays(params: Params$Resource$Shippingsettings$Getsupportedholidays, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        getsupportedholidays(params: Params$Resource$Shippingsettings$Getsupportedholidays, options: MethodOptions | BodyResponseCallback<Schema$ShippingsettingsGetSupportedHolidaysResponse>, callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedHolidaysResponse>): void;
        getsupportedholidays(params: Params$Resource$Shippingsettings$Getsupportedholidays, callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedHolidaysResponse>): void;
        getsupportedholidays(callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedHolidaysResponse>): void;
        /**
         * Retrieves supported pickup services for an account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.getsupportedpickupservices({
         *     // The ID of the account for which to retrieve the supported pickup services.
         *     merchantId: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "pickupServices": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        getsupportedpickupservices(params: Params$Resource$Shippingsettings$Getsupportedpickupservices, options: StreamMethodOptions): GaxiosPromise<Readable>;
        getsupportedpickupservices(params?: Params$Resource$Shippingsettings$Getsupportedpickupservices, options?: MethodOptions): GaxiosPromise<Schema$ShippingsettingsGetSupportedPickupServicesResponse>;
        getsupportedpickupservices(params: Params$Resource$Shippingsettings$Getsupportedpickupservices, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        getsupportedpickupservices(params: Params$Resource$Shippingsettings$Getsupportedpickupservices, options: MethodOptions | BodyResponseCallback<Schema$ShippingsettingsGetSupportedPickupServicesResponse>, callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedPickupServicesResponse>): void;
        getsupportedpickupservices(params: Params$Resource$Shippingsettings$Getsupportedpickupservices, callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedPickupServicesResponse>): void;
        getsupportedpickupservices(callback: BodyResponseCallback<Schema$ShippingsettingsGetSupportedPickupServicesResponse>): void;
        /**
         * Lists the shipping settings of the sub-accounts in your Merchant Center account.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.list({
         *     // The maximum number of shipping settings to return in the response, used for paging.
         *     maxResults: 'placeholder-value',
         *     // The ID of the managing account. This must be a multi-client account.
         *     merchantId: 'placeholder-value',
         *     // The token returned by the previous request.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "kind": "my_kind",
         *   //   "nextPageToken": "my_nextPageToken",
         *   //   "resources": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Shippingsettings$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Shippingsettings$List, options?: MethodOptions): GaxiosPromise<Schema$ShippingsettingsListResponse>;
        list(params: Params$Resource$Shippingsettings$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Shippingsettings$List, options: MethodOptions | BodyResponseCallback<Schema$ShippingsettingsListResponse>, callback: BodyResponseCallback<Schema$ShippingsettingsListResponse>): void;
        list(params: Params$Resource$Shippingsettings$List, callback: BodyResponseCallback<Schema$ShippingsettingsListResponse>): void;
        list(callback: BodyResponseCallback<Schema$ShippingsettingsListResponse>): void;
        /**
         * Updates the shipping settings of the account. Any fields that are not provided are deleted from the resource.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/content.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const content = google.content('v2.1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: ['https://www.googleapis.com/auth/content'],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await content.shippingsettings.update({
         *     // The ID of the account for which to get/update shipping settings.
         *     accountId: 'placeholder-value',
         *     // 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.
         *     merchantId: 'placeholder-value',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "accountId": "my_accountId",
         *       //   "postalCodeGroups": [],
         *       //   "services": []
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "accountId": "my_accountId",
         *   //   "postalCodeGroups": [],
         *   //   "services": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        update(params: Params$Resource$Shippingsettings$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
        update(params?: Params$Resource$Shippingsettings$Update, options?: MethodOptions): GaxiosPromise<Schema$ShippingSettings>;
        update(params: Params$Resource$Shippingsettings$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        update(params: Params$Resource$Shippingsettings$Update, options: MethodOptions | BodyResponseCallback<Schema$ShippingSettings>, callback: BodyResponseCallback<Schema$ShippingSettings>): void;
        update(params: Params$Resource$Shippingsettings$Update, callback: BodyResponseCallback<Schema$ShippingSettings>): void;
        update(callback: BodyResponseCallback<Schema$ShippingSettings>): void;
    }
    export interface Params$Resource$Shippingsettings$Custombatch extends StandardParameters {
        /**
         * Request body metadata
         */
        requestBody?: Schema$ShippingsettingsCustomBatchRequest;
    }
    export interface Params$Resource$Shippingsettings$Get extends StandardParameters {
        /**
         * The ID of the account for which to get/update shipping settings.
         */
        accountId?: 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.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Shippingsettings$Getsupportedcarriers extends StandardParameters {
        /**
         * The ID of the account for which to retrieve the supported carriers.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Shippingsettings$Getsupportedholidays extends StandardParameters {
        /**
         * The ID of the account for which to retrieve the supported holidays.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Shippingsettings$Getsupportedpickupservices extends StandardParameters {
        /**
         * The ID of the account for which to retrieve the supported pickup services.
         */
        merchantId?: string;
    }
    export interface Params$Resource$Shippingsettings$List extends StandardParameters {
        /**
         * The maximum number of shipping settings to return in the response, used for paging.
         */
        maxResults?: number;
        /**
         * The ID of the managing account. This must be a multi-client account.
         */
        merchantId?: string;
        /**
         * The token returned by the previous request.
         */
        pageToken?: string;
    }
    export interface Params$Resource$Shippingsettings$Update extends StandardParameters {
        /**
         * The ID of the account for which to get/update shipping settings.
         */
        accountId?: 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.
         */
        merchantId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ShippingSettings;
    }
    export {};
}
