ce-storefront 0.13.0 → 0.13.2

package/src/index.ts

@@ -4,4 +4,6 @@
 
 export * from "./lib/config.js";
 export * as files from "./lib/files.js";
+export { HTTPClient } from "./lib/http.js";
+export type { Fetcher, HTTPClientOptions } from "./lib/http.js";
 export * from "./sdk/sdk.js";

package/src/lib/config.ts

@@ -80,7 +80,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0",
-  sdkVersion: "0.13.0",
-  genVersion: "2.616.1",
-  userAgent: "speakeasy-sdk/typescript 0.13.0 2.616.1 1.0 ce-storefront",
+  sdkVersion: "0.13.2",
+  genVersion: "2.620.2",
+  userAgent: "speakeasy-sdk/typescript 0.13.2 2.620.2 1.0 ce-storefront",
 } as const;

package/src/models/components/appliedpromotion.ts

@@ -9,21 +9,23 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const PromotionType = {
+export const AppliedPromotionPromotionType = {
   Discount: "discount",
   FreeGoods: "free-goods",
   FreeShipping: "free-shipping",
   BuyXGetY: "buy-x-get-y",
   VolumeBased: "volume-based",
 } as const;
-export type PromotionType = ClosedEnum<typeof PromotionType>;
+export type AppliedPromotionPromotionType = ClosedEnum<
+  typeof AppliedPromotionPromotionType
+>;
 
 /**
  * Details about an active promotion applied to a cart/order
  */
 export type AppliedPromotion = {
   promotionId: string;
-  promotionType: PromotionType;
+  promotionType: AppliedPromotionPromotionType;
   savings: number;
   productId: string | null;
   variantId: string | null;
@@ -34,24 +36,24 @@ export type AppliedPromotion = {
 };
 
 /** @internal */
-export const PromotionType$inboundSchema: z.ZodNativeEnum<
-  typeof PromotionType
-> = z.nativeEnum(PromotionType);
+export const AppliedPromotionPromotionType$inboundSchema: z.ZodNativeEnum<
+  typeof AppliedPromotionPromotionType
+> = z.nativeEnum(AppliedPromotionPromotionType);
 
 /** @internal */
-export const PromotionType$outboundSchema: z.ZodNativeEnum<
-  typeof PromotionType
-> = PromotionType$inboundSchema;
+export const AppliedPromotionPromotionType$outboundSchema: z.ZodNativeEnum<
+  typeof AppliedPromotionPromotionType
+> = AppliedPromotionPromotionType$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace PromotionType$ {
-  /** @deprecated use `PromotionType$inboundSchema` instead. */
-  export const inboundSchema = PromotionType$inboundSchema;
-  /** @deprecated use `PromotionType$outboundSchema` instead. */
-  export const outboundSchema = PromotionType$outboundSchema;
+export namespace AppliedPromotionPromotionType$ {
+  /** @deprecated use `AppliedPromotionPromotionType$inboundSchema` instead. */
+  export const inboundSchema = AppliedPromotionPromotionType$inboundSchema;
+  /** @deprecated use `AppliedPromotionPromotionType$outboundSchema` instead. */
+  export const outboundSchema = AppliedPromotionPromotionType$outboundSchema;
 }
 
 /** @internal */
@@ -61,7 +63,7 @@ export const AppliedPromotion$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   promotion_id: z.string(),
-  promotion_type: PromotionType$inboundSchema,
+  promotion_type: AppliedPromotionPromotionType$inboundSchema,
   savings: z.number(),
   product_id: z.nullable(z.string()),
   variant_id: z.nullable(z.string()),
@@ -101,7 +103,7 @@ export const AppliedPromotion$outboundSchema: z.ZodType<
   AppliedPromotion
 > = z.object({
   promotionId: z.string(),
-  promotionType: PromotionType$outboundSchema,
+  promotionType: AppliedPromotionPromotionType$outboundSchema,
   savings: z.number(),
   productId: z.nullable(z.string()),
   variantId: z.nullable(z.string()),

package/src/models/components/discountbasedpromotion.ts

@@ -9,6 +9,14 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export const PromotionType = {
+  Discount: "discount",
+  VolumeBased: "volume-based",
+  FixedPrice: "fixed-price",
+  FreeGoods: "free-goods",
+} as const;
+export type PromotionType = ClosedEnum<typeof PromotionType>;
+
 export const DiscountType = {
   Percentage: "percentage",
   FixedAmount: "fixed-amount",
@@ -28,6 +36,27 @@ export type DiscountBasedPromotion = {
   discountFixedAmount?: number | undefined;
 };
 
+/** @internal */
+export const PromotionType$inboundSchema: z.ZodNativeEnum<
+  typeof PromotionType
+> = z.nativeEnum(PromotionType);
+
+/** @internal */
+export const PromotionType$outboundSchema: z.ZodNativeEnum<
+  typeof PromotionType
+> = PromotionType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace PromotionType$ {
+  /** @deprecated use `PromotionType$inboundSchema` instead. */
+  export const inboundSchema = PromotionType$inboundSchema;
+  /** @deprecated use `PromotionType$outboundSchema` instead. */
+  export const outboundSchema = PromotionType$outboundSchema;
+}
+
 /** @internal */
 export const DiscountType$inboundSchema: z.ZodNativeEnum<typeof DiscountType> =
   z.nativeEnum(DiscountType);
@@ -80,7 +109,7 @@ export const DiscountBasedPromotion$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DiscountBasedPromotion
 > = z.object({
-  promotionType: z.literal("discount").default("discount" as const),
+  promotionType: z.literal("discount").default("discount"),
   discountType: DiscountType$outboundSchema,
   discountPercent: z.number().optional(),
   discountFixedAmount: z.number().int().optional(),

package/src/models/components/fixedpricepromotion.ts

@@ -5,21 +5,53 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export const FixedPricePromotionPromotionType = {
+  Discount: "discount",
+  VolumeBased: "volume-based",
+  FixedPrice: "fixed-price",
+  FreeGoods: "free-goods",
+} as const;
+export type FixedPricePromotionPromotionType = ClosedEnum<
+  typeof FixedPricePromotionPromotionType
+>;
+
 export type FixedPricePromotion = {
-  promotionType?: "discount" | undefined;
+  promotionType?: "fixed-price" | undefined;
   offerPrice: number;
 };
 
+/** @internal */
+export const FixedPricePromotionPromotionType$inboundSchema: z.ZodNativeEnum<
+  typeof FixedPricePromotionPromotionType
+> = z.nativeEnum(FixedPricePromotionPromotionType);
+
+/** @internal */
+export const FixedPricePromotionPromotionType$outboundSchema: z.ZodNativeEnum<
+  typeof FixedPricePromotionPromotionType
+> = FixedPricePromotionPromotionType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace FixedPricePromotionPromotionType$ {
+  /** @deprecated use `FixedPricePromotionPromotionType$inboundSchema` instead. */
+  export const inboundSchema = FixedPricePromotionPromotionType$inboundSchema;
+  /** @deprecated use `FixedPricePromotionPromotionType$outboundSchema` instead. */
+  export const outboundSchema = FixedPricePromotionPromotionType$outboundSchema;
+}
+
 /** @internal */
 export const FixedPricePromotion$inboundSchema: z.ZodType<
   FixedPricePromotion,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  promotion_type: z.literal("discount").optional(),
+  promotion_type: z.literal("fixed-price").optional(),
   offer_price: z.number(),
 }).transform((v) => {
   return remap$(v, {
@@ -30,7 +62,7 @@ export const FixedPricePromotion$inboundSchema: z.ZodType<
 
 /** @internal */
 export type FixedPricePromotion$Outbound = {
-  promotion_type: "discount";
+  promotion_type: "fixed-price";
   offer_price: number;
 };
 
@@ -40,7 +72,7 @@ export const FixedPricePromotion$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FixedPricePromotion
 > = z.object({
-  promotionType: z.literal("discount").default("discount" as const),
+  promotionType: z.literal("fixed-price").default("fixed-price"),
   offerPrice: z.number(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/freegoodspromotion.ts

@@ -5,9 +5,20 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export const FreeGoodsPromotionPromotionType = {
+  Discount: "discount",
+  VolumeBased: "volume-based",
+  FixedPrice: "fixed-price",
+  FreeGoods: "free-goods",
+} as const;
+export type FreeGoodsPromotionPromotionType = ClosedEnum<
+  typeof FreeGoodsPromotionPromotionType
+>;
+
 export type FreeGoodsPromotion = {
   promotionType?: "free-goods" | undefined;
   /**
@@ -20,6 +31,27 @@ export type FreeGoodsPromotion = {
   getQuantity: number;
 };
 
+/** @internal */
+export const FreeGoodsPromotionPromotionType$inboundSchema: z.ZodNativeEnum<
+  typeof FreeGoodsPromotionPromotionType
+> = z.nativeEnum(FreeGoodsPromotionPromotionType);
+
+/** @internal */
+export const FreeGoodsPromotionPromotionType$outboundSchema: z.ZodNativeEnum<
+  typeof FreeGoodsPromotionPromotionType
+> = FreeGoodsPromotionPromotionType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace FreeGoodsPromotionPromotionType$ {
+  /** @deprecated use `FreeGoodsPromotionPromotionType$inboundSchema` instead. */
+  export const inboundSchema = FreeGoodsPromotionPromotionType$inboundSchema;
+  /** @deprecated use `FreeGoodsPromotionPromotionType$outboundSchema` instead. */
+  export const outboundSchema = FreeGoodsPromotionPromotionType$outboundSchema;
+}
+
 /** @internal */
 export const FreeGoodsPromotion$inboundSchema: z.ZodType<
   FreeGoodsPromotion,
@@ -50,7 +82,7 @@ export const FreeGoodsPromotion$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FreeGoodsPromotion
 > = z.object({
-  promotionType: z.literal("free-goods").default("free-goods" as const),
+  promotionType: z.literal("free-goods").default("free-goods"),
   buyQuantity: z.number().int(),
   getQuantity: z.number().int(),
 }).transform((v) => {

package/src/models/components/item.ts

@@ -38,6 +38,12 @@ import {
   ProductPromotion$Outbound,
   ProductPromotion$outboundSchema,
 } from "./productpromotion.js";
+import {
+  ProductShipping,
+  ProductShipping$inboundSchema,
+  ProductShipping$Outbound,
+  ProductShipping$outboundSchema,
+} from "./productshipping.js";
 import {
   ProductSubscription,
   ProductSubscription$inboundSchema,
@@ -63,6 +69,10 @@ export type Item = {
   shortDescription: string | null;
   active: boolean;
   stockAvailable: boolean;
+  /**
+   * Indicates whether the item is being fulfilled as a backorder. When true, the item is not currently in stock and will ship later once inventory is available. This may result in the order being split into multiple shipments, with delays for the backordered portion.
+   */
+  backorder?: boolean | undefined;
   /**
    * Indicates whether this item is associated with any active (product-specific) coupons
    */
@@ -79,6 +89,7 @@ export type Item = {
   promotion: ProductPromotion | null;
   subscription: Array<ProductSubscription>;
   associatedOptions: { [k: string]: AssociatedOption } | null;
+  shipping?: ProductShipping | null | undefined;
 };
 
 /** @internal */
@@ -115,6 +126,7 @@ export const Item$inboundSchema: z.ZodType<Item, z.ZodTypeDef, unknown> = z
     short_description: z.nullable(z.string()),
     active: z.boolean(),
     stock_available: z.boolean(),
+    backorder: z.boolean().optional(),
     on_offer: z.boolean(),
     on_subscription: z.boolean(),
     on_promotion: z.boolean(),
@@ -128,6 +140,7 @@ export const Item$inboundSchema: z.ZodType<Item, z.ZodTypeDef, unknown> = z
     promotion: z.nullable(ProductPromotion$inboundSchema),
     subscription: z.array(ProductSubscription$inboundSchema),
     associated_options: z.nullable(z.record(AssociatedOption$inboundSchema)),
+    shipping: z.nullable(ProductShipping$inboundSchema).optional(),
   }).transform((v) => {
     return remap$(v, {
       "product_id": "productId",
@@ -159,6 +172,7 @@ export type Item$Outbound = {
   short_description: string | null;
   active: boolean;
   stock_available: boolean;
+  backorder?: boolean | undefined;
   on_offer: boolean;
   on_subscription: boolean;
   on_promotion: boolean;
@@ -172,6 +186,7 @@ export type Item$Outbound = {
   promotion: ProductPromotion$Outbound | null;
   subscription: Array<ProductSubscription$Outbound>;
   associated_options: { [k: string]: AssociatedOption$Outbound } | null;
+  shipping?: ProductShipping$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -187,6 +202,7 @@ export const Item$outboundSchema: z.ZodType<Item$Outbound, z.ZodTypeDef, Item> =
     shortDescription: z.nullable(z.string()),
     active: z.boolean(),
     stockAvailable: z.boolean(),
+    backorder: z.boolean().optional(),
     onOffer: z.boolean(),
     onSubscription: z.boolean(),
     onPromotion: z.boolean(),
@@ -200,6 +216,7 @@ export const Item$outboundSchema: z.ZodType<Item$Outbound, z.ZodTypeDef, Item> =
     promotion: z.nullable(ProductPromotion$outboundSchema),
     subscription: z.array(ProductSubscription$outboundSchema),
     associatedOptions: z.nullable(z.record(AssociatedOption$outboundSchema)),
+    shipping: z.nullable(ProductShipping$outboundSchema).optional(),
   }).transform((v) => {
     return remap$(v, {
       productId: "product_id",

package/src/models/components/product.ts

@@ -79,6 +79,10 @@ export type Product = {
    * Indicates whether the product has stock available
    */
   stockAvailable: boolean;
+  /**
+   * Indicates whether the item is being fulfilled as a backorder. When true, the item is not currently in stock and will ship later once inventory is available. This may result in the order being split into multiple shipments, with delays for the backordered portion.
+   */
+  backorder?: boolean | undefined;
   /**
    * Indicates whether this item is associated with any active (product-specific) coupons
    */
@@ -142,6 +146,7 @@ export const Product$inboundSchema: z.ZodType<Product, z.ZodTypeDef, unknown> =
     product_type: ProductType$inboundSchema,
     active: z.boolean(),
     stock_available: z.boolean(),
+    backorder: z.boolean().optional(),
     on_offer: z.boolean(),
     on_subscription: z.boolean(),
     on_promotion: z.boolean(),
@@ -185,6 +190,7 @@ export type Product$Outbound = {
   product_type: string;
   active: boolean;
   stock_available: boolean;
+  backorder?: boolean | undefined;
   on_offer: boolean;
   on_subscription: boolean;
   on_promotion: boolean;
@@ -217,6 +223,7 @@ export const Product$outboundSchema: z.ZodType<
   productType: ProductType$outboundSchema,
   active: z.boolean(),
   stockAvailable: z.boolean(),
+  backorder: z.boolean().optional(),
   onOffer: z.boolean(),
   onSubscription: z.boolean(),
   onPromotion: z.boolean(),

package/src/models/components/productbundleitem.ts

@@ -38,6 +38,12 @@ import {
   ProductPromotion$Outbound,
   ProductPromotion$outboundSchema,
 } from "./productpromotion.js";
+import {
+  ProductShipping,
+  ProductShipping$inboundSchema,
+  ProductShipping$Outbound,
+  ProductShipping$outboundSchema,
+} from "./productshipping.js";
 import {
   ProductSubscription,
   ProductSubscription$inboundSchema,
@@ -66,6 +72,10 @@ export type ProductBundleItem = {
   shortDescription: string | null;
   active: boolean;
   stockAvailable: boolean;
+  /**
+   * Indicates whether the item is being fulfilled as a backorder. When true, the item is not currently in stock and will ship later once inventory is available. This may result in the order being split into multiple shipments, with delays for the backordered portion.
+   */
+  backorder?: boolean | undefined;
   /**
    * Indicates whether this item is associated with any active (product-specific) coupons
    */
@@ -82,6 +92,7 @@ export type ProductBundleItem = {
   promotion: ProductPromotion | null;
   subscription: Array<ProductSubscription>;
   associatedOptions: { [k: string]: AssociatedOption } | null;
+  shipping?: ProductShipping | null | undefined;
 };
 
 /** @internal */
@@ -122,6 +133,7 @@ export const ProductBundleItem$inboundSchema: z.ZodType<
   short_description: z.nullable(z.string()),
   active: z.boolean(),
   stock_available: z.boolean(),
+  backorder: z.boolean().optional(),
   on_offer: z.boolean(),
   on_subscription: z.boolean(),
   on_promotion: z.boolean(),
@@ -135,6 +147,7 @@ export const ProductBundleItem$inboundSchema: z.ZodType<
   promotion: z.nullable(ProductPromotion$inboundSchema),
   subscription: z.array(ProductSubscription$inboundSchema),
   associated_options: z.nullable(z.record(AssociatedOption$inboundSchema)),
+  shipping: z.nullable(ProductShipping$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "product_id": "productId",
@@ -167,6 +180,7 @@ export type ProductBundleItem$Outbound = {
   short_description: string | null;
   active: boolean;
   stock_available: boolean;
+  backorder?: boolean | undefined;
   on_offer: boolean;
   on_subscription: boolean;
   on_promotion: boolean;
@@ -180,6 +194,7 @@ export type ProductBundleItem$Outbound = {
   promotion: ProductPromotion$Outbound | null;
   subscription: Array<ProductSubscription$Outbound>;
   associated_options: { [k: string]: AssociatedOption$Outbound } | null;
+  shipping?: ProductShipping$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -199,6 +214,7 @@ export const ProductBundleItem$outboundSchema: z.ZodType<
   shortDescription: z.nullable(z.string()),
   active: z.boolean(),
   stockAvailable: z.boolean(),
+  backorder: z.boolean().optional(),
   onOffer: z.boolean(),
   onSubscription: z.boolean(),
   onPromotion: z.boolean(),
@@ -212,6 +228,7 @@ export const ProductBundleItem$outboundSchema: z.ZodType<
   promotion: z.nullable(ProductPromotion$outboundSchema),
   subscription: z.array(ProductSubscription$outboundSchema),
   associatedOptions: z.nullable(z.record(AssociatedOption$outboundSchema)),
+  shipping: z.nullable(ProductShipping$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     productId: "product_id",

package/src/models/components/productdetail.ts

@@ -99,6 +99,10 @@ export type ProductDetail = {
    * Indicates whether the product has stock available
    */
   stockAvailable: boolean;
+  /**
+   * Indicates whether the item is being fulfilled as a backorder. When true, the item is not currently in stock and will ship later once inventory is available. This may result in the order being split into multiple shipments, with delays for the backordered portion.
+   */
+  backorder?: boolean | undefined;
   /**
    * Indicates whether this item is associated with any active (product-specific) coupons
    */
@@ -181,6 +185,7 @@ export const ProductDetail$inboundSchema: z.ZodType<
   product_type: ProductDetailProductType$inboundSchema,
   active: z.boolean(),
   stock_available: z.boolean(),
+  backorder: z.boolean().optional(),
   on_offer: z.boolean(),
   on_subscription: z.boolean(),
   on_promotion: z.boolean(),
@@ -235,6 +240,7 @@ export type ProductDetail$Outbound = {
   product_type: string;
   active: boolean;
   stock_available: boolean;
+  backorder?: boolean | undefined;
   on_offer: boolean;
   on_subscription: boolean;
   on_promotion: boolean;
@@ -275,6 +281,7 @@ export const ProductDetail$outboundSchema: z.ZodType<
   productType: ProductDetailProductType$outboundSchema,
   active: z.boolean(),
   stockAvailable: z.boolean(),
+  backorder: z.boolean().optional(),
   onOffer: z.boolean(),
   onSubscription: z.boolean(),
   onPromotion: z.boolean(),

package/src/models/components/productshipping.ts

@@ -9,14 +9,10 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ProductShipping = {
-  additionalCost: number | null;
-  shippingPriceIncludingTax: boolean;
-  availabilityDescription: string | null;
-  shipsInternationally?: boolean | undefined;
-  midCode: string | null;
-  countryOfOrigin?: string | null | undefined;
-  taxType: string | null;
-  taxRate: number | null;
+  handlingChargesIncludingTax: number;
+  handlingChargesExcludingTax: number;
+  taxType: string;
+  taxRate: number;
 };
 
 /** @internal */
@@ -25,22 +21,14 @@ export const ProductShipping$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  additional_cost: z.nullable(z.number()),
-  shipping_price_including_tax: z.boolean(),
-  availability_description: z.nullable(z.string()),
-  ships_internationally: z.boolean().default(false),
-  mid_code: z.nullable(z.string()),
-  country_of_origin: z.nullable(z.string().default("India")),
-  tax_type: z.nullable(z.string()),
-  tax_rate: z.nullable(z.number()),
+  handling_charges_including_tax: z.number(),
+  handling_charges_excluding_tax: z.number(),
+  tax_type: z.string(),
+  tax_rate: z.number(),
 }).transform((v) => {
   return remap$(v, {
-    "additional_cost": "additionalCost",
-    "shipping_price_including_tax": "shippingPriceIncludingTax",
-    "availability_description": "availabilityDescription",
-    "ships_internationally": "shipsInternationally",
-    "mid_code": "midCode",
-    "country_of_origin": "countryOfOrigin",
+    "handling_charges_including_tax": "handlingChargesIncludingTax",
+    "handling_charges_excluding_tax": "handlingChargesExcludingTax",
     "tax_type": "taxType",
     "tax_rate": "taxRate",
   });
@@ -48,14 +36,10 @@ export const ProductShipping$inboundSchema: z.ZodType<
 
 /** @internal */
 export type ProductShipping$Outbound = {
-  additional_cost: number | null;
-  shipping_price_including_tax: boolean;
-  availability_description: string | null;
-  ships_internationally: boolean;
-  mid_code: string | null;
-  country_of_origin: string | null;
-  tax_type: string | null;
-  tax_rate: number | null;
+  handling_charges_including_tax: number;
+  handling_charges_excluding_tax: number;
+  tax_type: string;
+  tax_rate: number;
 };
 
 /** @internal */
@@ -64,22 +48,14 @@ export const ProductShipping$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProductShipping
 > = z.object({
-  additionalCost: z.nullable(z.number()),
-  shippingPriceIncludingTax: z.boolean(),
-  availabilityDescription: z.nullable(z.string()),
-  shipsInternationally: z.boolean().default(false),
-  midCode: z.nullable(z.string()),
-  countryOfOrigin: z.nullable(z.string().default("India")),
-  taxType: z.nullable(z.string()),
-  taxRate: z.nullable(z.number()),
+  handlingChargesIncludingTax: z.number(),
+  handlingChargesExcludingTax: z.number(),
+  taxType: z.string(),
+  taxRate: z.number(),
 }).transform((v) => {
   return remap$(v, {
-    additionalCost: "additional_cost",
-    shippingPriceIncludingTax: "shipping_price_including_tax",
-    availabilityDescription: "availability_description",
-    shipsInternationally: "ships_internationally",
-    midCode: "mid_code",
-    countryOfOrigin: "country_of_origin",
+    handlingChargesIncludingTax: "handling_charges_including_tax",
+    handlingChargesExcludingTax: "handling_charges_excluding_tax",
     taxType: "tax_type",
     taxRate: "tax_rate",
   });

package/src/models/components/variant.ts

@@ -63,6 +63,10 @@ export type Variant = {
   shortDescription: string | null;
   active: boolean;
   stockAvailable: boolean;
+  /**
+   * Indicates whether the item is being fulfilled as a backorder. When true, the item is not currently in stock and will ship later once inventory is available. This may result in the order being split into multiple shipments, with delays for the backordered portion.
+   */
+  backorder?: boolean | undefined;
   /**
    * Indicates whether this item is associated with any active (product-specific) coupons
    */
@@ -95,6 +99,7 @@ export const Variant$inboundSchema: z.ZodType<Variant, z.ZodTypeDef, unknown> =
     short_description: z.nullable(z.string()),
     active: z.boolean(),
     stock_available: z.boolean(),
+    backorder: z.boolean().optional(),
     on_offer: z.boolean(),
     on_promotion: z.boolean(),
     on_subscription: z.boolean(),
@@ -129,6 +134,7 @@ export type Variant$Outbound = {
   short_description: string | null;
   active: boolean;
   stock_available: boolean;
+  backorder?: boolean | undefined;
   on_offer: boolean;
   on_promotion: boolean;
   on_subscription: boolean;
@@ -155,6 +161,7 @@ export const Variant$outboundSchema: z.ZodType<
   shortDescription: z.nullable(z.string()),
   active: z.boolean(),
   stockAvailable: z.boolean(),
+  backorder: z.boolean().optional(),
   onOffer: z.boolean(),
   onPromotion: z.boolean(),
   onSubscription: z.boolean(),

package/src/models/components/variantdetail.ts

@@ -103,6 +103,10 @@ export type VariantDetail = {
   shortDescription: string | null;
   active: boolean;
   stockAvailable: boolean;
+  /**
+   * Indicates whether the item is being fulfilled as a backorder. When true, the item is not currently in stock and will ship later once inventory is available. This may result in the order being split into multiple shipments, with delays for the backordered portion.
+   */
+  backorder?: boolean | undefined;
   /**
    * Indicates whether this item is associated with any active (product-specific) coupons
    */
@@ -173,6 +177,7 @@ export const VariantDetail$inboundSchema: z.ZodType<
   short_description: z.nullable(z.string()),
   active: z.boolean(),
   stock_available: z.boolean(),
+  backorder: z.boolean().optional(),
   on_offer: z.boolean(),
   on_promotion: z.boolean(),
   on_subscription: z.boolean(),
@@ -229,6 +234,7 @@ export type VariantDetail$Outbound = {
   short_description: string | null;
   active: boolean;
   stock_available: boolean;
+  backorder?: boolean | undefined;
   on_offer: boolean;
   on_promotion: boolean;
   on_subscription: boolean;
@@ -269,6 +275,7 @@ export const VariantDetail$outboundSchema: z.ZodType<
   shortDescription: z.nullable(z.string()),
   active: z.boolean(),
   stockAvailable: z.boolean(),
+  backorder: z.boolean().optional(),
   onOffer: z.boolean(),
   onPromotion: z.boolean(),
   onSubscription: z.boolean(),