@googleapis/merchantapi 16.1.0 → 17.0.0

package/products_v1beta.ts

@@ -745,7 +745,7 @@ export namespace merchantapi_products_v1beta {
     ratio?: number | null;
   }
   /**
-   * A message that represents loyalty program.
+   * LINT.IfChange(LoyaltyProgram) A message that represents loyalty program.
    */
   export interface Schema$LoyaltyProgram {
     /**
@@ -915,7 +915,7 @@ export namespace merchantapi_products_v1beta {
      */
     feedLabel?: string | null;
     /**
-     * Identifier. The name of the product input. Format: `accounts/{account\}/productInputs/{productinput\}` where the last section `productinput` consists of: `content_language~feed_label~offer_id` example for product input name is `accounts/123/productInputs/en~US~sku123`. A legacy local product input name would be `accounts/123/productInputs/local~en~US~sku123`. Note: For calls to the v1beta version, the `productInput` section consists of: `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productInputs/online~en~US~sku123`.
+     * Identifier. The name of the product. Format: `accounts/{account\}/productInputs/{productinput\}` The {productinput\} segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the {productinput\} segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{productinput\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{productinput\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/productinputs/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{productinput\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{productinput\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productinputs/online~en~US~sku123`.
      */
     name?: string | null;
     /**
@@ -1259,10 +1259,8 @@ export namespace merchantapi_products_v1beta {
      *   const res = await merchantapi.accounts.productInputs.delete({
      *     // Required. The primary or supplemental data source from which the product input should be deleted. Format: `accounts/{account\}/dataSources/{datasource\}`. For example, `accounts/123456/dataSources/104628`.
      *     dataSource: 'placeholder-value',
-     *     // Required. The name of the product input resource to delete. Format: `accounts/{account\}/productInputs/{product\}` where the last section `product` consists of: `content_language~feed_label~offer_id` example for product name is `accounts/123/productInputs/en~US~sku123`.
+     *     // Required. The name of the product input to delete. Format: `accounts/{account\}/productInputs/{productInput\}` The {productInput\} segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the {productInput\} segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{productInput\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{productInput\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/productInputs/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{productInput\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{productInput\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productinputs/online~en~US~sku123`.
      *     name: 'accounts/my-account/productInputs/my-productInput',
-     *     // Optional. If true, the `{productInput\}` in the `name` field of the request will be interpreted as unpadded base64url-encoded and decoded during request processing to match the decoded value. Default value is `false`. Use this if your `{productInput\}` contains special characters, such as forward slash `/` or other characters that are unpadded base64url-encoded (as per RFC 7515: https://datatracker.ietf.org/doc/html/rfc7515#section-2). Note that future versions of the API will only accept unpadded base64url-encoded product ids, so we strongly recommend proactively setting this to `true` and encoding the product ids.
-     *     productIdBase64UrlEncoded: 'placeholder-value',
      *   });
      *   console.log(res.data);
      *
@@ -1528,7 +1526,7 @@ export namespace merchantapi_products_v1beta {
     }
 
     /**
-     * Updates the existing product input in your Merchant Center account. After inserting, updating, or deleting a product input, it may take several minutes before the processed product can be retrieved.
+     * Updates the existing product input in your Merchant Center account. The name of the product input to update is taken from the `name` field within the `ProductInput` resource. After inserting, updating, or deleting a product input, it may take several minutes before the processed product can be retrieved.
      * @example
      * ```js
      * // Before running the sample:
@@ -1560,10 +1558,8 @@ export namespace merchantapi_products_v1beta {
      *   const res = await merchantapi.accounts.productInputs.patch({
      *     // Required. The primary or supplemental product data source where `data_source` name identifies the product input to be updated. Only API data sources are supported. Format: `accounts/{account\}/dataSources/{datasource\}`. For example, `accounts/123456/dataSources/104628`.
      *     dataSource: 'placeholder-value',
-     *     // Identifier. The name of the product input. Format: `accounts/{account\}/productInputs/{productinput\}` where the last section `productinput` consists of: `content_language~feed_label~offer_id` example for product input name is `accounts/123/productInputs/en~US~sku123`. A legacy local product input name would be `accounts/123/productInputs/local~en~US~sku123`. Note: For calls to the v1beta version, the `productInput` section consists of: `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productInputs/online~en~US~sku123`.
+     *     // Identifier. The name of the product. Format: `accounts/{account\}/productInputs/{productinput\}` The {productinput\} segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the {productinput\} segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{productinput\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{productinput\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/productinputs/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{productinput\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{productinput\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productinputs/online~en~US~sku123`.
      *     name: 'accounts/my-account/productInputs/my-productInput',
-     *     // Optional. If true, the `{productInput\}` in the `name` field of the request will be interpreted as unpadded base64url-encoded and decoded during request processing to match the decoded value. Default value is `false`. Use this if your `{productInput\}` contains special characters, such as forward slash `/` or other characters that are unpadded base64url-encoded (as per RFC 7515: https://datatracker.ietf.org/doc/html/rfc7515#section-2). Note that future versions of the API will only accept unpadded base64url-encoded product ids, so we strongly recommend proactively setting this to `true` and encoding the product ids.
-     *     productIdBase64UrlEncoded: 'placeholder-value',
      *     // Optional. The list of product attributes to be updated. If the update mask is omitted, then it is treated as implied field mask equivalent to all fields that are populated (have a non-empty value). Attributes specified in the update mask without a value specified in the body will be deleted from the product. Update mask can only be specified for top level fields in attributes and custom attributes. To specify the update mask for custom attributes you need to add the `custom_attribute.` prefix. Providing special "*" value for full product replacement is not supported.
      *     updateMask: 'placeholder-value',
      *
@@ -1695,23 +1691,17 @@ export namespace merchantapi_products_v1beta {
     }
   }
 
-  export interface Params$Resource$Accounts$Productinputs$Delete
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Productinputs$Delete extends StandardParameters {
     /**
      * Required. The primary or supplemental data source from which the product input should be deleted. Format: `accounts/{account\}/dataSources/{datasource\}`. For example, `accounts/123456/dataSources/104628`.
      */
     dataSource?: string;
     /**
-     * Required. The name of the product input resource to delete. Format: `accounts/{account\}/productInputs/{product\}` where the last section `product` consists of: `content_language~feed_label~offer_id` example for product name is `accounts/123/productInputs/en~US~sku123`.
+     * Required. The name of the product input to delete. Format: `accounts/{account\}/productInputs/{productInput\}` The {productInput\} segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the {productInput\} segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{productInput\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{productInput\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/productInputs/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{productInput\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{productInput\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productinputs/online~en~US~sku123`.
      */
     name?: string;
-    /**
-     * Optional. If true, the `{productInput\}` in the `name` field of the request will be interpreted as unpadded base64url-encoded and decoded during request processing to match the decoded value. Default value is `false`. Use this if your `{productInput\}` contains special characters, such as forward slash `/` or other characters that are unpadded base64url-encoded (as per RFC 7515: https://datatracker.ietf.org/doc/html/rfc7515#section-2). Note that future versions of the API will only accept unpadded base64url-encoded product ids, so we strongly recommend proactively setting this to `true` and encoding the product ids.
-     */
-    productIdBase64UrlEncoded?: boolean;
   }
