@commercelayer/sdk 5.12.5 → 5.13.0

package/lib/cjs/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/cjs/resources/braintree_payments.js

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

package/lib/cjs/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/cjs/resources/bundles.js

@@ -35,6 +35,10 @@ class Bundles extends resource_1.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/cjs/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/cjs/resources/captures.js

@@ -13,6 +13,10 @@ class Captures extends resource_1.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/cjs/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/cjs/resources/carrier_accounts.js

@@ -10,6 +10,10 @@ class CarrierAccounts extends resource_1.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/cjs/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/cjs/resources/checkout_com_gateways.js

@@ -15,6 +15,10 @@ class CheckoutComGateways extends resource_1.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/cjs/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/cjs/resources/checkout_com_payments.js

@@ -19,6 +19,10 @@ class CheckoutComPayments extends resource_1.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/cjs/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/cjs/resources/cleanups.js

@@ -12,6 +12,10 @@ class Cleanups extends resource_1.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/cjs/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/cjs/resources/coupon_codes_promotion_rules.js

@@ -11,6 +11,10 @@ class CouponCodesPromotionRules extends resource_1.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/cjs/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/cjs/resources/coupon_recipients.js

@@ -19,6 +19,10 @@ class CouponRecipients extends resource_1.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/cjs/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/cjs/resources/coupons.js

@@ -27,6 +27,10 @@ class Coupons extends resource_1.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/cjs/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/cjs/resources/customer_addresses.js

@@ -23,6 +23,10 @@ class CustomerAddresses extends resource_1.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/cjs/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/cjs/resources/customer_groups.js

@@ -23,6 +23,10 @@ class CustomerGroups extends resource_1.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);
     }

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

@@ -1,6 +1,6 @@
 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 { Customer, CustomerType } from './customers';
 import type { AdyenPayment, AdyenPaymentType } from './adyen_payments';
 import type { AxervePayment, AxervePaymentType } from './axerve_payments';
@@ -8,10 +8,9 @@ import type { BraintreePayment, BraintreePaymentType } from './braintree_payment
 import type { CheckoutComPayment, CheckoutComPaymentType } from './checkout_com_payments';
 import type { ExternalPayment, ExternalPaymentType } from './external_payments';
 import type { KlarnaPayment, KlarnaPaymentType } from './klarna_payments';
-import type { PaypalPayment, PaypalPaymentType } from './paypal_payments';
 import type { SatispayPayment, SatispayPaymentType } from './satispay_payments';
 import type { StripePayment, StripePaymentType } from './stripe_payments';
