@commercelayer/sdk 5.12.4 → 5.13.0

package/lib/esm/resources/avalara_accounts.js

@@ -17,6 +17,10 @@ class AvalaraAccounts extends 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/esm/resources/axerve_gateways.d.ts

@@ -2,6 +2,7 @@ import { ApiResource } from '../resource';
 import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { AxervePayment, AxervePaymentType } from './axerve_payments';
 type AxerveGatewayType = 'axerve_gateways';
 type AxerveGatewayRel = ResourceRel & {
@@ -14,7 +15,9 @@ interface AxerveGateway extends Resource {
     readonly type: AxerveGatewayType;
     name: string;
     login: string;
+    webhook_endpoint_url?: string | null;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
     axerve_payments?: AxervePayment[] | null;
 }
 interface AxerveGatewayCreate extends ResourceCreate {
@@ -35,6 +38,7 @@ declare class AxerveGateways extends ApiResource<AxerveGateway> {
     update(resource: AxerveGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxerveGateway>;
     delete(id: string | ResourceId, 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/esm/resources/axerve_gateways.js

@@ -13,6 +13,10 @@ class AxerveGateways extends 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/esm/resources/axerve_payments.d.ts

@@ -1,8 +1,9 @@
 import { ApiResource } from '../resource';
-import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
-import type { QueryParamsRetrieve } from '../query';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Order, OrderType } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type AxervePaymentType = 'axerve_payments';
 type AxervePaymentRel = ResourceRel & {
     type: AxervePaymentType;
@@ -22,6 +23,7 @@ interface AxervePayment extends Resource {
     payment_instrument?: Record<string, any> | null;
     order?: Order | null;
     payment_gateway?: PaymentGateway | null;
+    versions?: Version[] | null;
 }
 interface AxervePaymentCreate extends ResourceCreate {
     return_url: string;
@@ -39,6 +41,7 @@ declare class AxervePayments extends ApiResource<AxervePayment> {
     delete(id: string | ResourceId, 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>>;
     _update(id: string | AxervePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxervePayment>;
     isAxervePayment(resource: any): resource is AxervePayment;
     relationship(id: string | ResourceId | null): AxervePaymentRel;

package/lib/esm/resources/axerve_payments.js

@@ -17,6 +17,10 @@ class AxervePayments extends 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);
+    }
     async _update(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: AxervePayments.TYPE, _update: true }, params, options);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Market, MarketType } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type BillingInfoValidationRuleType = 'billing_info_validation_rules';
 type BillingInfoValidationRuleRel = ResourceRel & {
     type: BillingInfoValidationRuleType;
@@ -14,6 +15,7 @@ interface BillingInfoValidationRule extends Resource {
     readonly type: BillingInfoValidationRuleType;
     market?: Market | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface BillingInfoValidationRuleCreate extends ResourceCreate {
     market: MarketRel;
@@ -28,6 +30,7 @@ declare class BillingInfoValidationRules extends ApiResource<BillingInfoValidati
     delete(id: string | ResourceId, 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(): BillingInfoValidationRuleType;

package/lib/esm/resources/billing_info_validation_rules.js

@@ -17,6 +17,10 @@ class BillingInfoValidationRules extends 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);
+    }
     isBillingInfoValidationRule(resource) {
         return resource.type && (resource.type === BillingInfoValidationRules.TYPE);
     }

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

@@ -2,6 +2,7 @@ import { ApiResource } from '../resource';
 import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { BraintreePayment, BraintreePaymentType } from './braintree_payments';
 type BraintreeGatewayType = 'braintree_gateways';
 type BraintreeGatewayRel = ResourceRel & {
@@ -18,6 +19,7 @@ interface BraintreeGateway extends Resource {
     descriptor_url?: string | null;
     webhook_endpoint_url?: string | null;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
     braintree_payments?: BraintreePayment[] | null;
 }
 interface BraintreeGatewayCreate extends ResourceCreate {
@@ -48,6 +50,7 @@ declare class BraintreeGateways extends ApiResource<BraintreeGateway> {
     update(resource: BraintreeGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreeGateway>;
     delete(id: string | ResourceId, 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/esm/resources/braintree_gateways.js

@@ -13,6 +13,10 @@ class BraintreeGateways extends 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/esm/resources/braintree_payments.d.ts

@@ -1,8 +1,9 @@
 import { ApiResource } from '../resource';
-import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
-import type { QueryParamsRetrieve } from '../query';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Order, OrderType } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type BraintreePaymentType = 'braintree_payments';
 type BraintreePaymentRel = ResourceRel & {
     type: BraintreePaymentType;
@@ -20,6 +21,7 @@ interface BraintreePayment extends Resource {
     payment_instrument?: Record<string, any> | null;
     order?: Order | null;
     payment_gateway?: PaymentGateway | null;
+    versions?: Version[] | null;
 }
 interface BraintreePaymentCreate extends ResourceCreate {
     payment_id?: string | null;
@@ -41,6 +43,7 @@ declare class BraintreePayments extends ApiResource<BraintreePayment> {
     delete(id: string | ResourceId, 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(): BraintreePaymentType;

package/lib/esm/resources/braintree_payments.js

@@ -17,6 +17,10 @@ class BraintreePayments extends 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);
+    }
     isBraintreePayment(resource) {
         return resource.type && (resource.type === BraintreePayments.TYPE);
     }

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

@@ -7,6 +7,7 @@ import type { Sku } from './skus';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
 import type { Tag, TagType } from './tags';
+import type { Version } from './versions';
 type BundleType = 'bundles';
 type BundleRel = ResourceRel & {
     type: BundleType;
@@ -42,6 +43,7 @@ interface Bundle extends Resource {
     attachments?: Attachment[] | null;
     events?: Event[] | null;
     tags?: Tag[] | null;
+    versions?: Version[] | null;
 }
 interface BundleCreate extends ResourceCreate {
     code: string;
@@ -80,6 +82,7 @@ declare class Bundles extends ApiResource<Bundle> {
     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>>;
     _compute_price_amount(id: string | Bundle, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Bundle>;
     _compute_compare_at_amount(id: string | Bundle, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Bundle>;
     isBundle(resource: any): resource is Bundle;

package/lib/esm/resources/bundles.js

@@ -33,6 +33,10 @@ class Bundles extends ApiResource {
         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);
+    }
     async _compute_price_amount(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: Bundles.TYPE, _compute_price_amount: true }, params, options);
     }

package/lib/esm/resources/captures.d.ts

@@ -3,6 +3,7 @@ import type { Resource, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Order } from './orders';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { Authorization } from './authorizations';
 import type { Refund } from './refunds';
 import type { Event } from './events';
@@ -31,6 +32,7 @@ interface Capture extends Resource {
     formatted_refund_balance?: string | null;
     order?: Order | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
     reference_authorization?: Authorization | null;
     refunds?: Refund[] | null;
     events?: Event[] | null;
@@ -44,6 +46,7 @@ declare class Captures extends ApiResource<Capture> {
     update(resource: CaptureUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Capture>;
     order(captureId: string | Capture, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     attachments(captureId: string | Capture, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(captureId: string | Capture, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     reference_authorization(captureId: string | Capture, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Authorization>;
     refunds(captureId: string | Capture, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Refund>>;
     events(captureId: string | Capture, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;

package/lib/esm/resources/captures.js

@@ -11,6 +11,10 @@ class Captures extends ApiResource {
         const _captureId = captureId.id || captureId;
         return this.resources.fetch({ type: 'attachments' }, `captures/${_captureId}/attachments`, params, options);
     }
+    async versions(captureId, params, options) {
+        const _captureId = captureId.id || captureId;
+        return this.resources.fetch({ type: 'versions' }, `captures/${_captureId}/versions`, params, options);
+    }
     async reference_authorization(captureId, params, options) {
         const _captureId = captureId.id || captureId;
         return this.resources.fetch({ type: 'authorizations' }, `captures/${_captureId}/reference_authorization`, params, options);

package/lib/esm/resources/carrier_accounts.d.ts

@@ -3,6 +3,7 @@ import type { Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse }
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type CarrierAccountType = 'carrier_accounts';
 type CarrierAccountRel = ResourceRel & {
     type: CarrierAccountType;
@@ -14,11 +15,13 @@ interface CarrierAccount extends Resource {
     easypost_id?: string | null;
     market?: Market | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 declare class CarrierAccounts extends ApiResource<CarrierAccount> {
     static readonly TYPE: CarrierAccountType;
     market(carrierAccountId: string | CarrierAccount, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     attachments(carrierAccountId: string | CarrierAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(carrierAccountId: string | CarrierAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCarrierAccount(resource: any): resource is CarrierAccount;
     relationship(id: string | ResourceId | null): CarrierAccountRel;
     type(): CarrierAccountType;

package/lib/esm/resources/carrier_accounts.js

@@ -8,6 +8,10 @@ class CarrierAccounts extends ApiResource {
         const _carrierAccountId = carrierAccountId.id || carrierAccountId;
         return this.resources.fetch({ type: 'attachments' }, `carrier_accounts/${_carrierAccountId}/attachments`, params, options);
     }
+    async versions(carrierAccountId, params, options) {
+        const _carrierAccountId = carrierAccountId.id || carrierAccountId;
+        return this.resources.fetch({ type: 'versions' }, `carrier_accounts/${_carrierAccountId}/versions`, params, options);
+    }
     isCarrierAccount(resource) {
         return resource.type && (resource.type === CarrierAccounts.TYPE);
     }

package/lib/esm/resources/checkout_com_gateways.d.ts

@@ -2,6 +2,7 @@ import { ApiResource } from '../resource';
 import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { CheckoutComPayment, CheckoutComPaymentType } from './checkout_com_payments';
 type CheckoutComGatewayType = 'checkout_com_gateways';
 type CheckoutComGatewayRel = ResourceRel & {
@@ -17,6 +18,7 @@ interface CheckoutComGateway extends Resource {
     webhook_endpoint_secret?: string | null;
     webhook_endpoint_url?: string | null;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
     checkout_com_payments?: CheckoutComPayment[] | null;
 }
 interface CheckoutComGatewayCreate extends ResourceCreate {
@@ -37,6 +39,7 @@ declare class CheckoutComGateways extends ApiResource<CheckoutComGateway> {
     update(resource: CheckoutComGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CheckoutComGateway>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     payment_methods(checkoutComGatewayId: string | CheckoutComGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(checkoutComGatewayId: string | CheckoutComGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     checkout_com_payments(checkoutComGatewayId: string | CheckoutComGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CheckoutComPayment>>;
     isCheckoutComGateway(resource: any): resource is CheckoutComGateway;
     relationship(id: string | ResourceId | null): CheckoutComGatewayRel;

package/lib/esm/resources/checkout_com_gateways.js

@@ -13,6 +13,10 @@ class CheckoutComGateways extends ApiResource {
         const _checkoutComGatewayId = checkoutComGatewayId.id || checkoutComGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `checkout_com_gateways/${_checkoutComGatewayId}/payment_methods`, params, options);
     }
+    async versions(checkoutComGatewayId, params, options) {
+        const _checkoutComGatewayId = checkoutComGatewayId.id || checkoutComGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `checkout_com_gateways/${_checkoutComGatewayId}/versions`, params, options);
+    }
     async checkout_com_payments(checkoutComGatewayId, params, options) {
         const _checkoutComGatewayId = checkoutComGatewayId.id || checkoutComGatewayId;
         return this.resources.fetch({ type: 'checkout_com_payments' }, `checkout_com_gateways/${_checkoutComGatewayId}/checkout_com_payments`, params, options);

package/lib/esm/resources/checkout_com_payments.d.ts

@@ -1,8 +1,9 @@
 import { ApiResource } from '../resource';
-import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
-import type { QueryParamsRetrieve } from '../query';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Order, OrderType } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type CheckoutComPaymentType = 'checkout_com_payments';
 type CheckoutComPaymentRel = ResourceRel & {
     type: CheckoutComPaymentType;
@@ -26,6 +27,7 @@ interface CheckoutComPayment extends Resource {
     payment_instrument?: Record<string, any> | null;
     order?: Order | null;
     payment_gateway?: PaymentGateway | null;
+    versions?: Version[] | null;
 }
 interface CheckoutComPaymentCreate extends ResourceCreate {
     payment_type: string;
@@ -52,6 +54,7 @@ declare class CheckoutComPayments extends ApiResource<CheckoutComPayment> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     order(checkoutComPaymentId: string | CheckoutComPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(checkoutComPaymentId: string | CheckoutComPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(checkoutComPaymentId: string | CheckoutComPayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _details(id: string | CheckoutComPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CheckoutComPayment>;
     _refresh(id: string | CheckoutComPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CheckoutComPayment>;
     isCheckoutComPayment(resource: any): resource is CheckoutComPayment;

package/lib/esm/resources/checkout_com_payments.js

@@ -17,6 +17,10 @@ class CheckoutComPayments extends ApiResource {
         const _checkoutComPaymentId = checkoutComPaymentId.id || checkoutComPaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `checkout_com_payments/${_checkoutComPaymentId}/payment_gateway`, params, options);
     }
+    async versions(checkoutComPaymentId, params, options) {
+        const _checkoutComPaymentId = checkoutComPaymentId.id || checkoutComPaymentId;
+        return this.resources.fetch({ type: 'versions' }, `checkout_com_payments/${_checkoutComPaymentId}/versions`, params, options);
+    }
     async _details(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: CheckoutComPayments.TYPE, _details: true }, params, options);
     }

package/lib/esm/resources/cleanups.d.ts

@@ -2,6 +2,7 @@ import { ApiResource } from '../resource';
 import type { Resource, ResourceCreate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Event } from './events';
+import type { Version } from './versions';
 type CleanupType = 'cleanups';
 type CleanupRel = ResourceRel & {
     type: CleanupType;
@@ -19,6 +20,7 @@ interface Cleanup extends Resource {
     processed_count?: number | null;
     errors_log?: Record<string, any> | null;
     events?: Event[] | null;
+    versions?: Version[] | null;
 }
 interface CleanupCreate extends ResourceCreate {
     resource_type: string;
@@ -29,6 +31,7 @@ declare class Cleanups extends ApiResource<Cleanup> {
     create(resource: CleanupCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Cleanup>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     events(cleanupId: string | Cleanup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(cleanupId: string | Cleanup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCleanup(resource: any): resource is Cleanup;
     relationship(id: string | ResourceId | null): CleanupRel;
     type(): CleanupType;

package/lib/esm/resources/cleanups.js

@@ -10,6 +10,10 @@ class Cleanups extends ApiResource {
         const _cleanupId = cleanupId.id || cleanupId;
         return this.resources.fetch({ type: 'events' }, `cleanups/${_cleanupId}/events`, params, options);
     }
+    async versions(cleanupId, params, options) {
+        const _cleanupId = cleanupId.id || cleanupId;
+        return this.resources.fetch({ type: 'versions' }, `cleanups/${_cleanupId}/versions`, params, options);
+    }
     isCleanup(resource) {
         return resource.type && (resource.type === Cleanups.TYPE);
     }

package/lib/esm/resources/coupon_codes_promotion_rules.d.ts

@@ -7,6 +7,7 @@ import type { FreeGiftPromotion, FreeGiftPromotionType } from './free_gift_promo
 import type { FixedPricePromotion, FixedPricePromotionType } from './fixed_price_promotions';
 import type { ExternalPromotion, ExternalPromotionType } from './external_promotions';
 import type { FixedAmountPromotion, FixedAmountPromotionType } from './fixed_amount_promotions';
+import type { Version } from './versions';
 import type { Coupon, CouponType } from './coupons';
 type CouponCodesPromotionRuleType = 'coupon_codes_promotion_rules';
 type CouponCodesPromotionRuleRel = ResourceRel & {
@@ -36,6 +37,7 @@ type CouponRel = ResourceRel & {
 interface CouponCodesPromotionRule extends Resource {
     readonly type: CouponCodesPromotionRuleType;
     promotion?: PercentageDiscountPromotion | FreeShippingPromotion | FreeGiftPromotion | FixedPricePromotion | ExternalPromotion | FixedAmountPromotion | null;
+    versions?: Version[] | null;
     coupons?: Coupon[] | null;
 }
 interface CouponCodesPromotionRuleCreate extends ResourceCreate {
@@ -51,6 +53,7 @@ declare class CouponCodesPromotionRules extends ApiResource<CouponCodesPromotion
     create(resource: CouponCodesPromotionRuleCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CouponCodesPromotionRule>;
     update(resource: CouponCodesPromotionRuleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CouponCodesPromotionRule>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    versions(couponCodesPromotionRuleId: string | CouponCodesPromotionRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     coupons(couponCodesPromotionRuleId: string | CouponCodesPromotionRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Coupon>>;
     isCouponCodesPromotionRule(resource: any): resource is CouponCodesPromotionRule;
     relationship(id: string | ResourceId | null): CouponCodesPromotionRuleRel;

package/lib/esm/resources/coupon_codes_promotion_rules.js

@@ -9,6 +9,10 @@ class CouponCodesPromotionRules extends ApiResource {
     async delete(id, options) {
         await this.resources.delete((typeof id === 'string') ? { id, type: CouponCodesPromotionRules.TYPE } : id, options);
     }
+    async versions(couponCodesPromotionRuleId, params, options) {
+        const _couponCodesPromotionRuleId = couponCodesPromotionRuleId.id || couponCodesPromotionRuleId;
+        return this.resources.fetch({ type: 'versions' }, `coupon_codes_promotion_rules/${_couponCodesPromotionRuleId}/versions`, params, options);
+    }
     async coupons(couponCodesPromotionRuleId, params, options) {
         const _couponCodesPromotionRuleId = couponCodesPromotionRuleId.id || couponCodesPromotionRuleId;
         return this.resources.fetch({ type: 'coupons' }, `coupon_codes_promotion_rules/${_couponCodesPromotionRuleId}/coupons`, params, options);

package/lib/esm/resources/coupon_recipients.d.ts

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Customer, CustomerType } from './customers';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type CouponRecipientType = 'coupon_recipients';
 type CouponRecipientRel = ResourceRel & {
     type: CouponRecipientType;
@@ -17,6 +18,7 @@ interface CouponRecipient extends Resource {
     last_name?: string | null;
     customer?: Customer | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface CouponRecipientCreate extends ResourceCreate {
     email: string;
@@ -37,6 +39,7 @@ declare class CouponRecipients extends ApiResource<CouponRecipient> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     customer(couponRecipientId: string | CouponRecipient, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
     attachments(couponRecipientId: string | CouponRecipient, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(couponRecipientId: string | CouponRecipient, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCouponRecipient(resource: any): resource is CouponRecipient;
     relationship(id: string | ResourceId | null): CouponRecipientRel;
     type(): CouponRecipientType;

package/lib/esm/resources/coupon_recipients.js

@@ -17,6 +17,10 @@ class CouponRecipients extends ApiResource {
         const _couponRecipientId = couponRecipientId.id || couponRecipientId;
         return this.resources.fetch({ type: 'attachments' }, `coupon_recipients/${_couponRecipientId}/attachments`, params, options);
     }
+    async versions(couponRecipientId, params, options) {
+        const _couponRecipientId = couponRecipientId.id || couponRecipientId;
+        return this.resources.fetch({ type: 'versions' }, `coupon_recipients/${_couponRecipientId}/versions`, params, options);
+    }
     isCouponRecipient(resource) {
         return resource.type && (resource.type === CouponRecipients.TYPE);
     }

package/lib/esm/resources/coupons.d.ts

@@ -5,6 +5,7 @@ import type { CouponCodesPromotionRule, CouponCodesPromotionRuleType } from './c
 import type { CouponRecipient, CouponRecipientType } from './coupon_recipients';
 import type { Event } from './events';
 import type { Tag, TagType } from './tags';
+import type { Version } from './versions';
 type CouponType = 'coupons';
 type CouponRel = ResourceRel & {
     type: CouponType;
@@ -29,6 +30,7 @@ interface Coupon extends Resource {
     coupon_recipient?: CouponRecipient | null;
     events?: Event[] | null;
     tags?: Tag[] | null;
+    versions?: Version[] | null;
 }
 interface CouponCreate extends ResourceCreate {
     code: string;
@@ -57,6 +59,7 @@ declare class Coupons extends ApiResource<Coupon> {
     coupon_recipient(couponId: string | Coupon, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CouponRecipient>;
     events(couponId: string | Coupon, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     tags(couponId: string | Coupon, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(couponId: string | Coupon, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCoupon(resource: any): resource is Coupon;
     relationship(id: string | ResourceId | null): CouponRel;
     type(): CouponType;

package/lib/esm/resources/coupons.js

@@ -25,6 +25,10 @@ class Coupons extends ApiResource {
         const _couponId = couponId.id || couponId;
         return this.resources.fetch({ type: 'tags' }, `coupons/${_couponId}/tags`, params, options);
     }
+    async versions(couponId, params, options) {
+        const _couponId = couponId.id || couponId;
+        return this.resources.fetch({ type: 'versions' }, `coupons/${_couponId}/versions`, params, options);
+    }
     isCoupon(resource) {
         return resource.type && (resource.type === Coupons.TYPE);
     }

package/lib/esm/resources/customer_addresses.d.ts

@@ -4,6 +4,7 @@ import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Customer, CustomerType } from './customers';
 import type { Address, AddressType } from './addresses';
 import type { Event } from './events';
+import type { Version } from './versions';
 type CustomerAddressType = 'customer_addresses';
 type CustomerAddressRel = ResourceRel & {
     type: CustomerAddressType;
@@ -21,6 +22,7 @@ interface CustomerAddress extends Resource {
     customer?: Customer | null;
     address?: Address | null;
     events?: Event[] | null;
+    versions?: Version[] | null;
 }
 interface CustomerAddressCreate extends ResourceCreate {
     customer_email: string;
@@ -39,6 +41,7 @@ declare class CustomerAddresses extends ApiResource<CustomerAddress> {
     customer(customerAddressId: string | CustomerAddress, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
     address(customerAddressId: string | CustomerAddress, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Address>;
     events(customerAddressId: string | CustomerAddress, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(customerAddressId: string | CustomerAddress, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCustomerAddress(resource: any): resource is CustomerAddress;
     relationship(id: string | ResourceId | null): CustomerAddressRel;
     type(): CustomerAddressType;

package/lib/esm/resources/customer_addresses.js

@@ -21,6 +21,10 @@ class CustomerAddresses extends ApiResource {
         const _customerAddressId = customerAddressId.id || customerAddressId;
         return this.resources.fetch({ type: 'events' }, `customer_addresses/${_customerAddressId}/events`, params, options);
     }
+    async versions(customerAddressId, params, options) {
+        const _customerAddressId = customerAddressId.id || customerAddressId;
+        return this.resources.fetch({ type: 'versions' }, `customer_addresses/${_customerAddressId}/versions`, params, options);
+    }
     isCustomerAddress(resource) {
         return resource.type && (resource.type === CustomerAddresses.TYPE);
     }

package/lib/esm/resources/customer_groups.d.ts

@@ -4,6 +4,7 @@ import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Customer } from './customers';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type CustomerGroupType = 'customer_groups';
 type CustomerGroupRel = ResourceRel & {
     type: CustomerGroupType;
@@ -14,6 +15,7 @@ interface CustomerGroup extends Resource {
     customers?: Customer[] | null;
     markets?: Market[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface CustomerGroupCreate extends ResourceCreate {
     name: string;
@@ -29,6 +31,7 @@ declare class CustomerGroups extends ApiResource<CustomerGroup> {
     customers(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Customer>>;
     markets(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
     attachments(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCustomerGroup(resource: any): resource is CustomerGroup;
     relationship(id: string | ResourceId | null): CustomerGroupRel;
     type(): CustomerGroupType;

package/lib/esm/resources/customer_groups.js

@@ -21,6 +21,10 @@ class CustomerGroups extends ApiResource {
         const _customerGroupId = customerGroupId.id || customerGroupId;
         return this.resources.fetch({ type: 'attachments' }, `customer_groups/${_customerGroupId}/attachments`, params, options);
     }
+    async versions(customerGroupId, params, options) {
+        const _customerGroupId = customerGroupId.id || customerGroupId;
+        return this.resources.fetch({ type: 'versions' }, `customer_groups/${_customerGroupId}/versions`, params, options);
+    }
     isCustomerGroup(resource) {
         return resource.type && (resource.type === CustomerGroups.TYPE);
     }