-  export interface Params$Resource$Accounts$Productinputs$Insert
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Productinputs$Insert extends StandardParameters {
     /**
      * Required. The primary or supplemental product data source name. If the product already exists and data source provided is different, then the product will be moved to a new data source. For more information, see [Create a primary data source](/merchant/api/guides/data-sources/api-sources#create-primary-data-source). Only API data sources are supported. Format: `accounts/{account\}/dataSources/{datasource\}`. For example, `accounts/123456/dataSources/104628`.
      */
@@ -1726,20 +1716,15 @@ export namespace merchantapi_products_v1beta {
      */
     requestBody?: Schema$ProductInput;
   }
-  export interface Params$Resource$Accounts$Productinputs$Patch
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Productinputs$Patch extends StandardParameters {
     /**
      * Required. The primary or supplemental product data source where `data_source` name identifies the product input to be updated. Only API data sources are supported. Format: `accounts/{account\}/dataSources/{datasource\}`. For example, `accounts/123456/dataSources/104628`.
      */
     dataSource?: string;
     /**
-     * Identifier. The name of the product input. Format: `accounts/{account\}/productInputs/{productinput\}` where the last section `productinput` consists of: `content_language~feed_label~offer_id` example for product input name is `accounts/123/productInputs/en~US~sku123`. A legacy local product input name would be `accounts/123/productInputs/local~en~US~sku123`. Note: For calls to the v1beta version, the `productInput` section consists of: `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productInputs/online~en~US~sku123`.
+     * Identifier. The name of the product. Format: `accounts/{account\}/productInputs/{productinput\}` The {productinput\} segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the {productinput\} segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{productinput\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{productinput\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/productinputs/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{productinput\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{productinput\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/productinputs/online~en~US~sku123`.
      */
     name?: string;
-    /**
-     * Optional. If true, the `{productInput\}` in the `name` field of the request will be interpreted as unpadded base64url-encoded and decoded during request processing to match the decoded value. Default value is `false`. Use this if your `{productInput\}` contains special characters, such as forward slash `/` or other characters that are unpadded base64url-encoded (as per RFC 7515: https://datatracker.ietf.org/doc/html/rfc7515#section-2). Note that future versions of the API will only accept unpadded base64url-encoded product ids, so we strongly recommend proactively setting this to `true` and encoding the product ids.
-     */
-    productIdBase64UrlEncoded?: boolean;
     /**
      * Optional. The list of product attributes to be updated. If the update mask is omitted, then it is treated as implied field mask equivalent to all fields that are populated (have a non-empty value). Attributes specified in the update mask without a value specified in the body will be deleted from the product. Update mask can only be specified for top level fields in attributes and custom attributes. To specify the update mask for custom attributes you need to add the `custom_attribute.` prefix. Providing special "*" value for full product replacement is not supported.
      */
@@ -1788,10 +1773,8 @@ export namespace merchantapi_products_v1beta {
      *
      *   // Do the magic
      *   const res = await merchantapi.accounts.products.get({
-     *     // Required. The name of the product to retrieve. Format: `accounts/{account\}/products/{product\}` where the last section `product` consists of: `content_language~feed_label~offer_id` example for product name is `accounts/123/products/en~US~sku123`. A legacy local product name would be `accounts/123/products/local~en~US~sku123`. Note: For calls to the v1beta version, the `product` section consists of: `channel~content_language~feed_label~offer_id`, for example: `accounts/123/products/online~en~US~sku123`.
+     *     // Required. The name of the product. Format: `accounts/{account\}/products/{product\}` The `{product\}` segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the `{product\}` segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{product\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{product\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/products/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{product\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{product\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/products/online~en~US~sku123`.
      *     name: 'accounts/my-account/products/my-product',
-     *     // Optional. If true, the `{product\}` in the `name` field of the request will be interpreted as unpadded base64url-encoded and decoded during request processing to match the decoded value. Default value is `false`. Use this if your `{product\}` contains special characters, such as forward slash `/` or other characters that are unpadded base64url-encoded (as per RFC 7515: https://datatracker.ietf.org/doc/html/rfc7515#section-2). Note that future versions of the API will only accept unpadded base64url-encoded product ids, so we strongly recommend proactively setting this to `true` and encoding the product ids.
-     *     productIdBase64UrlEncoded: 'placeholder-value',
      *   });
      *   console.log(res.data);
      *
@@ -2051,19 +2034,13 @@ export namespace merchantapi_products_v1beta {
     }
   }
 
-  export interface Params$Resource$Accounts$Products$Get
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Products$Get extends StandardParameters {
     /**
-     * Required. The name of the product to retrieve. Format: `accounts/{account\}/products/{product\}` where the last section `product` consists of: `content_language~feed_label~offer_id` example for product name is `accounts/123/products/en~US~sku123`. A legacy local product name would be `accounts/123/products/local~en~US~sku123`. Note: For calls to the v1beta version, the `product` section consists of: `channel~content_language~feed_label~offer_id`, for example: `accounts/123/products/online~en~US~sku123`.
+     * Required. The name of the product. Format: `accounts/{account\}/products/{product\}` The `{product\}` segment is a unique identifier for the product. This identifier must be unique within a merchant account and generally follows the structure: `content_language~feed_label~offer_id`. Example: `en~US~sku123` For legacy local products, the structure is: `local~content_language~feed_label~offer_id`. Example: `local~en~US~sku123` The format of the `{product\}` segment in the URL is automatically detected by the server, supporting two options: 1. **Encoded Format**: The `{product\}` segment is an unpadded base64url encoded string (RFC 4648 Section 5). The decoded string must result in the `content_language~feed_label~offer_id` structure. This encoding MUST be used if any part of the product identifier (like `offer_id`) contains characters such as `/`, `%`, or `~`. * Example: To represent the product ID `en~US~sku/123`, the `{product\}` segment must be the base64url encoding of this string, which is `ZW5-VVMtc2t1LzEyMw`. The full resource name for the product would be `accounts/123/products/ZW5-VVMtc2t1LzEyMw`. 2. **Plain Format**: The `{product\}` segment is the tilde-separated string `content_language~feed_label~offer_id`. This format is suitable only when `content_language`, `feed_label`, and `offer_id` do not contain URL-problematic characters like `/`, `%`, or `~`. We recommend using the **Encoded Format** for all product IDs to ensure correct parsing, especially those containing special characters. The presence of tilde (`~`) characters in the `{product\}` segment is used to differentiate between the two formats. Note: For calls to the v1beta version, the plain format is `channel~content_language~feed_label~offer_id`, for example: `accounts/123/products/online~en~US~sku123`.
      */
     name?: string;
-    /**
-     * Optional. If true, the `{product\}` in the `name` field of the request will be interpreted as unpadded base64url-encoded and decoded during request processing to match the decoded value. Default value is `false`. Use this if your `{product\}` contains special characters, such as forward slash `/` or other characters that are unpadded base64url-encoded (as per RFC 7515: https://datatracker.ietf.org/doc/html/rfc7515#section-2). Note that future versions of the API will only accept unpadded base64url-encoded product ids, so we strongly recommend proactively setting this to `true` and encoding the product ids.
-     */
-    productIdBase64UrlEncoded?: boolean;
   }
-  export interface Params$Resource$Accounts$Products$List
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Products$List extends StandardParameters {
     /**
      * The maximum number of products to return. The service may return fewer than this value. The maximum value is 1000; values above 1000 will be coerced to 1000. If unspecified, the default page size of 25 products will be returned.
      */

package/promotions_v1.ts

@@ -958,15 +958,13 @@ export namespace merchantapi_promotions_v1 {
     }
   }
 
-  export interface Params$Resource$Accounts$Promotions$Get
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Promotions$Get extends StandardParameters {
     /**
      * Required. The name of the promotion to retrieve. Format: `accounts/{account\}/promotions/{promotions\}`
      */
     name?: string;
   }
-  export interface Params$Resource$Accounts$Promotions$Insert
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Promotions$Insert extends StandardParameters {
     /**
      * Required. The account where the promotion will be inserted. Format: accounts/{account\}
      */
@@ -977,8 +975,7 @@ export namespace merchantapi_promotions_v1 {
      */
     requestBody?: Schema$InsertPromotionRequest;
   }
-  export interface Params$Resource$Accounts$Promotions$List
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Promotions$List extends StandardParameters {
     /**
      * Optional. The maximum number of promotions to return. The service may return fewer than this value. The maximum value is 250; values above 250 will be coerced to 250. If unspecified, the maximum number of promotions will be returned.
      */

package/promotions_v1beta.ts

@@ -958,15 +958,13 @@ export namespace merchantapi_promotions_v1beta {
     }
   }
 
-  export interface Params$Resource$Accounts$Promotions$Get
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Promotions$Get extends StandardParameters {
     /**
      * Required. The name of the promotion to retrieve. Format: `accounts/{account\}/promotions/{promotions\}`
      */
     name?: string;
   }
-  export interface Params$Resource$Accounts$Promotions$Insert
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Promotions$Insert extends StandardParameters {
     /**
      * Required. The account where the promotion will be inserted. Format: accounts/{account\}
      */
@@ -977,8 +975,7 @@ export namespace merchantapi_promotions_v1beta {
      */
     requestBody?: Schema$InsertPromotionRequest;
   }
-  export interface Params$Resource$Accounts$Promotions$List
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Promotions$List extends StandardParameters {
     /**
      * Optional. The maximum number of promotions to return. The service may return fewer than this value. The maximum value is 250; values above 250 will be coerced to 250. If unspecified, the maximum number of promotions will be returned.
      */

package/quota_v1.ts

@@ -124,6 +124,32 @@ export namespace merchantapi_quota_v1 {
     }
   }
 
+  /**
+   * 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;
+  }
+  /**
+   * 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 message for the ListMethodGroups method.
    */
@@ -179,6 +205,19 @@ export namespace merchantapi_quota_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;
+  }
   /**
    * The message that the merchant will receive to notify about product status change event
    */
@@ -248,13 +287,330 @@ export namespace merchantapi_quota_v1 {
 
   export class Resource$Accounts {
     context: APIRequestContext;
+    limits: Resource$Accounts$Limits;
     quotas: Resource$Accounts$Quotas;
     constructor(context: APIRequestContext) {
       this.context = context;
+      this.limits = new Resource$Accounts$Limits(this.context);
       this.quotas = new Resource$Accounts$Quotas(this.context);
     }
   }
 
+  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('quota_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 + '/quota/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('quota_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 + '/quota/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$Quotas {
     context: APIRequestContext;
     constructor(context: APIRequestContext) {
@@ -406,8 +762,7 @@ export namespace merchantapi_quota_v1 {
     }
   }
 
-  export interface Params$Resource$Accounts$Quotas$List
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Quotas$List extends StandardParameters {
     /**
      * Optional. The maximum number of quotas to return in the response, used for paging. Defaults to 500; values above 1000 will be coerced to 1000.
      */

package/quota_v1beta.ts

@@ -406,8 +406,7 @@ export namespace merchantapi_quota_v1beta {
     }
   }
 
-  export interface Params$Resource$Accounts$Quotas$List
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Quotas$List extends StandardParameters {
     /**
      * Optional. The maximum number of quotas to return in the response, used for paging. Defaults to 500; values above 1000 will be coerced to 1000.
      */

package/reports_v1.ts

@@ -1190,8 +1190,7 @@ export namespace merchantapi_reports_v1 {
     }
   }
 
-  export interface Params$Resource$Accounts$Reports$Search
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Reports$Search extends StandardParameters {
     /**
      * Required. Id of the account making the call. Must be a standalone account or an MCA subaccount. Format: accounts/{account\}
      */

package/reports_v1beta.ts

@@ -1190,8 +1190,7 @@ export namespace merchantapi_reports_v1beta {
     }
   }
 
-  export interface Params$Resource$Accounts$Reports$Search
-    extends StandardParameters {
+  export interface Params$Resource$Accounts$Reports$Search extends StandardParameters {
     /**
      * Required. Id of the account making the call. Must be a standalone account or an MCA subaccount. Format: accounts/{account\}
      */