@commercelayer/sdk 5.12.5 → 5.13.0

package/lib/esm/resources/parcels.js

@@ -29,6 +29,10 @@ class Parcels extends ApiResource {
         const _parcelId = parcelId.id || parcelId;
         return this.resources.fetch({ type: 'events' }, `parcels/${_parcelId}/events`, params, options);
     }
+    async versions(parcelId, params, options) {
+        const _parcelId = parcelId.id || parcelId;
+        return this.resources.fetch({ type: 'versions' }, `parcels/${_parcelId}/versions`, params, options);
+    }
     isParcel(resource) {
         return resource.type && (resource.type === Parcels.TYPE);
     }

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

@@ -2,6 +2,7 @@ import { ApiResource } from '../resource';
 import type { Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 type PaymentGatewayType = 'payment_gateways';
 type PaymentGatewayRel = ResourceRel & {
     type: PaymentGatewayType;
@@ -10,10 +11,12 @@ interface PaymentGateway extends Resource {
     readonly type: PaymentGatewayType;
     name: string;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
 }
 declare class PaymentGateways extends ApiResource<PaymentGateway> {
     static readonly TYPE: PaymentGatewayType;
     payment_methods(paymentGatewayId: string | PaymentGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(paymentGatewayId: string | PaymentGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPaymentGateway(resource: any): resource is PaymentGateway;
     relationship(id: string | ResourceId | null): PaymentGatewayRel;
     type(): PaymentGatewayType;

package/lib/esm/resources/payment_gateways.js

@@ -4,6 +4,10 @@ class PaymentGateways extends ApiResource {
         const _paymentGatewayId = paymentGatewayId.id || paymentGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `payment_gateways/${_paymentGatewayId}/payment_methods`, params, options);
     }
+    async versions(paymentGatewayId, params, options) {
+        const _paymentGatewayId = paymentGatewayId.id || paymentGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `payment_gateways/${_paymentGatewayId}/versions`, params, options);
+    }
     isPaymentGateway(resource) {
         return resource.type && (resource.type === PaymentGateways.TYPE);
     }

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

@@ -4,6 +4,7 @@ import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Market, MarketType } from './markets';
 import type { PaymentGateway, PaymentGatewayType } from './payment_gateways';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PaymentMethodType = 'payment_methods';
 type PaymentMethodRel = ResourceRel & {
     type: PaymentMethodType;
@@ -32,6 +33,7 @@ interface PaymentMethod extends Resource {
     market?: Market | null;
     payment_gateway?: PaymentGateway | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface PaymentMethodCreate extends ResourceCreate {
     payment_source_type: string;
@@ -65,6 +67,7 @@ declare class PaymentMethods extends ApiResource<PaymentMethod> {
     market(paymentMethodId: string | PaymentMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     payment_gateway(paymentMethodId: string | PaymentMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
     attachments(paymentMethodId: string | PaymentMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(paymentMethodId: string | PaymentMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _disable(id: string | PaymentMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentMethod>;
     _enable(id: string | PaymentMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentMethod>;
     isPaymentMethod(resource: any): resource is PaymentMethod;

package/lib/esm/resources/payment_methods.js

@@ -21,6 +21,10 @@ class PaymentMethods extends ApiResource {
         const _paymentMethodId = paymentMethodId.id || paymentMethodId;
         return this.resources.fetch({ type: 'attachments' }, `payment_methods/${_paymentMethodId}/attachments`, params, options);
     }
+    async versions(paymentMethodId, params, options) {
+        const _paymentMethodId = paymentMethodId.id || paymentMethodId;
+        return this.resources.fetch({ type: 'versions' }, `payment_methods/${_paymentMethodId}/versions`, params, options);
+    }
     async _disable(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: PaymentMethods.TYPE, _disable: true }, params, options);
     }

package/lib/esm/resources/paypal_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 { PaypalPayment } from './paypal_payments';
 type PaypalGatewayType = 'paypal_gateways';
 type PaypalGatewayRel = ResourceRel & {
@@ -11,6 +12,7 @@ interface PaypalGateway extends Resource {
     readonly type: PaypalGatewayType;
     name: string;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
     paypal_payments?: PaypalPayment[] | null;
 }
 interface PaypalGatewayCreate extends ResourceCreate {
@@ -29,6 +31,7 @@ declare class PaypalGateways extends ApiResource<PaypalGateway> {
     update(resource: PaypalGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaypalGateway>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     payment_methods(paypalGatewayId: string | PaypalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(paypalGatewayId: string | PaypalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     paypal_payments(paypalGatewayId: string | PaypalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaypalPayment>>;
     isPaypalGateway(resource: any): resource is PaypalGateway;
     relationship(id: string | ResourceId | null): PaypalGatewayRel;

package/lib/esm/resources/paypal_gateways.js

@@ -13,6 +13,10 @@ class PaypalGateways extends ApiResource {
         const _paypalGatewayId = paypalGatewayId.id || paypalGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `paypal_gateways/${_paypalGatewayId}/payment_methods`, params, options);
     }
+    async versions(paypalGatewayId, params, options) {
+        const _paypalGatewayId = paypalGatewayId.id || paypalGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `paypal_gateways/${_paypalGatewayId}/versions`, params, options);
+    }
     async paypal_payments(paypalGatewayId, params, options) {
         const _paypalGatewayId = paypalGatewayId.id || paypalGatewayId;
         return this.resources.fetch({ type: 'paypal_payments' }, `paypal_gateways/${_paypalGatewayId}/paypal_payments`, params, options);

package/lib/esm/resources/paypal_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 PaypalPaymentType = 'paypal_payments';
 type PaypalPaymentRel = ResourceRel & {
     type: PaypalPaymentType;
@@ -27,6 +28,7 @@ interface PaypalPayment extends Resource {
     payment_instrument?: Record<string, any> | null;
     order?: Order | null;
     payment_gateway?: PaymentGateway | null;
+    versions?: Version[] | null;
 }
 interface PaypalPaymentCreate extends ResourceCreate {
     return_url: string;
@@ -45,6 +47,7 @@ declare class PaypalPayments extends ApiResource<PaypalPayment> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     order(paypalPaymentId: string | PaypalPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(paypalPaymentId: string | PaypalPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(paypalPaymentId: string | PaypalPayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPaypalPayment(resource: any): resource is PaypalPayment;
     relationship(id: string | ResourceId | null): PaypalPaymentRel;
     type(): PaypalPaymentType;

package/lib/esm/resources/paypal_payments.js

@@ -17,6 +17,10 @@ class PaypalPayments extends ApiResource {
         const _paypalPaymentId = paypalPaymentId.id || paypalPaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `paypal_payments/${_paypalPaymentId}/payment_gateway`, params, options);
     }
+    async versions(paypalPaymentId, params, options) {
+        const _paypalPaymentId = paypalPaymentId.id || paypalPaymentId;
+        return this.resources.fetch({ type: 'versions' }, `paypal_payments/${_paypalPaymentId}/versions`, params, options);
+    }
     isPaypalPayment(resource) {
         return resource.type && (resource.type === PaypalPayments.TYPE);
     }

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

@@ -10,6 +10,7 @@ import type { SkuList, SkuListType } from './sku_lists';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
 import type { Tag, TagType } from './tags';
+import type { Version } from './versions';
 import type { Sku } from './skus';
 type PercentageDiscountPromotionType = 'percentage_discount_promotions';
 type PercentageDiscountPromotionRel = ResourceRel & {
@@ -55,6 +56,7 @@ interface PercentageDiscountPromotion extends Resource {
     attachments?: Attachment[] | null;
     events?: Event[] | null;
     tags?: Tag[] | null;
+    versions?: Version[] | null;
     skus?: Sku[] | null;
 }
 interface PercentageDiscountPromotionCreate extends ResourceCreate {
@@ -100,6 +102,7 @@ declare class PercentageDiscountPromotions extends ApiResource<PercentageDiscoun
     attachments(percentageDiscountPromotionId: string | PercentageDiscountPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(percentageDiscountPromotionId: string | PercentageDiscountPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     tags(percentageDiscountPromotionId: string | PercentageDiscountPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(percentageDiscountPromotionId: string | PercentageDiscountPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     skus(percentageDiscountPromotionId: string | PercentageDiscountPromotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Sku>>;
     isPercentageDiscountPromotion(resource: any): resource is PercentageDiscountPromotion;
     relationship(id: string | ResourceId | null): PercentageDiscountPromotionRel;

package/lib/esm/resources/percentage_discount_promotions.js

@@ -41,6 +41,10 @@ class PercentageDiscountPromotions extends ApiResource {
         const _percentageDiscountPromotionId = percentageDiscountPromotionId.id || percentageDiscountPromotionId;
         return this.resources.fetch({ type: 'tags' }, `percentage_discount_promotions/${_percentageDiscountPromotionId}/tags`, params, options);
     }
+    async versions(percentageDiscountPromotionId, params, options) {
+        const _percentageDiscountPromotionId = percentageDiscountPromotionId.id || percentageDiscountPromotionId;
+        return this.resources.fetch({ type: 'versions' }, `percentage_discount_promotions/${_percentageDiscountPromotionId}/versions`, params, options);
+    }
     async skus(percentageDiscountPromotionId, params, options) {
         const _percentageDiscountPromotionId = percentageDiscountPromotionId.id || percentageDiscountPromotionId;
         return this.resources.fetch({ type: 'skus' }, `percentage_discount_promotions/${_percentageDiscountPromotionId}/skus`, params, options);

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Price, PriceType } from './prices';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { Event } from './events';
 type PriceFrequencyTierType = 'price_frequency_tiers';
 type PriceFrequencyTierRel = ResourceRel & {
@@ -20,6 +21,7 @@ interface PriceFrequencyTier extends Resource {
     formatted_price_amount?: string | null;
     price?: Price | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
     events?: Event[] | null;
 }
 interface PriceFrequencyTierCreate extends ResourceCreate {
@@ -41,6 +43,7 @@ declare class PriceFrequencyTiers extends ApiResource<PriceFrequencyTier> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     price(priceFrequencyTierId: string | PriceFrequencyTier, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Price>;
     attachments(priceFrequencyTierId: string | PriceFrequencyTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(priceFrequencyTierId: string | PriceFrequencyTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     events(priceFrequencyTierId: string | PriceFrequencyTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     isPriceFrequencyTier(resource: any): resource is PriceFrequencyTier;
     relationship(id: string | ResourceId | null): PriceFrequencyTierRel;

package/lib/esm/resources/price_frequency_tiers.js

@@ -17,6 +17,10 @@ class PriceFrequencyTiers extends ApiResource {
         const _priceFrequencyTierId = priceFrequencyTierId.id || priceFrequencyTierId;
         return this.resources.fetch({ type: 'attachments' }, `price_frequency_tiers/${_priceFrequencyTierId}/attachments`, params, options);
     }
+    async versions(priceFrequencyTierId, params, options) {
+        const _priceFrequencyTierId = priceFrequencyTierId.id || priceFrequencyTierId;
+        return this.resources.fetch({ type: 'versions' }, `price_frequency_tiers/${_priceFrequencyTierId}/versions`, params, options);
+    }
     async events(priceFrequencyTierId, params, options) {
         const _priceFrequencyTierId = priceFrequencyTierId.id || priceFrequencyTierId;
         return this.resources.fetch({ type: 'events' }, `price_frequency_tiers/${_priceFrequencyTierId}/events`, params, options);

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Price } from './prices';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PriceListType = 'price_lists';
 type PriceListRel = ResourceRel & {
     type: PriceListType;
@@ -14,6 +15,7 @@ interface PriceList extends Resource {
     tax_included?: boolean | null;
     prices?: Price[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface PriceListCreate extends ResourceCreate {
     name: string;
@@ -32,6 +34,7 @@ declare class PriceLists extends ApiResource<PriceList> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     prices(priceListId: string | PriceList, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Price>>;
     attachments(priceListId: string | PriceList, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(priceListId: string | PriceList, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPriceList(resource: any): resource is PriceList;
     relationship(id: string | ResourceId | null): PriceListRel;
     type(): PriceListType;

package/lib/esm/resources/price_lists.js

@@ -17,6 +17,10 @@ class PriceLists extends ApiResource {
         const _priceListId = priceListId.id || priceListId;
         return this.resources.fetch({ type: 'attachments' }, `price_lists/${_priceListId}/attachments`, params, options);
     }
+    async versions(priceListId, params, options) {
+        const _priceListId = priceListId.id || priceListId;
+        return this.resources.fetch({ type: 'versions' }, `price_lists/${_priceListId}/versions`, params, options);
+    }
     isPriceList(resource) {
         return resource.type && (resource.type === PriceLists.TYPE);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse }
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Price } from './prices';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PriceTierType = 'price_tiers';
 type PriceTierRel = ResourceRel & {
     type: PriceTierType;
@@ -16,11 +17,13 @@ interface PriceTier extends Resource {
     formatted_price_amount?: string | null;
     price?: Price | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 declare class PriceTiers extends ApiResource<PriceTier> {
     static readonly TYPE: PriceTierType;
     price(priceTierId: string | PriceTier, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Price>;
     attachments(priceTierId: string | PriceTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(priceTierId: string | PriceTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPriceTier(resource: any): resource is PriceTier;
     relationship(id: string | ResourceId | null): PriceTierRel;
     type(): PriceTierType;

package/lib/esm/resources/price_tiers.js

@@ -8,6 +8,10 @@ class PriceTiers extends ApiResource {
         const _priceTierId = priceTierId.id || priceTierId;
         return this.resources.fetch({ type: 'attachments' }, `price_tiers/${_priceTierId}/attachments`, params, options);
     }
+    async versions(priceTierId, params, options) {
+        const _priceTierId = priceTierId.id || priceTierId;
+        return this.resources.fetch({ type: 'versions' }, `price_tiers/${_priceTierId}/versions`, params, options);
+    }
     isPriceTier(resource) {
         return resource.type && (resource.type === PriceTiers.TYPE);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Price, PriceType } from './prices';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { Event } from './events';
 type PriceVolumeTierType = 'price_volume_tiers';
 type PriceVolumeTierRel = ResourceRel & {
@@ -20,6 +21,7 @@ interface PriceVolumeTier extends Resource {
     formatted_price_amount?: string | null;
     price?: Price | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
     events?: Event[] | null;
 }
 interface PriceVolumeTierCreate extends ResourceCreate {
@@ -41,6 +43,7 @@ declare class PriceVolumeTiers extends ApiResource<PriceVolumeTier> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     price(priceVolumeTierId: string | PriceVolumeTier, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Price>;
     attachments(priceVolumeTierId: string | PriceVolumeTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(priceVolumeTierId: string | PriceVolumeTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     events(priceVolumeTierId: string | PriceVolumeTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     isPriceVolumeTier(resource: any): resource is PriceVolumeTier;
     relationship(id: string | ResourceId | null): PriceVolumeTierRel;

package/lib/esm/resources/price_volume_tiers.js

@@ -17,6 +17,10 @@ class PriceVolumeTiers extends ApiResource {
         const _priceVolumeTierId = priceVolumeTierId.id || priceVolumeTierId;
         return this.resources.fetch({ type: 'attachments' }, `price_volume_tiers/${_priceVolumeTierId}/attachments`, params, options);
     }
+    async versions(priceVolumeTierId, params, options) {
+        const _priceVolumeTierId = priceVolumeTierId.id || priceVolumeTierId;
+        return this.resources.fetch({ type: 'versions' }, `price_volume_tiers/${_priceVolumeTierId}/versions`, params, options);
+    }
     async events(priceVolumeTierId, params, options) {
         const _priceVolumeTierId = priceVolumeTierId.id || priceVolumeTierId;
         return this.resources.fetch({ type: 'events' }, `price_volume_tiers/${_priceVolumeTierId}/events`, params, options);

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

@@ -7,6 +7,7 @@ import type { PriceTier, PriceTierType } from './price_tiers';
 import type { PriceVolumeTier } from './price_volume_tiers';
 import type { PriceFrequencyTier } from './price_frequency_tiers';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PriceType = 'prices';
 type PriceRel = ResourceRel & {
     type: PriceType;
@@ -36,6 +37,7 @@ interface Price extends Resource {
     price_volume_tiers?: PriceVolumeTier[] | null;
     price_frequency_tiers?: PriceFrequencyTier[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface PriceCreate extends ResourceCreate {
     sku_code?: string | null;
@@ -64,6 +66,7 @@ declare class Prices extends ApiResource<Price> {
     price_volume_tiers(priceId: string | Price, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PriceVolumeTier>>;
     price_frequency_tiers(priceId: string | Price, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PriceFrequencyTier>>;
     attachments(priceId: string | Price, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(priceId: string | Price, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPrice(resource: any): resource is Price;
     relationship(id: string | ResourceId | null): PriceRel;
     type(): PriceType;

package/lib/esm/resources/prices.js

@@ -33,6 +33,10 @@ class Prices extends ApiResource {
         const _priceId = priceId.id || priceId;
         return this.resources.fetch({ type: 'attachments' }, `prices/${_priceId}/attachments`, params, options);
     }
+    async versions(priceId, params, options) {
+        const _priceId = priceId.id || priceId;
+        return this.resources.fetch({ type: 'versions' }, `prices/${_priceId}/versions`, params, options);
+    }
     isPrice(resource) {
         return resource.type && (resource.type === Prices.TYPE);
     }

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

@@ -1,11 +1,13 @@
 import { ApiResource } from '../resource';
-import type { Resource, ResourceId, ResourceRel } from '../resource';
+import type { Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsList } from '../query';
 import type { PercentageDiscountPromotion } from './percentage_discount_promotions';
 import type { FreeShippingPromotion } from './free_shipping_promotions';
 import type { FreeGiftPromotion } from './free_gift_promotions';
 import type { FixedPricePromotion } from './fixed_price_promotions';
 import type { ExternalPromotion } from './external_promotions';
 import type { FixedAmountPromotion } from './fixed_amount_promotions';
+import type { Version } from './versions';
 type PromotionRuleType = 'promotion_rules';
 type PromotionRuleRel = ResourceRel & {
     type: PromotionRuleType;
@@ -13,9 +15,11 @@ type PromotionRuleRel = ResourceRel & {
 interface PromotionRule extends Resource {
     readonly type: PromotionRuleType;
     promotion?: PercentageDiscountPromotion | FreeShippingPromotion | FreeGiftPromotion | FixedPricePromotion | ExternalPromotion | FixedAmountPromotion | null;
+    versions?: Version[] | null;
 }
 declare class PromotionRules extends ApiResource<PromotionRule> {
     static readonly TYPE: PromotionRuleType;
+    versions(promotionRuleId: string | PromotionRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPromotionRule(resource: any): resource is PromotionRule;
     relationship(id: string | ResourceId | null): PromotionRuleRel;
     type(): PromotionRuleType;

package/lib/esm/resources/promotion_rules.js

@@ -1,5 +1,9 @@
 import { ApiResource } from '../resource';
 class PromotionRules extends ApiResource {
+    async versions(promotionRuleId, params, options) {
+        const _promotionRuleId = promotionRuleId.id || promotionRuleId;
+        return this.resources.fetch({ type: 'versions' }, `promotion_rules/${_promotionRuleId}/versions`, params, options);
+    }
     isPromotionRule(resource) {
         return resource.type && (resource.type === PromotionRules.TYPE);
     }

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

@@ -10,6 +10,7 @@ import type { SkuList } from './sku_lists';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
 import type { Tag } from './tags';
+import type { Version } from './versions';
 type PromotionType = 'promotions';
 type PromotionRel = ResourceRel & {
     type: PromotionType;
@@ -32,6 +33,7 @@ interface Promotion extends Resource {
     attachments?: Attachment[] | null;
     events?: Event[] | null;
     tags?: Tag[] | null;
+    versions?: Version[] | null;
 }
 declare class Promotions extends ApiResource<Promotion> {
     static readonly TYPE: PromotionType;
@@ -43,6 +45,7 @@ declare class Promotions extends ApiResource<Promotion> {
     attachments(promotionId: string | Promotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(promotionId: string | Promotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     tags(promotionId: string | Promotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(promotionId: string | Promotion, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPromotion(resource: any): resource is Promotion;
     relationship(id: string | ResourceId | null): PromotionRel;
     type(): PromotionType;

package/lib/esm/resources/promotions.js

@@ -32,6 +32,10 @@ class Promotions extends ApiResource {
         const _promotionId = promotionId.id || promotionId;
         return this.resources.fetch({ type: 'tags' }, `promotions/${_promotionId}/tags`, params, options);
     }
+    async versions(promotionId, params, options) {
+        const _promotionId = promotionId.id || promotionId;
+        return this.resources.fetch({ type: 'versions' }, `promotions/${_promotionId}/versions`, params, options);
+    }
     isPromotion(resource) {
         return resource.type && (resource.type === Promotions.TYPE);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse }
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Order } from './orders';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { Capture } from './captures';
 import type { Event } from './events';
 type RefundType = 'refunds';
@@ -24,6 +25,7 @@ interface Refund extends Resource {
     gateway_transaction_id?: string | null;
     order?: Order | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
     reference_capture?: Capture | null;
     events?: Event[] | null;
 }
@@ -31,6 +33,7 @@ declare class Refunds extends ApiResource<Refund> {
     static readonly TYPE: RefundType;
     order(refundId: string | Refund, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     attachments(refundId: string | Refund, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(refundId: string | Refund, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     reference_capture(refundId: string | Refund, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Capture>;
     events(refundId: string | Refund, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     isRefund(resource: any): resource is Refund;

package/lib/esm/resources/refunds.js

@@ -8,6 +8,10 @@ class Refunds extends ApiResource {
         const _refundId = refundId.id || refundId;
         return this.resources.fetch({ type: 'attachments' }, `refunds/${_refundId}/attachments`, params, options);
     }
+    async versions(refundId, params, options) {
+        const _refundId = refundId.id || refundId;
+        return this.resources.fetch({ type: 'versions' }, `refunds/${_refundId}/versions`, params, options);
+    }
     async reference_capture(refundId, params, options) {
         const _refundId = refundId.id || refundId;
         return this.resources.fetch({ type: 'captures' }, `refunds/${_refundId}/reference_capture`, params, options);

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

@@ -9,6 +9,7 @@ import type { ReturnLineItem } from './return_line_items';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
 import type { Tag, TagType } from './tags';
+import type { Version } from './versions';
 type ReturnType = 'returns';
 type ReturnRel = ResourceRel & {
     type: ReturnType;
@@ -43,6 +44,7 @@ interface Return extends Resource {
     attachments?: Attachment[] | null;
     events?: Event[] | null;
     tags?: Tag[] | null;
+    versions?: Version[] | null;
 }
 interface ReturnCreate extends ResourceCreate {
     order: OrderRel;
@@ -76,6 +78,7 @@ declare class Returns extends ApiResource<Return> {
     attachments(returnId: string | Return, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(returnId: string | Return, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     tags(returnId: string | Return, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(returnId: string | Return, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _request(id: string | Return, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Return>;
     _approve(id: string | Return, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Return>;
     _cancel(id: string | Return, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Return>;

package/lib/esm/resources/returns.js

@@ -45,6 +45,10 @@ class Returns extends ApiResource {
         const _returnId = returnId.id || returnId;
         return this.resources.fetch({ type: 'tags' }, `returns/${_returnId}/tags`, params, options);
     }
+    async versions(returnId, params, options) {
+        const _returnId = returnId.id || returnId;
+        return this.resources.fetch({ type: 'versions' }, `returns/${_returnId}/versions`, params, options);
+    }
     async _request(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: Returns.TYPE, _request: true }, params, options);
     }

package/lib/esm/resources/satispay_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 { SatispayPayment, SatispayPaymentType } from './satispay_payments';
 type SatispayGatewayType = 'satispay_gateways';
 type SatispayGatewayRel = ResourceRel & {
@@ -17,6 +18,7 @@ interface SatispayGateway extends Resource {
     key_id: string;
     webhook_endpoint_url?: string | null;
     payment_methods?: PaymentMethod[] | null;
+    versions?: Version[] | null;
     satispay_payments?: SatispayPayment[] | null;
 }
 interface SatispayGatewayCreate extends ResourceCreate {
@@ -34,6 +36,7 @@ declare class SatispayGateways extends ApiResource<SatispayGateway> {
     update(resource: SatispayGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SatispayGateway>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     payment_methods(satispayGatewayId: string | SatispayGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(satispayGatewayId: string | SatispayGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     satispay_payments(satispayGatewayId: string | SatispayGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<SatispayPayment>>;
     isSatispayGateway(resource: any): resource is SatispayGateway;
     relationship(id: string | ResourceId | null): SatispayGatewayRel;

package/lib/esm/resources/satispay_gateways.js

@@ -13,6 +13,10 @@ class SatispayGateways extends ApiResource {
         const _satispayGatewayId = satispayGatewayId.id || satispayGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `satispay_gateways/${_satispayGatewayId}/payment_methods`, params, options);
     }
+    async versions(satispayGatewayId, params, options) {
+        const _satispayGatewayId = satispayGatewayId.id || satispayGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `satispay_gateways/${_satispayGatewayId}/versions`, params, options);
+    }
     async satispay_payments(satispayGatewayId, params, options) {
         const _satispayGatewayId = satispayGatewayId.id || satispayGatewayId;
         return this.resources.fetch({ type: 'satispay_payments' }, `satispay_gateways/${_satispayGatewayId}/satispay_payments`, params, options);

package/lib/esm/resources/satispay_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 SatispayPaymentType = 'satispay_payments';
 type SatispayPaymentRel = ResourceRel & {
     type: SatispayPaymentType;
@@ -14,6 +15,7 @@ interface SatispayPayment extends Resource {
     readonly type: SatispayPaymentType;
     payment_id?: string | null;
     flow?: string | null;
+    status?: string | null;
     redirect_url?: string | null;
     payment_url?: string | null;
     intent_amount_cents: number;
@@ -22,6 +24,7 @@ interface SatispayPayment extends Resource {
     payment_response?: Record<string, any> | null;
     order?: Order | null;
     payment_gateway?: PaymentGateway | null;
+    versions?: Version[] | null;
 }
 interface SatispayPaymentCreate extends ResourceCreate {
     flow?: string | null;
@@ -40,6 +43,7 @@ declare class SatispayPayments extends ApiResource<SatispayPayment> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     order(satispayPaymentId: string | SatispayPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(satispayPaymentId: string | SatispayPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(satispayPaymentId: string | SatispayPayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _refresh(id: string | SatispayPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SatispayPayment>;
     isSatispayPayment(resource: any): resource is SatispayPayment;
     relationship(id: string | ResourceId | null): SatispayPaymentRel;

package/lib/esm/resources/satispay_payments.js

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