@googleapis/merchantapi 16.0.0 → 16.1.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [16.1.0](https://github.com/googleapis/google-api-nodejs-client/compare/merchantapi-v16.0.0...merchantapi-v16.1.0) (2025-11-26)
+
+
+### Features
+
+* **merchantapi:** update the API ([126dbf3](https://github.com/googleapis/google-api-nodejs-client/commit/126dbf39a0b92092e2f19efb491d4e07de74c418))
+* **merchantapi:** update the API ([33ba80e](https://github.com/googleapis/google-api-nodejs-client/commit/33ba80e5bf48a4cc05552c8a8607e98c43d8c0a7))
+* regenerate index files ([55171de](https://github.com/googleapis/google-api-nodejs-client/commit/55171de7cd500021ca8df008337dacc3ca9da23b))
+
 ## [16.0.0](https://github.com/googleapis/google-api-nodejs-client/compare/merchantapi-v15.0.0...merchantapi-v16.0.0) (2025-11-11)
 
 

package/accounts_v1.ts

@@ -231,6 +231,19 @@ export namespace merchantapi_accounts_v1 {
      */
     title?: string | null;
   }
+  /**
+   * A limit of a certain type that is applied to an account.
+   */
+  export interface Schema$AccountLimit {
+    /**
+     * Identifier. The limit part of the name will be a combination of the type and the scope. For example: `accounts/123/limits/products~ADS_NON_EEA` Format: `accounts/{account\}/limits/{limit\}`
+     */
+    name?: string | null;
+    /**
+     * The limit for products.
+     */
+    products?: Schema$ProductLimit;
+  }
   /**
    * `AccountManagement` payload.
    */
@@ -1136,6 +1149,19 @@ export namespace merchantapi_accounts_v1 {
      */
     nextPageToken?: string | null;
   }
+  /**
+   * Response message for the `ListAccountLimits` method.
+   */
+  export interface Schema$ListAccountLimitsResponse {
+    /**
+     * The limits for the given account.
+     */
+    accountLimits?: Schema$AccountLimit[];
+    /**
+     * 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 after trying to list account relationships.
    */
@@ -1594,6 +1620,19 @@ export namespace merchantapi_accounts_v1 {
      */
     reportingContext?: string | null;
   }
+  /**
+   * The limit for products.
+   */
+  export interface Schema$ProductLimit {
+    /**
+     * Required. The maximum number of products that are allowed in the account in the given scope.
+     */
+    limit?: string | null;
+    /**
+     * Required. The scope of the product limit.
+     */
+    scope?: string | null;
+  }
   /**
    * `ProductsManagement` payload.
    */
@@ -2244,6 +2283,7 @@ export namespace merchantapi_accounts_v1 {
     gbpAccounts: Resource$Accounts$Gbpaccounts;
     homepage: Resource$Accounts$Homepage;
     issues: Resource$Accounts$Issues;
+    limits: Resource$Accounts$Limits;
     omnichannelSettings: Resource$Accounts$Omnichannelsettings;
     onlineReturnPolicies: Resource$Accounts$Onlinereturnpolicies;
     programs: Resource$Accounts$Programs;
@@ -2274,6 +2314,7 @@ export namespace merchantapi_accounts_v1 {
       this.gbpAccounts = new Resource$Accounts$Gbpaccounts(this.context);
       this.homepage = new Resource$Accounts$Homepage(this.context);
       this.issues = new Resource$Accounts$Issues(this.context);
+      this.limits = new Resource$Accounts$Limits(this.context);
       this.omnichannelSettings = new Resource$Accounts$Omnichannelsettings(
         this.context
       );
@@ -6669,6 +6710,326 @@ export namespace merchantapi_accounts_v1 {
     timeZone?: string;
   }
 
+  export class Resource$Accounts$Limits {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * Retrieves an account limit.
+     * @example
+     * ```js
+     * // Before running the sample:
+     * // - Enable the API at:
+     * //   https://console.developers.google.com/apis/api/merchantapi.googleapis.com
+     * // - Login into gcloud by running:
+     * //   ```sh
+     * //   $ gcloud auth application-default login
+     * //   ```
+     * // - Install the npm module by running:
+     * //   ```sh
+     * //   $ npm install googleapis
+     * //   ```
+     *
+     * const {google} = require('googleapis');
+     * const merchantapi = google.merchantapi('accounts_v1');
+     *
+     * 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 merchantapi.accounts.limits.get({
+     *     // Required. The name of the limit to retrieve. Format: `accounts/{account\}/limits/{limit\}` For example: `accounts/123/limits/products~ADS_NON_EEA`
+     *     name: 'accounts/my-account/limits/my-limit',
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "name": "my_name",
+     *   //   "products": {}
+     *   // }
+     * }
+     *
+     * 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$Limits$Get,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    get(
+      params?: Params$Resource$Accounts$Limits$Get,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$AccountLimit>>;
+    get(
+      params: Params$Resource$Accounts$Limits$Get,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    get(
+      params: Params$Resource$Accounts$Limits$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$AccountLimit>,
+      callback: BodyResponseCallback<Schema$AccountLimit>
+    ): void;
+    get(
+      params: Params$Resource$Accounts$Limits$Get,
+      callback: BodyResponseCallback<Schema$AccountLimit>
+    ): void;
+    get(callback: BodyResponseCallback<Schema$AccountLimit>): void;
+    get(
+      paramsOrCallback?:
+        | Params$Resource$Accounts$Limits$Get
+        | BodyResponseCallback<Schema$AccountLimit>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$AccountLimit>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$AccountLimit>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$AccountLimit>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Accounts$Limits$Get;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Accounts$Limits$Get;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://merchantapi.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/accounts/v1/{+name}').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'GET',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['name'],
+        pathParams: ['name'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$AccountLimit>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$AccountLimit>(parameters);
+      }
+    }
+
+    /**
+     * Lists the limits of an account.
+     * @example
+     * ```js
+     * // Before running the sample:
+     * // - Enable the API at:
+     * //   https://console.developers.google.com/apis/api/merchantapi.googleapis.com
+     * // - Login into gcloud by running:
+     * //   ```sh
+     * //   $ gcloud auth application-default login
+     * //   ```
+     * // - Install the npm module by running:
+     * //   ```sh
+     * //   $ npm install googleapis
+     * //   ```
+     *
+     * const {google} = require('googleapis');
+     * const merchantapi = google.merchantapi('accounts_v1');
+     *
+     * 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 merchantapi.accounts.limits.list({
+     *     // Required. A filter on the limit `type` is required, for example, `type = "products"`.
+     *     filter: 'placeholder-value',
+     *     // Optional. The maximum number of limits to return. The service may return fewer than this value. If unspecified, at most 100 limits will be returned. The maximum value is 100; values above 100 will be coerced to 100.
+     *     pageSize: 'placeholder-value',
+     *     // Optional. A page token, received from a previous `ListAccountLimits` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccountLimits` must match the call that provided the page token.
+     *     pageToken: 'placeholder-value',
+     *     // Required. The parent account. Format: `accounts/{account\}`
+     *     parent: 'accounts/my-account',
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "accountLimits": [],
+     *   //   "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$Limits$List,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    list(
+      params?: Params$Resource$Accounts$Limits$List,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$ListAccountLimitsResponse>>;
+    list(
+      params: Params$Resource$Accounts$Limits$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    list(
+      params: Params$Resource$Accounts$Limits$List,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$ListAccountLimitsResponse>,
+      callback: BodyResponseCallback<Schema$ListAccountLimitsResponse>
+    ): void;
+    list(
+      params: Params$Resource$Accounts$Limits$List,
+      callback: BodyResponseCallback<Schema$ListAccountLimitsResponse>
+    ): void;
+    list(
+      callback: BodyResponseCallback<Schema$ListAccountLimitsResponse>
+    ): void;
+    list(
+      paramsOrCallback?:
+        | Params$Resource$Accounts$Limits$List
+        | BodyResponseCallback<Schema$ListAccountLimitsResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$ListAccountLimitsResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$ListAccountLimitsResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$ListAccountLimitsResponse>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Accounts$Limits$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Accounts$Limits$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://merchantapi.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/accounts/v1/{+parent}/limits').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'GET',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['parent'],
+        pathParams: ['parent'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ListAccountLimitsResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ListAccountLimitsResponse>(parameters);
+      }
+    }
+  }
+
+  export interface Params$Resource$Accounts$Limits$Get
+    extends StandardParameters {
+    /**
+     * Required. The name of the limit to retrieve. Format: `accounts/{account\}/limits/{limit\}` For example: `accounts/123/limits/products~ADS_NON_EEA`
+     */
+    name?: string;
+  }
+  export interface Params$Resource$Accounts$Limits$List
+    extends StandardParameters {
+    /**
+     * Required. A filter on the limit `type` is required, for example, `type = "products"`.
+     */
+    filter?: string;
+    /**
+     * Optional. The maximum number of limits to return. The service may return fewer than this value. If unspecified, at most 100 limits will be returned. The maximum value is 100; values above 100 will be coerced to 100.
+     */
+    pageSize?: number;
+    /**
+     * Optional. A page token, received from a previous `ListAccountLimits` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccountLimits` must match the call that provided the page token.
+     */
+    pageToken?: string;
+    /**
+     * Required. The parent account. Format: `accounts/{account\}`
+     */
+    parent?: string;
+  }
+
   export class Resource$Accounts$Omnichannelsettings {
     context: APIRequestContext;
     lfpProviders: Resource$Accounts$Omnichannelsettings$Lfpproviders;

package/build/accounts_v1.d.ts

@@ -177,6 +177,19 @@ export declare namespace merchantapi_accounts_v1 {
          */
         title?: string | null;
     }
+    /**
+     * A limit of a certain type that is applied to an account.
+     */
+    export interface Schema$AccountLimit {
+        /**
+         * Identifier. The limit part of the name will be a combination of the type and the scope. For example: `accounts/123/limits/products~ADS_NON_EEA` Format: `accounts/{account\}/limits/{limit\}`
+         */
+        name?: string | null;
+        /**
+         * The limit for products.
+         */
+        products?: Schema$ProductLimit;
+    }
     /**
      * `AccountManagement` payload.
      */
@@ -1088,6 +1101,19 @@ export declare namespace merchantapi_accounts_v1 {
          */
         nextPageToken?: string | null;
     }
+    /**
+     * Response message for the `ListAccountLimits` method.
+     */
+    export interface Schema$ListAccountLimitsResponse {
+        /**
+         * The limits for the given account.
+         */
+        accountLimits?: Schema$AccountLimit[];
+        /**
+         * 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 after trying to list account relationships.
      */
@@ -1547,6 +1573,19 @@ export declare namespace merchantapi_accounts_v1 {
          */
         reportingContext?: string | null;
     }
+    /**
+     * The limit for products.
+     */
+    export interface Schema$ProductLimit {
+        /**
+         * Required. The maximum number of products that are allowed in the account in the given scope.
+         */
+        limit?: string | null;
+        /**
+         * Required. The scope of the product limit.
+         */
+        scope?: string | null;
+    }
     /**
      * `ProductsManagement` payload.
      */
@@ -2201,6 +2240,7 @@ export declare namespace merchantapi_accounts_v1 {
         gbpAccounts: Resource$Accounts$Gbpaccounts;
         homepage: Resource$Accounts$Homepage;
         issues: Resource$Accounts$Issues;
+        limits: Resource$Accounts$Limits;
         omnichannelSettings: Resource$Accounts$Omnichannelsettings;
         onlineReturnPolicies: Resource$Accounts$Onlinereturnpolicies;
         programs: Resource$Accounts$Programs;
@@ -4376,6 +4416,162 @@ export declare namespace merchantapi_accounts_v1 {
          */
         timeZone?: string;
     }
+    export class Resource$Accounts$Limits {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Retrieves an account limit.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/merchantapi.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const merchantapi = google.merchantapi('accounts_v1');
+         *
+         * 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 merchantapi.accounts.limits.get({
+         *     // Required. The name of the limit to retrieve. Format: `accounts/{account\}/limits/{limit\}` For example: `accounts/123/limits/products~ADS_NON_EEA`
+         *     name: 'accounts/my-account/limits/my-limit',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "name": "my_name",
+         *   //   "products": {}
+         *   // }
+         * }
+         *
+         * 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$Limits$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Limits$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$AccountLimit>>;
+        get(params: Params$Resource$Accounts$Limits$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Accounts$Limits$Get, options: MethodOptions | BodyResponseCallback<Schema$AccountLimit>, callback: BodyResponseCallback<Schema$AccountLimit>): void;
+        get(params: Params$Resource$Accounts$Limits$Get, callback: BodyResponseCallback<Schema$AccountLimit>): void;
+        get(callback: BodyResponseCallback<Schema$AccountLimit>): void;
+        /**
+         * Lists the limits of an account.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/merchantapi.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const merchantapi = google.merchantapi('accounts_v1');
+         *
+         * 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 merchantapi.accounts.limits.list({
+         *     // Required. A filter on the limit `type` is required, for example, `type = "products"`.
+         *     filter: 'placeholder-value',
+         *     // Optional. The maximum number of limits to return. The service may return fewer than this value. If unspecified, at most 100 limits will be returned. The maximum value is 100; values above 100 will be coerced to 100.
+         *     pageSize: 'placeholder-value',
+         *     // Optional. A page token, received from a previous `ListAccountLimits` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccountLimits` must match the call that provided the page token.
+         *     pageToken: 'placeholder-value',
+         *     // Required. The parent account. Format: `accounts/{account\}`
+         *     parent: 'accounts/my-account',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountLimits": [],
+         *   //   "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$Limits$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Limits$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListAccountLimitsResponse>>;
+        list(params: Params$Resource$Accounts$Limits$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Accounts$Limits$List, options: MethodOptions | BodyResponseCallback<Schema$ListAccountLimitsResponse>, callback: BodyResponseCallback<Schema$ListAccountLimitsResponse>): void;
+        list(params: Params$Resource$Accounts$Limits$List, callback: BodyResponseCallback<Schema$ListAccountLimitsResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ListAccountLimitsResponse>): void;
+    }
+    export interface Params$Resource$Accounts$Limits$Get extends StandardParameters {
+        /**
+         * Required. The name of the limit to retrieve. Format: `accounts/{account\}/limits/{limit\}` For example: `accounts/123/limits/products~ADS_NON_EEA`
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Accounts$Limits$List extends StandardParameters {
+        /**
+         * Required. A filter on the limit `type` is required, for example, `type = "products"`.
+         */
+        filter?: string;
+        /**
+         * Optional. The maximum number of limits to return. The service may return fewer than this value. If unspecified, at most 100 limits will be returned. The maximum value is 100; values above 100 will be coerced to 100.
+         */
+        pageSize?: number;
+        /**
+         * Optional. A page token, received from a previous `ListAccountLimits` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccountLimits` must match the call that provided the page token.
+         */
+        pageToken?: string;
+        /**
+         * Required. The parent account. Format: `accounts/{account\}`
+         */
+        parent?: string;
+    }
     export class Resource$Accounts$Omnichannelsettings {
         context: APIRequestContext;
         lfpProviders: Resource$Accounts$Omnichannelsettings$Lfpproviders;