@commercelayer/sdk 5.12.5 → 5.13.1

package/lib/cjs/resources/percentage_discount_promotions.js

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

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

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

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

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

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const resource_1 = require("../resource");
 class PromotionRules extends resource_1.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/cjs/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/cjs/resources/promotions.js

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

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

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

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

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

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

@@ -13,6 +13,7 @@ import type { CarrierAccount } from './carrier_accounts';
 import type { Parcel } from './parcels';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
+import type { Version } from './versions';
 type ShipmentType = 'shipments';
 type ShipmentRel = ResourceRel & {
     type: ShipmentType;
@@ -62,6 +63,7 @@ interface Shipment extends Resource {
     parcels?: Parcel[] | null;
     attachments?: Attachment[] | null;
     events?: Event[] | null;
+    versions?: Version[] | null;
 }
 interface ShipmentUpdate extends ResourceUpdate {
     _on_hold?: boolean | null;
@@ -91,6 +93,7 @@ declare class Shipments extends ApiResource<Shipment> {
     parcels(shipmentId: string | Shipment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Parcel>>;
     attachments(shipmentId: string | Shipment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(shipmentId: string | Shipment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(shipmentId: string | Shipment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _on_hold(id: string | Shipment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Shipment>;
     _picking(id: string | Shipment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Shipment>;
     _packing(id: string | Shipment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Shipment>;

package/lib/cjs/resources/shipments.js

@@ -61,6 +61,10 @@ class Shipments extends resource_1.ApiResource {
         const _shipmentId = shipmentId.id || shipmentId;
         return this.resources.fetch({ type: 'events' }, `shipments/${_shipmentId}/events`, params, options);
     }
+    async versions(shipmentId, params, options) {
+        const _shipmentId = shipmentId.id || shipmentId;
+        return this.resources.fetch({ type: 'versions' }, `shipments/${_shipmentId}/versions`, params, options);
+    }
     async _on_hold(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: Shipments.TYPE, _on_hold: true }, params, options);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Sku } from './skus';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type ShippingCategoryType = 'shipping_categories';
 type ShippingCategoryRel = ResourceRel & {
     type: ShippingCategoryType;
@@ -12,6 +13,7 @@ interface ShippingCategory extends Resource {
     name: string;
     skus?: Sku[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface ShippingCategoryCreate extends ResourceCreate {
     name: string;
@@ -26,6 +28,7 @@ declare class ShippingCategories extends ApiResource<ShippingCategory> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     skus(shippingCategoryId: string | ShippingCategory, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Sku>>;
     attachments(shippingCategoryId: string | ShippingCategory, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(shippingCategoryId: string | ShippingCategory, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isShippingCategory(resource: any): resource is ShippingCategory;
     relationship(id: string | ResourceId | null): ShippingCategoryRel;
     type(): ShippingCategoryType;

package/lib/cjs/resources/shipping_categories.js

@@ -19,6 +19,10 @@ class ShippingCategories extends resource_1.ApiResource {
         const _shippingCategoryId = shippingCategoryId.id || shippingCategoryId;
         return this.resources.fetch({ type: 'attachments' }, `shipping_categories/${_shippingCategoryId}/attachments`, params, options);
     }
+    async versions(shippingCategoryId, params, options) {
+        const _shippingCategoryId = shippingCategoryId.id || shippingCategoryId;
+        return this.resources.fetch({ type: 'versions' }, `shipping_categories/${_shippingCategoryId}/versions`, params, options);
+    }
     isShippingCategory(resource) {
         return resource.type && (resource.type === ShippingCategories.TYPE);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse }
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { ShippingMethod } from './shipping_methods';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type ShippingMethodTierType = 'shipping_method_tiers';
 type ShippingMethodTierRel = ResourceRel & {
     type: ShippingMethodTierType;
@@ -16,11 +17,13 @@ interface ShippingMethodTier extends Resource {
     formatted_price_amount?: string | null;
     shipping_method?: ShippingMethod | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 declare class ShippingMethodTiers extends ApiResource<ShippingMethodTier> {
     static readonly TYPE: ShippingMethodTierType;
     shipping_method(shippingMethodTierId: string | ShippingMethodTier, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ShippingMethod>;
     attachments(shippingMethodTierId: string | ShippingMethodTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(shippingMethodTierId: string | ShippingMethodTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isShippingMethodTier(resource: any): resource is ShippingMethodTier;
     relationship(id: string | ResourceId | null): ShippingMethodTierRel;
     type(): ShippingMethodTierType;

package/lib/cjs/resources/shipping_method_tiers.js

@@ -10,6 +10,10 @@ class ShippingMethodTiers extends resource_1.ApiResource {
         const _shippingMethodTierId = shippingMethodTierId.id || shippingMethodTierId;
         return this.resources.fetch({ type: 'attachments' }, `shipping_method_tiers/${_shippingMethodTierId}/attachments`, params, options);
     }
+    async versions(shippingMethodTierId, params, options) {
+        const _shippingMethodTierId = shippingMethodTierId.id || shippingMethodTierId;
+        return this.resources.fetch({ type: 'versions' }, `shipping_method_tiers/${_shippingMethodTierId}/versions`, params, options);
+    }
     isShippingMethodTier(resource) {
         return resource.type && (resource.type === ShippingMethodTiers.TYPE);
     }

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

@@ -9,6 +9,7 @@ import type { DeliveryLeadTime } from './delivery_lead_times';
 import type { ShippingMethodTier, ShippingMethodTierType } from './shipping_method_tiers';
 import type { ShippingWeightTier } from './shipping_weight_tiers';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type ShippingMethodType = 'shipping_methods';
 type ShippingMethodRel = ResourceRel & {
     type: ShippingMethodType;
@@ -56,6 +57,7 @@ interface ShippingMethod extends Resource {
     shipping_method_tiers?: ShippingMethodTier[] | null;
     shipping_weight_tiers?: ShippingWeightTier[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface ShippingMethodCreate extends ResourceCreate {
     name: string;
@@ -106,6 +108,7 @@ declare class ShippingMethods extends ApiResource<ShippingMethod> {
     shipping_method_tiers(shippingMethodId: string | ShippingMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ShippingMethodTier>>;
     shipping_weight_tiers(shippingMethodId: string | ShippingMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ShippingWeightTier>>;
     attachments(shippingMethodId: string | ShippingMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(shippingMethodId: string | ShippingMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _disable(id: string | ShippingMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ShippingMethod>;
     _enable(id: string | ShippingMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ShippingMethod>;
     isShippingMethod(resource: any): resource is ShippingMethod;

package/lib/cjs/resources/shipping_methods.js

@@ -43,6 +43,10 @@ class ShippingMethods extends resource_1.ApiResource {
         const _shippingMethodId = shippingMethodId.id || shippingMethodId;
         return this.resources.fetch({ type: 'attachments' }, `shipping_methods/${_shippingMethodId}/attachments`, params, options);
     }
+    async versions(shippingMethodId, params, options) {
+        const _shippingMethodId = shippingMethodId.id || shippingMethodId;
+        return this.resources.fetch({ type: 'versions' }, `shipping_methods/${_shippingMethodId}/versions`, params, options);
+    }
     async _disable(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: ShippingMethods.TYPE, _disable: true }, params, options);
     }

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { ShippingMethod, ShippingMethodType } from './shipping_methods';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type ShippingWeightTierType = 'shipping_weight_tiers';
 type ShippingWeightTierRel = ResourceRel & {
     type: ShippingWeightTierType;
@@ -19,6 +20,7 @@ interface ShippingWeightTier extends Resource {
     formatted_price_amount?: string | null;
     shipping_method?: ShippingMethod | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface ShippingWeightTierCreate extends ResourceCreate {
     name: string;
@@ -39,6 +41,7 @@ declare class ShippingWeightTiers extends ApiResource<ShippingWeightTier> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     shipping_method(shippingWeightTierId: string | ShippingWeightTier, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ShippingMethod>;
     attachments(shippingWeightTierId: string | ShippingWeightTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(shippingWeightTierId: string | ShippingWeightTier, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isShippingWeightTier(resource: any): resource is ShippingWeightTier;
     relationship(id: string | ResourceId | null): ShippingWeightTierRel;
     type(): ShippingWeightTierType;

package/lib/cjs/resources/shipping_weight_tiers.js

@@ -19,6 +19,10 @@ class ShippingWeightTiers extends resource_1.ApiResource {
         const _shippingWeightTierId = shippingWeightTierId.id || shippingWeightTierId;
         return this.resources.fetch({ type: 'attachments' }, `shipping_weight_tiers/${_shippingWeightTierId}/attachments`, params, options);
     }
+    async versions(shippingWeightTierId, params, options) {
+        const _shippingWeightTierId = shippingWeightTierId.id || shippingWeightTierId;
+        return this.resources.fetch({ type: 'versions' }, `shipping_weight_tiers/${_shippingWeightTierId}/versions`, params, options);
+    }
     isShippingWeightTier(resource) {
         return resource.type && (resource.type === ShippingWeightTiers.TYPE);
     }