@commercelayer/sdk 4.27.1 → 4.28.1

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

@@ -12,8 +12,12 @@ import type { PercentageDiscountPromotion } from './percentage_discount_promotio
 import type { Shipment } from './shipments';
 import type { Sku } from './skus';
 import type { LineItemOption } from './line_item_options';
+import type { ReturnLineItem } from './return_line_items';
+import type { StockReservation } from './stock_reservations';
 import type { StockLineItem } from './stock_line_items';
 import type { StockTransfer } from './stock_transfers';
+import type { Event } from './events';
+import type { Tag } from './tags';
 type LineItemRel = ResourceRel & {
     type: typeof LineItems.TYPE;
 };
@@ -50,14 +54,21 @@ type ShipmentRel = ResourceRel & {
 type SkuRel = ResourceRel & {
     type: 'skus';
 };
+type TagRel = ResourceRel & {
+    type: 'tags';
+};
 interface LineItem extends Resource {
     sku_code?: string;
     bundle_code?: string;
     quantity?: number;
+    _external_price?: boolean;
     currency_code?: string;
     unit_amount_cents?: number;
     unit_amount_float?: number;
     formatted_unit_amount?: string;
+    compare_at_amount_cents?: number;
+    compare_at_amount_float?: number;
+    formatted_compare_at_amount?: string;
     options_amount_cents?: number;
     options_amount_float?: number;
     formatted_options_amount?: string;
@@ -77,15 +88,22 @@ interface LineItem extends Resource {
     tax_breakdown?: object;
     item_type?: string;
     frequency?: string;
+    coupon_code?: string;
     order?: Order;
     item?: Adjustment | Bundle | ExternalPromotion | FixedAmountPromotion | FreeShippingPromotion | GiftCard | PaymentMethod | PercentageDiscountPromotion | Shipment | Sku;
+    sku?: Sku;
+    bundle?: Bundle;
     line_item_options?: LineItemOption[];
+    return_line_items?: ReturnLineItem[];
     /**
     * @deprecated This field should not be used as it may be removed in the future without notice
     */
     shipment_line_items?: object[];
+    stock_reservations?: StockReservation[];
     stock_line_items?: StockLineItem[];
     stock_transfers?: StockTransfer[];
+    events?: Event[];
+    tags?: Tag[];
 }
 interface LineItemCreate extends ResourceCreate {
     sku_code?: string;
@@ -93,22 +111,30 @@ interface LineItemCreate extends ResourceCreate {
     quantity: number;
     _external_price?: boolean;
     _update_quantity?: boolean;
+    _reserve_stock?: boolean;
     unit_amount_cents?: number;
+    compare_at_amount_cents?: number;
     name?: string;
     image_url?: string;
     item_type?: string;
     frequency?: string;
     order: OrderRel;
     item?: AdjustmentRel | BundleRel | ExternalPromotionRel | FixedAmountPromotionRel | FreeShippingPromotionRel | GiftCardRel | PaymentMethodRel | PercentageDiscountPromotionRel | ShipmentRel | SkuRel;
+    sku?: SkuRel;
+    bundle?: BundleRel;
+    tags?: TagRel[];
 }
 interface LineItemUpdate extends ResourceUpdate {
     sku_code?: string;
     bundle_code?: string;
     quantity?: number;
     _external_price?: boolean;
+    _reserve_stock?: boolean;
+    compare_at_amount_cents?: number;
     name?: string;
     image_url?: string;
     frequency?: string;
+    tags?: TagRel[];
 }
 declare class LineItems extends ApiResource {
     static readonly TYPE: 'line_items';
@@ -119,8 +145,12 @@ declare class LineItems extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(lineItemId: string | LineItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     line_item_options(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<LineItemOption>>;
+    return_line_items(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ReturnLineItem>>;
+    stock_reservations(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockReservation>>;
     stock_line_items(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockLineItem>>;
     stock_transfers(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockTransfer>>;
+    events(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    tags(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
     isLineItem(resource: any): resource is LineItem;
     relationship(id: string | ResourceId | null): LineItemRel;
     type(): string;

package/lib/esm/resources/line_items.js

@@ -24,6 +24,14 @@ class LineItems extends ApiResource {
         const _lineItemId = lineItemId.id || lineItemId;
         return this.resources.fetch({ type: 'line_item_options' }, `line_items/${_lineItemId}/line_item_options`, params, options);
     }
+    async return_line_items(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'return_line_items' }, `line_items/${_lineItemId}/return_line_items`, params, options);
+    }
+    async stock_reservations(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'stock_reservations' }, `line_items/${_lineItemId}/stock_reservations`, params, options);
+    }
     async stock_line_items(lineItemId, params, options) {
         const _lineItemId = lineItemId.id || lineItemId;
         return this.resources.fetch({ type: 'stock_line_items' }, `line_items/${_lineItemId}/stock_line_items`, params, options);
@@ -32,6 +40,14 @@ class LineItems extends ApiResource {
         const _lineItemId = lineItemId.id || lineItemId;
         return this.resources.fetch({ type: 'stock_transfers' }, `line_items/${_lineItemId}/stock_transfers`, params, options);
     }
+    async events(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'events' }, `line_items/${_lineItemId}/events`, params, options);
+    }
+    async tags(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'tags' }, `line_items/${_lineItemId}/tags`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isLineItem(resource) {
         return resource.type && (resource.type === LineItems.TYPE);

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

@@ -1,12 +1,14 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 type ManualGatewayRel = ResourceRel & {
     type: typeof ManualGateways.TYPE;
 };
 interface ManualGateway extends Resource {
     name?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
 }
 interface ManualGatewayCreate extends ResourceCreate {
     name: string;
@@ -22,6 +24,7 @@ declare class ManualGateways extends ApiResource {
     update(resource: ManualGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ManualGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(manualGatewayId: string | ManualGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(manualGatewayId: string | ManualGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isManualGateway(resource: any): resource is ManualGateway;
     relationship(id: string | ResourceId | null): ManualGatewayRel;
     type(): string;

package/lib/esm/resources/manual_gateways.js

@@ -20,6 +20,10 @@ class ManualGateways extends ApiResource {
         const _manualGatewayId = manualGatewayId.id || manualGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `manual_gateways/${_manualGatewayId}/payment_methods`, params, options);
     }
+    async versions(manualGatewayId, params, options) {
+        const _manualGatewayId = manualGatewayId.id || manualGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `manual_gateways/${_manualGatewayId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isManualGateway(resource) {
         return resource.type && (resource.type === ManualGateways.TYPE);

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

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { TaxRule } from './tax_rules';
 type ManualTaxCalculatorRel = ResourceRel & {
     type: typeof ManualTaxCalculators.TYPE;
@@ -13,6 +14,7 @@ interface ManualTaxCalculator extends Resource {
     name?: string;
     markets?: Market[];
     attachments?: Attachment[];
+    versions?: Version[];
     tax_rules?: TaxRule[];
 }
 interface ManualTaxCalculatorCreate extends ResourceCreate {
@@ -32,6 +34,7 @@ declare class ManualTaxCalculators extends ApiResource {
     delete(id: string, 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/esm/resources/manual_tax_calculators.js

@@ -24,6 +24,10 @@ class ManualTaxCalculators extends 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/esm/resources/markets.d.ts

@@ -7,6 +7,7 @@ import type { SubscriptionModel } from './subscription_models';
 import type { TaxCalculator } from './tax_calculators';
 import type { CustomerGroup } from './customer_groups';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type MarketRel = ResourceRel & {
     type: typeof Markets.TYPE;
 };
@@ -31,6 +32,7 @@ type CustomerGroupRel = ResourceRel & {
 interface Market extends Resource {
     number?: number;
     name?: string;
+    code?: string;
     facebook_pixel_id?: string;
     checkout_url?: string;
     external_prices_url?: string;
@@ -45,13 +47,17 @@ interface Market extends Resource {
     tax_calculator?: TaxCalculator;
     customer_group?: CustomerGroup;
     attachments?: Attachment[];
+    versions?: Version[];
 }
 interface MarketCreate extends ResourceCreate {
     name: string;
+    code?: string;
     facebook_pixel_id?: string;
     checkout_url?: string;
     external_prices_url?: string;
     external_order_validation_url?: string;
+    _disable?: boolean;
+    _enable?: boolean;
     merchant: MerchantRel;
     price_list: PriceListRel;
     inventory_model: InventoryModelRel;
@@ -61,6 +67,7 @@ interface MarketCreate extends ResourceCreate {
 }
 interface MarketUpdate extends ResourceUpdate {
     name?: string;
+    code?: string;
     facebook_pixel_id?: string;
     checkout_url?: string;
     external_prices_url?: string;
@@ -88,6 +95,7 @@ declare class Markets extends ApiResource {
     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>>;
     isMarket(resource: any): resource is Market;
     relationship(id: string | ResourceId | null): MarketRel;
     type(): string;

package/lib/esm/resources/markets.js

@@ -44,6 +44,10 @@ class Markets extends 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);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isMarket(resource) {
         return resource.type && (resource.type === Markets.TYPE);

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

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Address } from './addresses';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type MerchantRel = ResourceRel & {
     type: typeof Merchants.TYPE;
 };
@@ -12,6 +13,7 @@ interface Merchant extends Resource {
     name?: string;
     address?: Address;
     attachments?: Attachment[];
+    versions?: Version[];
 }
 interface MerchantCreate extends ResourceCreate {
     name: string;
@@ -30,6 +32,7 @@ declare class Merchants extends ApiResource {
     delete(id: string, 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(): string;

package/lib/esm/resources/merchants.js

@@ -24,6 +24,10 @@ class Merchants extends 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);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isMerchant(resource) {
         return resource.type && (resource.type === Merchants.TYPE);

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

@@ -2,10 +2,12 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PercentageDiscountPromotion } from './percentage_discount_promotions';
 import type { FreeShippingPromotion } from './free_shipping_promotions';
+import type { BuyXPayYPromotion } from './buy_x_pay_y_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 OrderAmountPromotionRuleRel = ResourceRel & {
     type: typeof OrderAmountPromotionRules.TYPE;
 };
@@ -15,6 +17,9 @@ type PercentageDiscountPromotionRel = ResourceRel & {
 type FreeShippingPromotionRel = ResourceRel & {
     type: 'free_shipping_promotions';
 };
+type BuyXPayYPromotionRel = ResourceRel & {
+    type: 'buy_x_pay_y_promotions';
+};
 type FreeGiftPromotionRel = ResourceRel & {
     type: 'free_gift_promotions';
 };
@@ -31,15 +36,19 @@ interface OrderAmountPromotionRule extends Resource {
     order_amount_cents?: number;
     order_amount_float?: number;
     formatted_order_amount?: string;
-    promotion?: PercentageDiscountPromotion | FreeShippingPromotion | FreeGiftPromotion | FixedPricePromotion | ExternalPromotion | FixedAmountPromotion;
+    use_subtotal?: boolean;
+    promotion?: PercentageDiscountPromotion | FreeShippingPromotion | BuyXPayYPromotion | FreeGiftPromotion | FixedPricePromotion | ExternalPromotion | FixedAmountPromotion;
+    versions?: Version[];
 }
 interface OrderAmountPromotionRuleCreate extends ResourceCreate {
     order_amount_cents?: number;
-    promotion: PercentageDiscountPromotionRel | FreeShippingPromotionRel | FreeGiftPromotionRel | FixedPricePromotionRel | ExternalPromotionRel | FixedAmountPromotionRel;
+    use_subtotal?: boolean;
+    promotion: PercentageDiscountPromotionRel | FreeShippingPromotionRel | BuyXPayYPromotionRel | FreeGiftPromotionRel | FixedPricePromotionRel | ExternalPromotionRel | FixedAmountPromotionRel;
 }
 interface OrderAmountPromotionRuleUpdate extends ResourceUpdate {
     order_amount_cents?: number;
-    promotion?: PercentageDiscountPromotionRel | FreeShippingPromotionRel | FreeGiftPromotionRel | FixedPricePromotionRel | ExternalPromotionRel | FixedAmountPromotionRel;
+    use_subtotal?: boolean;
+    promotion?: PercentageDiscountPromotionRel | FreeShippingPromotionRel | BuyXPayYPromotionRel | FreeGiftPromotionRel | FixedPricePromotionRel | ExternalPromotionRel | FixedAmountPromotionRel;
 }
 declare class OrderAmountPromotionRules extends ApiResource {
     static readonly TYPE: 'order_amount_promotion_rules';
@@ -48,6 +57,7 @@ declare class OrderAmountPromotionRules extends ApiResource {
     retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderAmountPromotionRule>;
     update(resource: OrderAmountPromotionRuleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderAmountPromotionRule>;
     delete(id: string, 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(): string;

package/lib/esm/resources/order_amount_promotion_rules.js

@@ -16,6 +16,10 @@ class OrderAmountPromotionRules extends ApiResource {
     async delete(id, options) {
         await this.resources.delete({ 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);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isOrderAmountPromotionRule(resource) {
         return resource.type && (resource.type === OrderAmountPromotionRules.TYPE);

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

@@ -4,6 +4,7 @@ import type { OrderSubscription } from './order_subscriptions';
 import type { Adjustment } from './adjustments';
 import type { Bundle } from './bundles';
 import type { Sku } from './skus';
+import type { LineItem } from './line_items';
 type OrderSubscriptionItemRel = ResourceRel & {
     type: typeof OrderSubscriptionItems.TYPE;
 };
@@ -29,6 +30,9 @@ interface OrderSubscriptionItem extends Resource {
     formatted_total_amount?: string;
     order_subscription?: OrderSubscription;
     item?: Adjustment | Bundle | Sku;
+    sku?: Sku;
+    bundle?: Bundle;
+    source_line_item?: LineItem;
 }
 interface OrderSubscriptionItemCreate extends ResourceCreate {
     sku_code?: string;
@@ -37,6 +41,8 @@ interface OrderSubscriptionItemCreate extends ResourceCreate {
     unit_amount_cents?: number;
     order_subscription: OrderSubscriptionRel;
     item: AdjustmentRel | BundleRel | SkuRel;
+    sku?: SkuRel;
+    bundle?: BundleRel;
 }
 interface OrderSubscriptionItemUpdate extends ResourceUpdate {
     sku_code?: string;
@@ -52,6 +58,7 @@ declare class OrderSubscriptionItems extends ApiResource {
     update(resource: OrderSubscriptionItemUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscriptionItem>;
     delete(id: string, 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(): string;

package/lib/esm/resources/order_subscription_items.js

@@ -20,6 +20,10 @@ class OrderSubscriptionItems extends 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);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isOrderSubscriptionItem(resource) {
         return resource.type && (resource.type === OrderSubscriptionItems.TYPE);

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

@@ -9,6 +9,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 OrderSubscriptionRel = ResourceRel & {
     type: typeof OrderSubscriptions.TYPE;
 };
@@ -29,6 +30,7 @@ interface OrderSubscription extends Resource {
     customer_email?: string;
     starts_at?: string;
     expires_at?: string;
+    last_run_at?: string;
     next_run_at?: string;
     occurrencies?: number;
     errors_count?: number;
@@ -48,6 +50,7 @@ interface OrderSubscription extends Resource {
     recurring_order_copies?: RecurringOrderCopy[];
     orders?: Order[];
     events?: Event[];
+    versions?: Version[];
 }
 interface OrderSubscriptionCreate extends ResourceCreate {
     frequency: string;
@@ -84,6 +87,7 @@ declare class OrderSubscriptions extends ApiResource {
     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>>;
     isOrderSubscription(resource: any): resource is OrderSubscription;
     relationship(id: string | ResourceId | null): OrderSubscriptionRel;
     type(): string;

package/lib/esm/resources/order_subscriptions.js

@@ -56,6 +56,10 @@ class OrderSubscriptions extends 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);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isOrderSubscription(resource) {
         return resource.type && (resource.type === OrderSubscriptions.TYPE);

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

@@ -2,12 +2,14 @@ import { ApiResource, Resource, ResourcesConfig, ResourceId, ResourceRel, ListRe
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type OrderValidationRuleRel = ResourceRel & {
     type: typeof OrderValidationRules.TYPE;
 };
 interface OrderValidationRule extends Resource {
     market?: Market;
     attachments?: Attachment[];
+    versions?: Version[];
 }
 declare class OrderValidationRules extends ApiResource {
     static readonly TYPE: 'order_validation_rules';
@@ -15,6 +17,7 @@ declare class OrderValidationRules extends ApiResource {
     retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderValidationRule>;
     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(): string;

package/lib/esm/resources/order_validation_rules.js

@@ -15,6 +15,10 @@ class OrderValidationRules extends 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);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isOrderValidationRule(resource) {
         return resource.type && (resource.type === OrderValidationRules.TYPE);