@commercelayer/sdk 4.27.1 → 4.28.1

package/lib/cjs/resources/adyen_payments.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type AdyenPaymentRel = ResourceRel & {
     type: typeof AdyenPayments.TYPE;
 };
@@ -18,6 +19,7 @@ interface AdyenPayment extends Resource {
     payment_instrument?: object;
     order?: Order;
     payment_gateway?: PaymentGateway;
+    versions?: Version[];
 }
 interface AdyenPaymentCreate extends ResourceCreate {
     order: OrderRel;
@@ -38,6 +40,7 @@ declare class AdyenPayments extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(adyenPaymentId: string | AdyenPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(adyenPaymentId: string | AdyenPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(adyenPaymentId: string | AdyenPayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isAdyenPayment(resource: any): resource is AdyenPayment;
     relationship(id: string | ResourceId | null): AdyenPaymentRel;
     type(): string;

package/lib/cjs/resources/adyen_payments.js

@@ -26,6 +26,10 @@ class AdyenPayments extends resource_1.ApiResource {
         const _adyenPaymentId = adyenPaymentId.id || adyenPaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `adyen_payments/${_adyenPaymentId}/payment_gateway`, params, options);
     }
+    async versions(adyenPaymentId, params, options) {
+        const _adyenPaymentId = adyenPaymentId.id || adyenPaymentId;
+        return this.resources.fetch({ type: 'versions' }, `adyen_payments/${_adyenPaymentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAdyenPayment(resource) {
         return resource.type && (resource.type === AdyenPayments.TYPE);

package/lib/cjs/resources/authorizations.d.ts

@@ -1,9 +1,11 @@
 import { ApiResource, Resource, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
+import type { Attachment } from './attachments';
+import type { Event } from './events';
+import type { Version } from './versions';
 import type { Capture } from './captures';
 import type { Void } from './voids';
-import type { Event } from './events';
 type AuthorizationRel = ResourceRel & {
     type: typeof Authorizations.TYPE;
 };
@@ -34,9 +36,11 @@ interface Authorization extends Resource {
     void_balance_float?: number;
     formatted_void_balance?: string;
     order?: Order;
+    attachments?: Attachment[];
+    events?: Event[];
+    versions?: Version[];
     captures?: Capture[];
     voids?: Void[];
-    events?: Event[];
 }
 interface AuthorizationUpdate extends ResourceUpdate {
     _capture?: boolean;
@@ -49,9 +53,11 @@ declare class Authorizations extends ApiResource {
     retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Authorization>;
     update(resource: AuthorizationUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Authorization>;
     order(authorizationId: string | Authorization, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    attachments(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    events(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     captures(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Capture>>;
     voids(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Void>>;
-    events(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     isAuthorization(resource: any): resource is Authorization;
     relationship(id: string | ResourceId | null): AuthorizationRel;
     type(): string;

package/lib/cjs/resources/authorizations.js

@@ -16,6 +16,18 @@ class Authorizations extends resource_1.ApiResource {
         const _authorizationId = authorizationId.id || authorizationId;
         return this.resources.fetch({ type: 'orders' }, `authorizations/${_authorizationId}/order`, params, options);
     }
+    async attachments(authorizationId, params, options) {
+        const _authorizationId = authorizationId.id || authorizationId;
+        return this.resources.fetch({ type: 'attachments' }, `authorizations/${_authorizationId}/attachments`, params, options);
+    }
+    async events(authorizationId, params, options) {
+        const _authorizationId = authorizationId.id || authorizationId;
+        return this.resources.fetch({ type: 'events' }, `authorizations/${_authorizationId}/events`, params, options);
+    }
+    async versions(authorizationId, params, options) {
+        const _authorizationId = authorizationId.id || authorizationId;
+        return this.resources.fetch({ type: 'versions' }, `authorizations/${_authorizationId}/versions`, params, options);
+    }
     async captures(authorizationId, params, options) {
         const _authorizationId = authorizationId.id || authorizationId;
         return this.resources.fetch({ type: 'captures' }, `authorizations/${_authorizationId}/captures`, params, options);
@@ -24,10 +36,6 @@ class Authorizations extends resource_1.ApiResource {
         const _authorizationId = authorizationId.id || authorizationId;
         return this.resources.fetch({ type: 'voids' }, `authorizations/${_authorizationId}/voids`, params, options);
     }
-    async events(authorizationId, params, options) {
-        const _authorizationId = authorizationId.id || authorizationId;
-        return this.resources.fetch({ type: 'events' }, `authorizations/${_authorizationId}/events`, params, options);
-    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAuthorization(resource) {
         return resource.type && (resource.type === Authorizations.TYPE);

package/lib/cjs/resources/avalara_accounts.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { TaxCategory } from './tax_categories';
 type AvalaraAccountRel = ResourceRel & {
     type: typeof AvalaraAccounts.TYPE;
@@ -13,10 +14,11 @@ interface AvalaraAccount extends Resource {
     name?: string;
     username?: string;
     company_code?: string;
-    commit_invoice?: string;
-    ddp?: string;
+    commit_invoice?: boolean;
+    ddp?: boolean;
     markets?: Market[];
     attachments?: Attachment[];
+    versions?: Version[];
     tax_categories?: TaxCategory[];
 }
 interface AvalaraAccountCreate extends ResourceCreate {
@@ -24,8 +26,8 @@ interface AvalaraAccountCreate extends ResourceCreate {
     username: string;
     password: string;
     company_code: string;
-    commit_invoice?: string;
-    ddp?: string;
+    commit_invoice?: boolean;
+    ddp?: boolean;
     tax_categories?: TaxCategoryRel[];
 }
 interface AvalaraAccountUpdate extends ResourceUpdate {
@@ -33,8 +35,8 @@ interface AvalaraAccountUpdate extends ResourceUpdate {
     username?: string;
     password?: string;
     company_code?: string;
-    commit_invoice?: string;
-    ddp?: string;
+    commit_invoice?: boolean;
+    ddp?: boolean;
     tax_categories?: TaxCategoryRel[];
 }
 declare class AvalaraAccounts extends ApiResource {
@@ -46,6 +48,7 @@ declare class AvalaraAccounts extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     markets(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
     attachments(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     tax_categories(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxCategory>>;
     isAvalaraAccount(resource: any): resource is AvalaraAccount;
     relationship(id: string | ResourceId | null): AvalaraAccountRel;

package/lib/cjs/resources/avalara_accounts.js

@@ -26,6 +26,10 @@ class AvalaraAccounts extends resource_1.ApiResource {
         const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
         return this.resources.fetch({ type: 'attachments' }, `avalara_accounts/${_avalaraAccountId}/attachments`, params, options);
     }
+    async versions(avalaraAccountId, params, options) {
+        const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
+        return this.resources.fetch({ type: 'versions' }, `avalara_accounts/${_avalaraAccountId}/versions`, params, options);
+    }
     async tax_categories(avalaraAccountId, params, options) {
         const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
         return this.resources.fetch({ type: 'tax_categories' }, `avalara_accounts/${_avalaraAccountId}/tax_categories`, params, options);

package/lib/cjs/resources/axerve_gateways.d.ts

@@ -1,6 +1,7 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { AxervePayment } from './axerve_payments';
 type AxerveGatewayRel = ResourceRel & {
     type: typeof AxerveGateways.TYPE;
@@ -11,7 +12,9 @@ type AxervePaymentRel = ResourceRel & {
 interface AxerveGateway extends Resource {
     name?: string;
     login?: string;
+    webhook_endpoint_url?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
     axerve_payments?: AxervePayment[];
 }
 interface AxerveGatewayCreate extends ResourceCreate {
@@ -34,6 +37,7 @@ declare class AxerveGateways extends ApiResource {
     update(resource: AxerveGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxerveGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     axerve_payments(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AxervePayment>>;
     isAxerveGateway(resource: any): resource is AxerveGateway;
     relationship(id: string | ResourceId | null): AxerveGatewayRel;

package/lib/cjs/resources/axerve_gateways.js

@@ -22,6 +22,10 @@ class AxerveGateways extends resource_1.ApiResource {
         const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `axerve_gateways/${_axerveGatewayId}/payment_methods`, params, options);
     }
+    async versions(axerveGatewayId, params, options) {
+        const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `axerve_gateways/${_axerveGatewayId}/versions`, params, options);
+    }
     async axerve_payments(axerveGatewayId, params, options) {
         const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
         return this.resources.fetch({ type: 'axerve_payments' }, `axerve_gateways/${_axerveGatewayId}/axerve_payments`, params, options);

package/lib/cjs/resources/axerve_payments.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type AxervePaymentRel = ResourceRel & {
     type: typeof AxervePayments.TYPE;
 };
@@ -12,6 +13,9 @@ interface AxervePayment extends Resource {
     login?: string;
     return_url?: string;
     payment_request_data?: object;
+    client_ip?: string;
+    buyer_details?: object;
+    request_token?: boolean;
     mismatched_amounts?: boolean;
     intent_amount_cents?: number;
     intent_amount_float?: number;
@@ -19,9 +23,13 @@ interface AxervePayment extends Resource {
     payment_instrument?: object;
     order?: Order;
     payment_gateway?: PaymentGateway;
+    versions?: Version[];
 }
 interface AxervePaymentCreate extends ResourceCreate {
     return_url: string;
+    client_ip?: string;
+    buyer_details?: object;
+    request_token?: boolean;
     order: OrderRel;
 }
 interface AxervePaymentUpdate extends ResourceUpdate {
@@ -38,6 +46,7 @@ declare class AxervePayments extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(axervePaymentId: string | AxervePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(axervePaymentId: string | AxervePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(axervePaymentId: string | AxervePayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isAxervePayment(resource: any): resource is AxervePayment;
     relationship(id: string | ResourceId | null): AxervePaymentRel;
     type(): string;

package/lib/cjs/resources/axerve_payments.js

@@ -26,6 +26,10 @@ class AxervePayments extends resource_1.ApiResource {
         const _axervePaymentId = axervePaymentId.id || axervePaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `axerve_payments/${_axervePaymentId}/payment_gateway`, params, options);
     }
+    async versions(axervePaymentId, params, options) {
+        const _axervePaymentId = axervePaymentId.id || axervePaymentId;
+        return this.resources.fetch({ type: 'versions' }, `axerve_payments/${_axervePaymentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAxervePayment(resource) {
         return resource.type && (resource.type === AxervePayments.TYPE);

package/lib/cjs/resources/billing_info_validation_rules.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type BillingInfoValidationRuleRel = ResourceRel & {
     type: typeof BillingInfoValidationRules.TYPE;
 };
@@ -11,6 +12,7 @@ type MarketRel = ResourceRel & {
 interface BillingInfoValidationRule extends Resource {
     market?: Market;
     attachments?: Attachment[];
+    versions?: Version[];
 }
 interface BillingInfoValidationRuleCreate extends ResourceCreate {
     market: MarketRel;
@@ -27,6 +29,7 @@ declare class BillingInfoValidationRules extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     market(billingInfoValidationRuleId: string | BillingInfoValidationRule, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     attachments(billingInfoValidationRuleId: string | BillingInfoValidationRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(billingInfoValidationRuleId: string | BillingInfoValidationRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isBillingInfoValidationRule(resource: any): resource is BillingInfoValidationRule;
     relationship(id: string | ResourceId | null): BillingInfoValidationRuleRel;
     type(): string;

package/lib/cjs/resources/billing_info_validation_rules.js

@@ -26,6 +26,10 @@ class BillingInfoValidationRules extends resource_1.ApiResource {
         const _billingInfoValidationRuleId = billingInfoValidationRuleId.id || billingInfoValidationRuleId;
         return this.resources.fetch({ type: 'attachments' }, `billing_info_validation_rules/${_billingInfoValidationRuleId}/attachments`, params, options);
     }
+    async versions(billingInfoValidationRuleId, params, options) {
+        const _billingInfoValidationRuleId = billingInfoValidationRuleId.id || billingInfoValidationRuleId;
+        return this.resources.fetch({ type: 'versions' }, `billing_info_validation_rules/${_billingInfoValidationRuleId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isBillingInfoValidationRule(resource) {
         return resource.type && (resource.type === BillingInfoValidationRules.TYPE);

package/lib/cjs/resources/braintree_gateways.d.ts

@@ -1,6 +1,7 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { BraintreePayment } from './braintree_payments';
 type BraintreeGatewayRel = ResourceRel & {
     type: typeof BraintreeGateways.TYPE;
@@ -15,6 +16,7 @@ interface BraintreeGateway extends Resource {
     descriptor_url?: string;
     webhook_endpoint_url?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
     braintree_payments?: BraintreePayment[];
 }
 interface BraintreeGatewayCreate extends ResourceCreate {
@@ -47,6 +49,7 @@ declare class BraintreeGateways extends ApiResource {
     update(resource: BraintreeGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreeGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     braintree_payments(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BraintreePayment>>;
     isBraintreeGateway(resource: any): resource is BraintreeGateway;
     relationship(id: string | ResourceId | null): BraintreeGatewayRel;

package/lib/cjs/resources/braintree_gateways.js

@@ -22,6 +22,10 @@ class BraintreeGateways extends resource_1.ApiResource {
         const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `braintree_gateways/${_braintreeGatewayId}/payment_methods`, params, options);
     }
+    async versions(braintreeGatewayId, params, options) {
+        const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `braintree_gateways/${_braintreeGatewayId}/versions`, params, options);
+    }
     async braintree_payments(braintreeGatewayId, params, options) {
         const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
         return this.resources.fetch({ type: 'braintree_payments' }, `braintree_gateways/${_braintreeGatewayId}/braintree_payments`, params, options);

package/lib/cjs/resources/braintree_payments.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type BraintreePaymentRel = ResourceRel & {
     type: typeof BraintreePayments.TYPE;
 };
@@ -17,6 +18,7 @@ interface BraintreePayment extends Resource {
     payment_instrument?: object;
     order?: Order;
     payment_gateway?: PaymentGateway;
+    versions?: Version[];
 }
 interface BraintreePaymentCreate extends ResourceCreate {
     payment_id?: string;
@@ -40,6 +42,7 @@ declare class BraintreePayments extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(braintreePaymentId: string | BraintreePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(braintreePaymentId: string | BraintreePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(braintreePaymentId: string | BraintreePayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isBraintreePayment(resource: any): resource is BraintreePayment;
     relationship(id: string | ResourceId | null): BraintreePaymentRel;
     type(): string;

package/lib/cjs/resources/braintree_payments.js

@@ -26,6 +26,10 @@ class BraintreePayments extends resource_1.ApiResource {
         const _braintreePaymentId = braintreePaymentId.id || braintreePaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `braintree_payments/${_braintreePaymentId}/payment_gateway`, params, options);
     }
+    async versions(braintreePaymentId, params, options) {
+        const _braintreePaymentId = braintreePaymentId.id || braintreePaymentId;
+        return this.resources.fetch({ type: 'versions' }, `braintree_payments/${_braintreePaymentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isBraintreePayment(resource) {
         return resource.type && (resource.type === BraintreePayments.TYPE);

package/lib/cjs/resources/bundles.d.ts

@@ -4,6 +4,9 @@ import type { Market } from './markets';
 import type { SkuList } from './sku_lists';
 import type { Sku } from './skus';
 import type { Attachment } from './attachments';
+import type { Event } from './events';
+import type { Tag } from './tags';
+import type { Version } from './versions';
 type BundleRel = ResourceRel & {
     type: typeof Bundles.TYPE;
 };
@@ -13,6 +16,9 @@ type MarketRel = ResourceRel & {
 type SkuListRel = ResourceRel & {
     type: 'sku_lists';
 };
+type TagRel = ResourceRel & {
+    type: 'tags';
+};
 interface Bundle extends Resource {
     code?: string;
     name?: string;
@@ -32,6 +38,9 @@ interface Bundle extends Resource {
     sku_list?: SkuList;
     skus?: Sku[];
     attachments?: Attachment[];
+    events?: Event[];
+    tags?: Tag[];
+    versions?: Version[];
 }
 interface BundleCreate extends ResourceCreate {
     code: string;
@@ -39,12 +48,13 @@ interface BundleCreate extends ResourceCreate {
     currency_code?: string;
     description?: string;
     image_url?: string;
-    price_amount_cents: number;
-    compare_at_amount_cents: number;
+    price_amount_cents?: number;
+    compare_at_amount_cents?: number;
     _compute_price_amount?: boolean;
     _compute_compare_at_amount?: boolean;
     market?: MarketRel;
     sku_list: SkuListRel;
+    tags?: TagRel[];
 }
 interface BundleUpdate extends ResourceUpdate {
     code?: string;
@@ -56,6 +66,7 @@ interface BundleUpdate extends ResourceUpdate {
     compare_at_amount_cents?: number;
     _compute_price_amount?: boolean;
     _compute_compare_at_amount?: boolean;
+    tags?: TagRel[];
 }
 declare class Bundles extends ApiResource {
     static readonly TYPE: 'bundles';
@@ -68,6 +79,9 @@ declare class Bundles extends ApiResource {
     sku_list(bundleId: string | Bundle, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SkuList>;
     skus(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Sku>>;
     attachments(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    events(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    tags(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isBundle(resource: any): resource is Bundle;
     relationship(id: string | ResourceId | null): BundleRel;
     type(): string;

package/lib/cjs/resources/bundles.js

@@ -34,6 +34,18 @@ class Bundles extends resource_1.ApiResource {
         const _bundleId = bundleId.id || bundleId;
         return this.resources.fetch({ type: 'attachments' }, `bundles/${_bundleId}/attachments`, params, options);
     }
+    async events(bundleId, params, options) {
+        const _bundleId = bundleId.id || bundleId;
+        return this.resources.fetch({ type: 'events' }, `bundles/${_bundleId}/events`, params, options);
+    }
+    async tags(bundleId, params, options) {
+        const _bundleId = bundleId.id || bundleId;
+        return this.resources.fetch({ type: 'tags' }, `bundles/${_bundleId}/tags`, params, options);
+    }
+    async versions(bundleId, params, options) {
+        const _bundleId = bundleId.id || bundleId;
+        return this.resources.fetch({ type: 'versions' }, `bundles/${_bundleId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isBundle(resource) {
         return resource.type && (resource.type === Bundles.TYPE);

package/lib/cjs/resources/buy_x_pay_y_promotions.d.ts

@@ -0,0 +1,134 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsList, QueryParamsRetrieve } from '../query';
+import type { Market } from './markets';
+import type { PromotionRule } from './promotion_rules';
+import type { OrderAmountPromotionRule } from './order_amount_promotion_rules';
+import type { SkuListPromotionRule } from './sku_list_promotion_rules';
+import type { CouponCodesPromotionRule } from './coupon_codes_promotion_rules';
+import type { CustomPromotionRule } from './custom_promotion_rules';
+import type { SkuList } from './sku_lists';
+import type { Coupon } from './coupons';
+import type { Attachment } from './attachments';
+import type { Event } from './events';
+import type { Tag } from './tags';
+import type { Version } from './versions';
+import type { Sku } from './skus';
+type BuyXPayYPromotionRel = ResourceRel & {
+    type: typeof BuyXPayYPromotions.TYPE;
+};
+type MarketRel = ResourceRel & {
+    type: 'markets';
+};
+type OrderAmountPromotionRuleRel = ResourceRel & {
+    type: 'order_amount_promotion_rules';
+};
+type SkuListPromotionRuleRel = ResourceRel & {
+    type: 'sku_list_promotion_rules';
+};
+type CouponCodesPromotionRuleRel = ResourceRel & {
+    type: 'coupon_codes_promotion_rules';
+};
+type CustomPromotionRuleRel = ResourceRel & {
+    type: 'custom_promotion_rules';
+};
+type SkuListRel = ResourceRel & {
+    type: 'sku_lists';
+};
+type TagRel = ResourceRel & {
+    type: 'tags';
+};
+interface BuyXPayYPromotion extends Resource {
+    name?: string;
+    currency_code?: string;
+    exclusive?: boolean;
+    priority?: number;
+    starts_at?: string;
+    expires_at?: string;
+    total_usage_limit?: number;
+    total_usage_count?: number;
+    active?: boolean;
+    disabled_at?: string;
+    x?: number;
+    y?: number;
+    cheapest_free?: boolean;
+    market?: Market;
+    promotion_rules?: PromotionRule[];
+    order_amount_promotion_rule?: OrderAmountPromotionRule;
+    sku_list_promotion_rule?: SkuListPromotionRule;
+    coupon_codes_promotion_rule?: CouponCodesPromotionRule;
+    custom_promotion_rule?: CustomPromotionRule;
+    sku_list?: SkuList;
+    coupons?: Coupon[];
+    attachments?: Attachment[];
+    events?: Event[];
+    tags?: Tag[];
+    versions?: Version[];
+    skus?: Sku[];
+}
+interface BuyXPayYPromotionCreate extends ResourceCreate {
+    name: string;
+    currency_code?: string;
+    exclusive?: boolean;
+    priority?: number;
+    starts_at: string;
+    expires_at: string;
+    total_usage_limit?: number;
+    _disable?: boolean;
+    _enable?: boolean;
+    x: number;
+    y: number;
+    cheapest_free?: boolean;
+    market?: MarketRel;
+    order_amount_promotion_rule?: OrderAmountPromotionRuleRel;
+    sku_list_promotion_rule?: SkuListPromotionRuleRel;
+    coupon_codes_promotion_rule?: CouponCodesPromotionRuleRel;
+    custom_promotion_rule?: CustomPromotionRuleRel;
+    sku_list: SkuListRel;
+    tags?: TagRel[];
+}
+interface BuyXPayYPromotionUpdate extends ResourceUpdate {
+    name?: string;
+    currency_code?: string;
+    exclusive?: boolean;
+    priority?: number;
+    starts_at?: string;
+    expires_at?: string;
+    total_usage_limit?: number;
+    _disable?: boolean;
+    _enable?: boolean;
+    x?: number;
+    y?: number;
+    cheapest_free?: boolean;
+    market?: MarketRel;
+    order_amount_promotion_rule?: OrderAmountPromotionRuleRel;
+    sku_list_promotion_rule?: SkuListPromotionRuleRel;
+    coupon_codes_promotion_rule?: CouponCodesPromotionRuleRel;
+    custom_promotion_rule?: CustomPromotionRuleRel;
+    sku_list?: SkuListRel;
+    tags?: TagRel[];
+}
+declare class BuyXPayYPromotions extends ApiResource {
+    static readonly TYPE: 'buy_x_pay_y_promotions';
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BuyXPayYPromotion>>;
+    create(resource: BuyXPayYPromotionCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BuyXPayYPromotion>;
+    retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BuyXPayYPromotion>;
+    update(resource: BuyXPayYPromotionUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BuyXPayYPromotion>;
+    delete(id: string, options?: ResourcesConfig): Promise<void>;
+    market(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
+    order_amount_promotion_rule(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderAmountPromotionRule>;
+    sku_list_promotion_rule(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SkuListPromotionRule>;
+    coupon_codes_promotion_rule(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CouponCodesPromotionRule>;
+    custom_promotion_rule(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomPromotionRule>;
+    sku_list(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SkuList>;
+    coupons(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Coupon>>;
+    attachments(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    events(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    tags(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    skus(buyXPayYPromotionId: string | BuyXPayYPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Sku>>;
+    isBuyXPayYPromotion(resource: any): resource is BuyXPayYPromotion;
+    relationship(id: string | ResourceId | null): BuyXPayYPromotionRel;
+    type(): string;
+}
+export default BuyXPayYPromotions;
+export { BuyXPayYPromotion, BuyXPayYPromotionCreate, BuyXPayYPromotionUpdate };