-import type { WireTransfer, WireTransferType } from './wire_transfers';
+import type { Version } from './versions';
 type CustomerPaymentSourceType = 'customer_payment_sources';
 type CustomerPaymentSourceRel = ResourceRel & {
     type: CustomerPaymentSourceType;
@@ -37,33 +36,28 @@ type ExternalPaymentRel = ResourceRel & {
 type KlarnaPaymentRel = ResourceRel & {
     type: KlarnaPaymentType;
 };
-type PaypalPaymentRel = ResourceRel & {
-    type: PaypalPaymentType;
-};
 type SatispayPaymentRel = ResourceRel & {
     type: SatispayPaymentType;
 };
 type StripePaymentRel = ResourceRel & {
     type: StripePaymentType;
 };
-type WireTransferRel = ResourceRel & {
-    type: WireTransferType;
-};
 interface CustomerPaymentSource extends Resource {
     readonly type: CustomerPaymentSourceType;
     name?: string | null;
     customer_token?: string | null;
     payment_source_token?: string | null;
     customer?: Customer | null;
-    payment_source?: AdyenPayment | AxervePayment | BraintreePayment | CheckoutComPayment | ExternalPayment | KlarnaPayment | PaypalPayment | SatispayPayment | StripePayment | WireTransfer | null;
+    payment_source?: AdyenPayment | AxervePayment | BraintreePayment | CheckoutComPayment | ExternalPayment | KlarnaPayment | SatispayPayment | StripePayment | null;
+    versions?: Version[] | null;
 }
 interface CustomerPaymentSourceCreate extends ResourceCreate {
     customer: CustomerRel;
-    payment_source: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | PaypalPaymentRel | SatispayPaymentRel | StripePaymentRel | WireTransferRel;
+    payment_source: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | SatispayPaymentRel | StripePaymentRel;
 }
 interface CustomerPaymentSourceUpdate extends ResourceUpdate {
     customer?: CustomerRel | null;
-    payment_source?: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | PaypalPaymentRel | SatispayPaymentRel | StripePaymentRel | WireTransferRel | null;
+    payment_source?: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | SatispayPaymentRel | StripePaymentRel | null;
 }
 declare class CustomerPaymentSources extends ApiResource<CustomerPaymentSource> {
     static readonly TYPE: CustomerPaymentSourceType;
@@ -71,6 +65,7 @@ declare class CustomerPaymentSources extends ApiResource<CustomerPaymentSource>
     update(resource: CustomerPaymentSourceUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerPaymentSource>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     customer(customerPaymentSourceId: string | CustomerPaymentSource, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    versions(customerPaymentSourceId: string | CustomerPaymentSource, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCustomerPaymentSource(resource: any): resource is CustomerPaymentSource;
     relationship(id: string | ResourceId | null): CustomerPaymentSourceRel;
     type(): CustomerPaymentSourceType;

package/lib/cjs/resources/customer_payment_sources.js

@@ -15,6 +15,10 @@ class CustomerPaymentSources extends resource_1.ApiResource {
         const _customerPaymentSourceId = customerPaymentSourceId.id || customerPaymentSourceId;
         return this.resources.fetch({ type: 'customers' }, `customer_payment_sources/${_customerPaymentSourceId}/customer`, params, options);
     }
+    async versions(customerPaymentSourceId, params, options) {
+        const _customerPaymentSourceId = customerPaymentSourceId.id || customerPaymentSourceId;
+        return this.resources.fetch({ type: 'versions' }, `customer_payment_sources/${_customerPaymentSourceId}/versions`, params, options);
+    }
     isCustomerPaymentSource(resource) {
         return resource.type && (resource.type === CustomerPaymentSources.TYPE);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Customer } from './customers';
 import type { Event } from './events';
+import type { Version } from './versions';
 type CustomerSubscriptionType = 'customer_subscriptions';
 type CustomerSubscriptionRel = ResourceRel & {
     type: CustomerSubscriptionType;
@@ -12,6 +13,7 @@ interface CustomerSubscription extends Resource {
     customer_email: string;
     customer?: Customer | null;
     events?: Event[] | null;
+    versions?: Version[] | null;
 }
 interface CustomerSubscriptionCreate extends ResourceCreate {
     customer_email: string;
@@ -24,6 +26,7 @@ declare class CustomerSubscriptions extends ApiResource<CustomerSubscription> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     customer(customerSubscriptionId: string | CustomerSubscription, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
     events(customerSubscriptionId: string | CustomerSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(customerSubscriptionId: string | CustomerSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isCustomerSubscription(resource: any): resource is CustomerSubscription;
     relationship(id: string | ResourceId | null): CustomerSubscriptionRel;
     type(): CustomerSubscriptionType;

package/lib/cjs/resources/customer_subscriptions.js

@@ -19,6 +19,10 @@ class CustomerSubscriptions extends resource_1.ApiResource {
         const _customerSubscriptionId = customerSubscriptionId.id || customerSubscriptionId;
         return this.resources.fetch({ type: 'events' }, `customer_subscriptions/${_customerSubscriptionId}/events`, params, options);
     }
+    async versions(customerSubscriptionId, params, options) {
+        const _customerSubscriptionId = customerSubscriptionId.id || customerSubscriptionId;
+        return this.resources.fetch({ type: 'versions' }, `customer_subscriptions/${_customerSubscriptionId}/versions`, params, options);
+    }
     isCustomerSubscription(resource) {
         return resource.type && (resource.type === CustomerSubscriptions.TYPE);
     }

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

@@ -4,6 +4,7 @@ import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { StockLocation, StockLocationType } from './stock_locations';
 import type { ShippingMethod, ShippingMethodType } from './shipping_methods';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type DeliveryLeadTimeType = 'delivery_lead_times';
 type DeliveryLeadTimeRel = ResourceRel & {
     type: DeliveryLeadTimeType;
@@ -23,6 +24,7 @@ interface DeliveryLeadTime extends Resource {
     stock_location?: StockLocation | null;
     shipping_method?: ShippingMethod | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface DeliveryLeadTimeCreate extends ResourceCreate {
     min_hours: number;
@@ -44,6 +46,7 @@ declare class DeliveryLeadTimes extends ApiResource<DeliveryLeadTime> {
     stock_location(deliveryLeadTimeId: string | DeliveryLeadTime, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StockLocation>;
     shipping_method(deliveryLeadTimeId: string | DeliveryLeadTime, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ShippingMethod>;
     attachments(deliveryLeadTimeId: string | DeliveryLeadTime, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(deliveryLeadTimeId: string | DeliveryLeadTime, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isDeliveryLeadTime(resource: any): resource is DeliveryLeadTime;
     relationship(id: string | ResourceId | null): DeliveryLeadTimeRel;
     type(): DeliveryLeadTimeType;

package/lib/cjs/resources/delivery_lead_times.js

@@ -23,6 +23,10 @@ class DeliveryLeadTimes extends resource_1.ApiResource {
         const _deliveryLeadTimeId = deliveryLeadTimeId.id || deliveryLeadTimeId;
         return this.resources.fetch({ type: 'attachments' }, `delivery_lead_times/${_deliveryLeadTimeId}/attachments`, params, options);
     }
+    async versions(deliveryLeadTimeId, params, options) {
+        const _deliveryLeadTimeId = deliveryLeadTimeId.id || deliveryLeadTimeId;
+        return this.resources.fetch({ type: 'versions' }, `delivery_lead_times/${_deliveryLeadTimeId}/versions`, params, options);
+    }
     isDeliveryLeadTime(resource) {
         return resource.type && (resource.type === DeliveryLeadTimes.TYPE);
     }

package/lib/cjs/resources/external_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 { ExternalPayment } from './external_payments';
 type ExternalGatewayType = 'external_gateways';
 type ExternalGatewayRel = ResourceRel & {
@@ -17,6 +18,7 @@ interface ExternalGateway extends Resource {
     refund_url?: string | null;
     token_url?: string | null;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
     external_payments?: ExternalPayment[] | null;
 }
 interface ExternalGatewayCreate extends ResourceCreate {
@@ -41,6 +43,7 @@ declare class ExternalGateways extends ApiResource<ExternalGateway> {
     update(resource: ExternalGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ExternalGateway>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     payment_methods(externalGatewayId: string | ExternalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(externalGatewayId: string | ExternalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     external_payments(externalGatewayId: string | ExternalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ExternalPayment>>;
     isExternalGateway(resource: any): resource is ExternalGateway;
     relationship(id: string | ResourceId | null): ExternalGatewayRel;