@commercelayer/sdk 5.12.4 → 5.13.0

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { TaxRule, TaxRuleType } from './tax_rules';
 type ManualTaxCalculatorType = 'manual_tax_calculators';
 type ManualTaxCalculatorRel = ResourceRel & {
@@ -16,6 +17,7 @@ interface ManualTaxCalculator extends Resource {
     name: string;
     markets?: Market[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
     tax_rules?: TaxRule[] | null;
 }
 interface ManualTaxCalculatorCreate extends ResourceCreate {
@@ -33,6 +35,7 @@ declare class ManualTaxCalculators extends ApiResource<ManualTaxCalculator> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     markets(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
     attachments(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     tax_rules(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxRule>>;
     isManualTaxCalculator(resource: any): resource is ManualTaxCalculator;
     relationship(id: string | ResourceId | null): ManualTaxCalculatorRel;

package/lib/cjs/resources/manual_tax_calculators.js

@@ -19,6 +19,10 @@ class ManualTaxCalculators extends resource_1.ApiResource {
         const _manualTaxCalculatorId = manualTaxCalculatorId.id || manualTaxCalculatorId;
         return this.resources.fetch({ type: 'attachments' }, `manual_tax_calculators/${_manualTaxCalculatorId}/attachments`, params, options);
     }
+    async versions(manualTaxCalculatorId, params, options) {
+        const _manualTaxCalculatorId = manualTaxCalculatorId.id || manualTaxCalculatorId;
+        return this.resources.fetch({ type: 'versions' }, `manual_tax_calculators/${_manualTaxCalculatorId}/versions`, params, options);
+    }
     async tax_rules(manualTaxCalculatorId, params, options) {
         const _manualTaxCalculatorId = manualTaxCalculatorId.id || manualTaxCalculatorId;
         return this.resources.fetch({ type: 'tax_rules' }, `manual_tax_calculators/${_manualTaxCalculatorId}/tax_rules`, params, options);

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

@@ -8,6 +8,7 @@ import type { SubscriptionModel, SubscriptionModelType } from './subscription_mo
 import type { TaxCalculator, TaxCalculatorType } from './tax_calculators';
 import type { CustomerGroup, CustomerGroupType } from './customer_groups';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type MarketType = 'markets';
 type MarketRel = ResourceRel & {
     type: MarketType;
@@ -48,6 +49,7 @@ interface Market extends Resource {
     tax_calculator?: TaxCalculator | null;
     customer_group?: CustomerGroup | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface MarketCreate extends ResourceCreate {
     name: string;
@@ -89,6 +91,7 @@ declare class Markets extends ApiResource<Market> {
     tax_calculator(marketId: string | Market, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxCalculator>;
     customer_group(marketId: string | Market, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerGroup>;
     attachments(marketId: string | Market, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(marketId: string | Market, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _disable(id: string | Market, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     _enable(id: string | Market, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     isMarket(resource: any): resource is Market;

package/lib/cjs/resources/markets.js

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

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

@@ -3,6 +3,7 @@ import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesCon
 import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { Address, AddressType } from './addresses';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type MerchantType = 'merchants';
 type MerchantRel = ResourceRel & {
     type: MerchantType;
@@ -15,6 +16,7 @@ interface Merchant extends Resource {
     name: string;
     address?: Address | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface MerchantCreate extends ResourceCreate {
     name: string;
@@ -31,6 +33,7 @@ declare class Merchants extends ApiResource<Merchant> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     address(merchantId: string | Merchant, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Address>;
     attachments(merchantId: string | Merchant, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(merchantId: string | Merchant, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isMerchant(resource: any): resource is Merchant;
     relationship(id: string | ResourceId | null): MerchantRel;
     type(): MerchantType;

package/lib/cjs/resources/merchants.js

@@ -19,6 +19,10 @@ class Merchants extends resource_1.ApiResource {
         const _merchantId = merchantId.id || merchantId;
         return this.resources.fetch({ type: 'attachments' }, `merchants/${_merchantId}/attachments`, params, options);
     }
+    async versions(merchantId, params, options) {
+        const _merchantId = merchantId.id || merchantId;
+        return this.resources.fetch({ type: 'versions' }, `merchants/${_merchantId}/versions`, params, options);
+    }
     isMerchant(resource) {
         return resource.type && (resource.type === Merchants.TYPE);
     }

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

@@ -1,12 +1,13 @@
 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 { PercentageDiscountPromotion, PercentageDiscountPromotionType } from './percentage_discount_promotions';
 import type { FreeShippingPromotion, FreeShippingPromotionType } from './free_shipping_promotions';
 import type { FreeGiftPromotion, FreeGiftPromotionType } from './free_gift_promotions';
 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';
 type OrderAmountPromotionRuleType = 'order_amount_promotion_rules';
 type OrderAmountPromotionRuleRel = ResourceRel & {
     type: OrderAmountPromotionRuleType;
@@ -36,6 +37,7 @@ interface OrderAmountPromotionRule extends Resource {
     formatted_order_amount?: string | null;
     use_subtotal?: boolean | null;
     promotion?: PercentageDiscountPromotion | FreeShippingPromotion | FreeGiftPromotion | FixedPricePromotion | ExternalPromotion | FixedAmountPromotion | null;
+    versions?: Version[] | null;
 }
 interface OrderAmountPromotionRuleCreate extends ResourceCreate {
     order_amount_cents?: number | null;
@@ -52,6 +54,7 @@ declare class OrderAmountPromotionRules extends ApiResource<OrderAmountPromotion
     create(resource: OrderAmountPromotionRuleCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderAmountPromotionRule>;
     update(resource: OrderAmountPromotionRuleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderAmountPromotionRule>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    versions(orderAmountPromotionRuleId: string | OrderAmountPromotionRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isOrderAmountPromotionRule(resource: any): resource is OrderAmountPromotionRule;
     relationship(id: string | ResourceId | null): OrderAmountPromotionRuleRel;
     type(): OrderAmountPromotionRuleType;

package/lib/cjs/resources/order_amount_promotion_rules.js

@@ -11,6 +11,10 @@ class OrderAmountPromotionRules extends resource_1.ApiResource {
     async delete(id, options) {
         await this.resources.delete((typeof id === 'string') ? { id, type: OrderAmountPromotionRules.TYPE } : id, options);
     }
+    async versions(orderAmountPromotionRuleId, params, options) {
+        const _orderAmountPromotionRuleId = orderAmountPromotionRuleId.id || orderAmountPromotionRuleId;
+        return this.resources.fetch({ type: 'versions' }, `order_amount_promotion_rules/${_orderAmountPromotionRuleId}/versions`, params, options);
+    }
     isOrderAmountPromotionRule(resource) {
         return resource.type && (resource.type === OrderAmountPromotionRules.TYPE);
     }

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

@@ -5,6 +5,7 @@ import type { OrderSubscription, OrderSubscriptionType } from './order_subscript
 import type { Adjustment, AdjustmentType } from './adjustments';
 import type { Bundle, BundleType } from './bundles';
 import type { Sku, SkuType } from './skus';
+import type { LineItem } from './line_items';
 type OrderSubscriptionItemType = 'order_subscription_items';
 type OrderSubscriptionItemRel = ResourceRel & {
     type: OrderSubscriptionItemType;
@@ -32,6 +33,7 @@ interface OrderSubscriptionItem extends Resource {
     formatted_total_amount?: string | null;
     order_subscription?: OrderSubscription | null;
     item?: Adjustment | Bundle | Sku | null;
+    source_line_item?: LineItem | null;
 }
 interface OrderSubscriptionItemCreate extends ResourceCreate {
     sku_code?: string | null;
@@ -53,6 +55,7 @@ declare class OrderSubscriptionItems extends ApiResource<OrderSubscriptionItem>
     update(resource: OrderSubscriptionItemUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscriptionItem>;
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     order_subscription(orderSubscriptionItemId: string | OrderSubscriptionItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscription>;
+    source_line_item(orderSubscriptionItemId: string | OrderSubscriptionItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<LineItem>;
     isOrderSubscriptionItem(resource: any): resource is OrderSubscriptionItem;
     relationship(id: string | ResourceId | null): OrderSubscriptionItemRel;
     type(): OrderSubscriptionItemType;

package/lib/cjs/resources/order_subscription_items.js

@@ -15,6 +15,10 @@ class OrderSubscriptionItems extends resource_1.ApiResource {
         const _orderSubscriptionItemId = orderSubscriptionItemId.id || orderSubscriptionItemId;
         return this.resources.fetch({ type: 'order_subscriptions' }, `order_subscription_items/${_orderSubscriptionItemId}/order_subscription`, params, options);
     }
+    async source_line_item(orderSubscriptionItemId, params, options) {
+        const _orderSubscriptionItemId = orderSubscriptionItemId.id || orderSubscriptionItemId;
+        return this.resources.fetch({ type: 'line_items' }, `order_subscription_items/${_orderSubscriptionItemId}/source_line_item`, params, options);
+    }
     isOrderSubscriptionItem(resource) {
         return resource.type && (resource.type === OrderSubscriptionItems.TYPE);
     }

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

@@ -10,6 +10,7 @@ import type { OrderSubscriptionItem } from './order_subscription_items';
 import type { OrderFactory } from './order_factories';
 import type { RecurringOrderCopy } from './recurring_order_copies';
 import type { Event } from './events';
+import type { Version } from './versions';
 type OrderSubscriptionType = 'order_subscriptions';
 type OrderSubscriptionRel = ResourceRel & {
     type: OrderSubscriptionType;
@@ -51,6 +52,7 @@ interface OrderSubscription extends Resource {
     recurring_order_copies?: RecurringOrderCopy[] | null;
     orders?: Order[] | null;
     events?: Event[] | null;
+    versions?: Version[] | null;
 }
 interface OrderSubscriptionCreate extends ResourceCreate {
     frequency: string;
@@ -85,6 +87,7 @@ declare class OrderSubscriptions extends ApiResource<OrderSubscription> {
     recurring_order_copies(orderSubscriptionId: string | OrderSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<RecurringOrderCopy>>;
     orders(orderSubscriptionId: string | OrderSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Order>>;
     events(orderSubscriptionId: string | OrderSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(orderSubscriptionId: string | OrderSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _activate(id: string | OrderSubscription, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscription>;
     _deactivate(id: string | OrderSubscription, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscription>;
     _cancel(id: string | OrderSubscription, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscription>;

package/lib/cjs/resources/order_subscriptions.js

@@ -51,6 +51,10 @@ class OrderSubscriptions extends resource_1.ApiResource {
         const _orderSubscriptionId = orderSubscriptionId.id || orderSubscriptionId;
         return this.resources.fetch({ type: 'events' }, `order_subscriptions/${_orderSubscriptionId}/events`, params, options);
     }
+    async versions(orderSubscriptionId, params, options) {
+        const _orderSubscriptionId = orderSubscriptionId.id || orderSubscriptionId;
+        return this.resources.fetch({ type: 'versions' }, `order_subscriptions/${_orderSubscriptionId}/versions`, params, options);
+    }
     async _activate(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: OrderSubscriptions.TYPE, _activate: true }, params, options);
     }

package/lib/cjs/resources/order_validation_rules.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 OrderValidationRuleType = 'order_validation_rules';
 type OrderValidationRuleRel = ResourceRel & {
     type: OrderValidationRuleType;
@@ -11,11 +12,13 @@ interface OrderValidationRule extends Resource {
     readonly type: OrderValidationRuleType;
     market?: Market | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 declare class OrderValidationRules extends ApiResource<OrderValidationRule> {
     static readonly TYPE: OrderValidationRuleType;
     market(orderValidationRuleId: string | OrderValidationRule, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     attachments(orderValidationRuleId: string | OrderValidationRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(orderValidationRuleId: string | OrderValidationRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isOrderValidationRule(resource: any): resource is OrderValidationRule;
     relationship(id: string | ResourceId | null): OrderValidationRuleRel;
     type(): OrderValidationRuleType;

package/lib/cjs/resources/order_validation_rules.js

@@ -10,6 +10,10 @@ class OrderValidationRules extends resource_1.ApiResource {
         const _orderValidationRuleId = orderValidationRuleId.id || orderValidationRuleId;
         return this.resources.fetch({ type: 'attachments' }, `order_validation_rules/${_orderValidationRuleId}/attachments`, params, options);
     }
+    async versions(orderValidationRuleId, params, options) {
+        const _orderValidationRuleId = orderValidationRuleId.id || orderValidationRuleId;
+        return this.resources.fetch({ type: 'versions' }, `order_validation_rules/${_orderValidationRuleId}/versions`, params, options);
+    }
     isOrderValidationRule(resource) {
         return resource.type && (resource.type === OrderValidationRules.TYPE);
     }

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

@@ -21,8 +21,8 @@ import type { WireTransfer, WireTransferType } from './wire_transfers';
 import type { LineItem } from './line_items';
 import type { Shipment } from './shipments';
 import type { Authorization } from './authorizations';
-import type { Void } from './voids';
 import type { Capture } from './captures';
+import type { Void } from './voids';
 import type { Refund } from './refunds';
 import type { Return } from './returns';
 import type { OrderSubscription } from './order_subscriptions';
@@ -32,6 +32,7 @@ import type { RecurringOrderCopy } from './recurring_order_copies';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
 import type { Tag, TagType } from './tags';
+import type { Version } from './versions';
 type OrderType = 'orders';
 type OrderRel = ResourceRel & {
     type: OrderType;
@@ -161,6 +162,9 @@ interface Order extends Resource {
     duty_amount_cents?: number | null;
     duty_amount_float?: number | null;
     formatted_duty_amount?: string | null;
+    place_total_amount_cents?: number | null;
+    place_total_amount_float?: number | null;
+    formatted_place_total_amount?: string | null;
     skus_count?: number | null;
     line_item_options_count?: number | null;
     shipments_count?: number | null;
@@ -194,7 +198,7 @@ interface Order extends Resource {
     payment_source?: AdyenPayment | AxervePayment | BraintreePayment | CheckoutComPayment | ExternalPayment | KlarnaPayment | PaypalPayment | SatispayPayment | StripePayment | WireTransfer | null;
     line_items?: LineItem[] | null;
     shipments?: Shipment[] | null;
-    transactions?: Array<Authorization | Void | Capture | Refund> | null;
+    transactions?: Array<Authorization | Capture | Void | Refund> | null;
     authorizations?: Authorization[] | null;
     captures?: Capture[] | null;
     voids?: Void[] | null;
@@ -207,6 +211,7 @@ interface Order extends Resource {
     attachments?: Attachment[] | null;
     events?: Event[] | null;
     tags?: Tag[] | null;
+    versions?: Version[] | null;
 }
 interface OrderCreate extends ResourceCreate {
     autorefresh?: boolean | null;
@@ -305,6 +310,7 @@ declare class Orders extends ApiResource<Order> {
     attachments(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     tags(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     _archive(id: string | Order, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     _unarchive(id: string | Order, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     _place(id: string | Order, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;

package/lib/cjs/resources/orders.js

@@ -103,6 +103,10 @@ class Orders extends resource_1.ApiResource {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'tags' }, `orders/${_orderId}/tags`, params, options);
     }
+    async versions(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'versions' }, `orders/${_orderId}/versions`, params, options);
+    }
     async _archive(id, params, options) {
         return this.resources.update({ id: (typeof id === 'string') ? id : id.id, type: Orders.TYPE, _archive: true }, params, options);
     }

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

@@ -4,6 +4,7 @@ import type { QueryParamsRetrieve, QueryParamsList } from '../query';
 import type { StockLocation, StockLocationType } from './stock_locations';
 import type { Parcel } from './parcels';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PackageType = 'packages';
 type PackageRel = ResourceRel & {
     type: PackageType;
@@ -22,6 +23,7 @@ interface Package extends Resource {
     stock_location?: StockLocation | null;
     parcels?: Parcel[] | null;
     attachments?: Attachment[] | null;
+    versions?: Version[] | null;
 }
 interface PackageCreate extends ResourceCreate {
     name: string;
@@ -49,6 +51,7 @@ declare class Packages extends ApiResource<Package> {
     stock_location(packageId: string | Package, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StockLocation>;
     parcels(packageId: string | Package, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Parcel>>;
     attachments(packageId: string | Package, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(packageId: string | Package, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPackage(resource: any): resource is Package;
     relationship(id: string | ResourceId | null): PackageRel;
     type(): PackageType;

package/lib/cjs/resources/packages.js

@@ -23,6 +23,10 @@ class Packages extends resource_1.ApiResource {
         const _packageId = packageId.id || packageId;
         return this.resources.fetch({ type: 'attachments' }, `packages/${_packageId}/attachments`, params, options);
     }
+    async versions(packageId, params, options) {
+        const _packageId = packageId.id || packageId;
+        return this.resources.fetch({ type: 'versions' }, `packages/${_packageId}/versions`, params, options);
+    }
     isPackage(resource) {
         return resource.type && (resource.type === Packages.TYPE);
     }

package/lib/cjs/resources/parcel_line_items.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 { Parcel, ParcelType } from './parcels';
 import type { StockLineItem, StockLineItemType } from './stock_line_items';
+import type { Version } from './versions';
 type ParcelLineItemType = 'parcel_line_items';
 type ParcelLineItemRel = ResourceRel & {
     type: ParcelLineItemType;
@@ -26,6 +27,7 @@ interface ParcelLineItem extends Resource {
     * @deprecated This field should not be used as it may be removed in the future without notice
     */
     shipment_line_item?: object;
+    versions?: Version[] | null;
 }
 interface ParcelLineItemCreate extends ResourceCreate {
     quantity: number;
@@ -44,6 +46,7 @@ declare class ParcelLineItems extends ApiResource<ParcelLineItem> {
     delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
     parcel(parcelLineItemId: string | ParcelLineItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Parcel>;
     stock_line_item(parcelLineItemId: string | ParcelLineItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StockLineItem>;
+    versions(parcelLineItemId: string | ParcelLineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isParcelLineItem(resource: any): resource is ParcelLineItem;
     relationship(id: string | ResourceId | null): ParcelLineItemRel;
     type(): ParcelLineItemType;

package/lib/cjs/resources/parcel_line_items.js

@@ -19,6 +19,10 @@ class ParcelLineItems extends resource_1.ApiResource {
         const _parcelLineItemId = parcelLineItemId.id || parcelLineItemId;
         return this.resources.fetch({ type: 'stock_line_items' }, `parcel_line_items/${_parcelLineItemId}/stock_line_item`, params, options);
     }
+    async versions(parcelLineItemId, params, options) {
+        const _parcelLineItemId = parcelLineItemId.id || parcelLineItemId;
+        return this.resources.fetch({ type: 'versions' }, `parcel_line_items/${_parcelLineItemId}/versions`, params, options);
+    }
     isParcelLineItem(resource) {
         return resource.type && (resource.type === ParcelLineItems.TYPE);
     }

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

@@ -6,6 +6,7 @@ import type { Package, PackageType } from './packages';
 import type { ParcelLineItem } from './parcel_line_items';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
+import type { Version } from './versions';
 type ParcelType = 'parcels';
 type ParcelRel = ResourceRel & {
     type: ParcelType;
@@ -48,6 +49,7 @@ interface Parcel extends Resource {
     parcel_line_items?: ParcelLineItem[] | null;
     attachments?: Attachment[] | null;
     events?: Event[] | null;
+    versions?: Version[] | null;
 }
 interface ParcelCreate extends ResourceCreate {
     weight: number;
@@ -115,6 +117,7 @@ declare class Parcels extends ApiResource<Parcel> {
     parcel_line_items(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ParcelLineItem>>;
     attachments(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isParcel(resource: any): resource is Parcel;
     relationship(id: string | ResourceId | null): ParcelRel;
     type(): ParcelType;

package/lib/cjs/resources/parcels.js

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

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

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

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

@@ -19,6 +19,10 @@ class PaypalPayments extends resource_1.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/cjs/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;