ce-storefront 0.3.6 → 0.3.8

package/src/models/components/productdetail.ts

@@ -6,196 +6,23 @@ import * as z from "zod";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-
-export type BundleProduct2 = {};
-
-export type BundleProduct = BundleProduct2 | Array<any>;
-
-export type Product2 = {};
-
-export type ProductDetailProduct = Product2 | Array<any>;
-
-export type ProductDetail = Product2 | Array<any> | BundleProduct2 | Array<any>;
-
-/** @internal */
-export const BundleProduct2$inboundSchema: z.ZodType<
-  BundleProduct2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-/** @internal */
-export type BundleProduct2$Outbound = {};
-
-/** @internal */
-export const BundleProduct2$outboundSchema: z.ZodType<
-  BundleProduct2$Outbound,
-  z.ZodTypeDef,
-  BundleProduct2
-> = z.object({});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace BundleProduct2$ {
-  /** @deprecated use `BundleProduct2$inboundSchema` instead. */
-  export const inboundSchema = BundleProduct2$inboundSchema;
-  /** @deprecated use `BundleProduct2$outboundSchema` instead. */
-  export const outboundSchema = BundleProduct2$outboundSchema;
-  /** @deprecated use `BundleProduct2$Outbound` instead. */
-  export type Outbound = BundleProduct2$Outbound;
-}
-
-export function bundleProduct2ToJSON(bundleProduct2: BundleProduct2): string {
-  return JSON.stringify(BundleProduct2$outboundSchema.parse(bundleProduct2));
-}
-
-export function bundleProduct2FromJSON(
-  jsonString: string,
-): SafeParseResult<BundleProduct2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BundleProduct2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BundleProduct2' from JSON`,
-  );
-}
-
-/** @internal */
-export const BundleProduct$inboundSchema: z.ZodType<
-  BundleProduct,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.lazy(() => BundleProduct2$inboundSchema), z.array(z.any())]);
-
-/** @internal */
-export type BundleProduct$Outbound = BundleProduct2$Outbound | Array<any>;
-
-/** @internal */
-export const BundleProduct$outboundSchema: z.ZodType<
-  BundleProduct$Outbound,
-  z.ZodTypeDef,
-  BundleProduct
-> = z.union([z.lazy(() => BundleProduct2$outboundSchema), z.array(z.any())]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace BundleProduct$ {
-  /** @deprecated use `BundleProduct$inboundSchema` instead. */
-  export const inboundSchema = BundleProduct$inboundSchema;
-  /** @deprecated use `BundleProduct$outboundSchema` instead. */
-  export const outboundSchema = BundleProduct$outboundSchema;
-  /** @deprecated use `BundleProduct$Outbound` instead. */
-  export type Outbound = BundleProduct$Outbound;
-}
-
-export function bundleProductToJSON(bundleProduct: BundleProduct): string {
-  return JSON.stringify(BundleProduct$outboundSchema.parse(bundleProduct));
-}
-
-export function bundleProductFromJSON(
-  jsonString: string,
-): SafeParseResult<BundleProduct, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BundleProduct$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BundleProduct' from JSON`,
-  );
-}
-
-/** @internal */
-export const Product2$inboundSchema: z.ZodType<
-  Product2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-/** @internal */
-export type Product2$Outbound = {};
-
-/** @internal */
-export const Product2$outboundSchema: z.ZodType<
-  Product2$Outbound,
-  z.ZodTypeDef,
-  Product2
-> = z.object({});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Product2$ {
-  /** @deprecated use `Product2$inboundSchema` instead. */
-  export const inboundSchema = Product2$inboundSchema;
-  /** @deprecated use `Product2$outboundSchema` instead. */
-  export const outboundSchema = Product2$outboundSchema;
-  /** @deprecated use `Product2$Outbound` instead. */
-  export type Outbound = Product2$Outbound;
-}
-
-export function product2ToJSON(product2: Product2): string {
-  return JSON.stringify(Product2$outboundSchema.parse(product2));
-}
-
-export function product2FromJSON(
-  jsonString: string,
-): SafeParseResult<Product2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Product2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Product2' from JSON`,
-  );
-}
-
-/** @internal */
-export const ProductDetailProduct$inboundSchema: z.ZodType<
-  ProductDetailProduct,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.lazy(() => Product2$inboundSchema), z.array(z.any())]);
-
-/** @internal */
-export type ProductDetailProduct$Outbound = Product2$Outbound | Array<any>;
-
-/** @internal */
-export const ProductDetailProduct$outboundSchema: z.ZodType<
-  ProductDetailProduct$Outbound,
-  z.ZodTypeDef,
-  ProductDetailProduct
-> = z.union([z.lazy(() => Product2$outboundSchema), z.array(z.any())]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ProductDetailProduct$ {
-  /** @deprecated use `ProductDetailProduct$inboundSchema` instead. */
-  export const inboundSchema = ProductDetailProduct$inboundSchema;
-  /** @deprecated use `ProductDetailProduct$outboundSchema` instead. */
-  export const outboundSchema = ProductDetailProduct$outboundSchema;
-  /** @deprecated use `ProductDetailProduct$Outbound` instead. */
-  export type Outbound = ProductDetailProduct$Outbound;
-}
-
-export function productDetailProductToJSON(
-  productDetailProduct: ProductDetailProduct,
-): string {
-  return JSON.stringify(
-    ProductDetailProduct$outboundSchema.parse(productDetailProduct),
-  );
-}
-
-export function productDetailProductFromJSON(
-  jsonString: string,
-): SafeParseResult<ProductDetailProduct, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ProductDetailProduct$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ProductDetailProduct' from JSON`,
-  );
-}
+import {
+  BundleProductDetail,
+  BundleProductDetail$inboundSchema,
+  BundleProductDetail$Outbound,
+  BundleProductDetail$outboundSchema,
+} from "./bundleproductdetail.js";
+import {
+  SingleProductDetail,
+  SingleProductDetail$inboundSchema,
+  SingleProductDetail$Outbound,
+  SingleProductDetail$outboundSchema,
+} from "./singleproductdetail.js";
+
+export type ProductDetail =
+  | (SingleProductDetail & { productType: "physical" })
+  | (SingleProductDetail & { productType: "digital" })
+  | (BundleProductDetail & { productType: "bundle" });
 
 /** @internal */
 export const ProductDetail$inboundSchema: z.ZodType<
@@ -203,16 +30,28 @@ export const ProductDetail$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.union([z.lazy(() => Product2$inboundSchema), z.array(z.any())]),
-  z.union([z.lazy(() => BundleProduct2$inboundSchema), z.array(z.any())]),
+  SingleProductDetail$inboundSchema.and(
+    z.object({ product_type: z.literal("physical") }).transform((v) => ({
+      productType: v.product_type,
+    })),
+  ),
+  SingleProductDetail$inboundSchema.and(
+    z.object({ product_type: z.literal("digital") }).transform((v) => ({
+      productType: v.product_type,
+    })),
+  ),
+  BundleProductDetail$inboundSchema.and(
+    z.object({ product_type: z.literal("bundle") }).transform((v) => ({
+      productType: v.product_type,
+    })),
+  ),
 ]);
 
 /** @internal */
 export type ProductDetail$Outbound =
-  | Product2$Outbound
-  | Array<any>
-  | BundleProduct2$Outbound
-  | Array<any>;
+  | (SingleProductDetail$Outbound & { product_type: "physical" })
+  | (SingleProductDetail$Outbound & { product_type: "digital" })
+  | (BundleProductDetail$Outbound & { product_type: "bundle" });
 
 /** @internal */
 export const ProductDetail$outboundSchema: z.ZodType<
@@ -220,8 +59,21 @@ export const ProductDetail$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProductDetail
 > = z.union([
-  z.union([z.lazy(() => Product2$outboundSchema), z.array(z.any())]),
-  z.union([z.lazy(() => BundleProduct2$outboundSchema), z.array(z.any())]),
+  SingleProductDetail$outboundSchema.and(
+    z.object({ productType: z.literal("physical") }).transform((v) => ({
+      product_type: v.productType,
+    })),
+  ),
+  SingleProductDetail$outboundSchema.and(
+    z.object({ productType: z.literal("digital") }).transform((v) => ({
+      product_type: v.productType,
+    })),
+  ),
+  BundleProductDetail$outboundSchema.and(
+    z.object({ productType: z.literal("bundle") }).transform((v) => ({
+      product_type: v.productType,
+    })),
+  ),
 ]);
 
 /**

package/src/models/components/productlistresponse.ts

@@ -6,6 +6,12 @@ import * as z from "zod";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  BundleProduct,
+  BundleProduct$inboundSchema,
+  BundleProduct$Outbound,
+  BundleProduct$outboundSchema,
+} from "./bundleproduct.js";
 import {
   Pagination,
   Pagination$inboundSchema,
@@ -13,16 +19,16 @@ import {
   Pagination$outboundSchema,
 } from "./pagination.js";
 import {
-  Product,
-  Product$inboundSchema,
-  Product$Outbound,
-  Product$outboundSchema,
-} from "./product.js";
+  SingleProduct,
+  SingleProduct$inboundSchema,
+  SingleProduct$Outbound,
+  SingleProduct$outboundSchema,
+} from "./singleproduct.js";
 
-export type Products = Array<Product>;
+export type Products = SingleProduct | BundleProduct;
 
 export type ProductListResponse = {
-  products?: Array<Product> | undefined;
+  products?: Array<SingleProduct | BundleProduct> | undefined;
   /**
    * pagination metadata structure
    */
@@ -34,17 +40,17 @@ export const Products$inboundSchema: z.ZodType<
   Products,
   z.ZodTypeDef,
   unknown
-> = z.array(Product$inboundSchema);
+> = z.union([SingleProduct$inboundSchema, BundleProduct$inboundSchema]);
 
 /** @internal */
-export type Products$Outbound = Array<Product$Outbound>;
+export type Products$Outbound = SingleProduct$Outbound | BundleProduct$Outbound;
 
 /** @internal */
 export const Products$outboundSchema: z.ZodType<
   Products$Outbound,
   z.ZodTypeDef,
   Products
-> = z.array(Product$outboundSchema);
+> = z.union([SingleProduct$outboundSchema, BundleProduct$outboundSchema]);
 
 /**
  * @internal
@@ -79,13 +85,15 @@ export const ProductListResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  products: z.array(Product$inboundSchema).optional(),
+  products: z.array(
+    z.union([SingleProduct$inboundSchema, BundleProduct$inboundSchema]),
+  ).optional(),
   pagination: Pagination$inboundSchema.optional(),
 });
 
 /** @internal */
 export type ProductListResponse$Outbound = {
-  products?: Array<Product$Outbound> | undefined;
+  products?: Array<SingleProduct$Outbound | BundleProduct$Outbound> | undefined;
   pagination?: Pagination$Outbound | undefined;
 };
 
@@ -95,7 +103,9 @@ export const ProductListResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProductListResponse
 > = z.object({
-  products: z.array(Product$outboundSchema).optional(),
+  products: z.array(
+    z.union([SingleProduct$outboundSchema, BundleProduct$outboundSchema]),
+  ).optional(),
   pagination: Pagination$outboundSchema.optional(),
 });
 

package/src/models/components/productpricing.ts

@@ -15,12 +15,12 @@ export const TaxType = {
 export type TaxType = ClosedEnum<typeof TaxType>;
 
 export type ProductPricing = {
-  currency?: string | undefined;
-  taxType?: TaxType | undefined;
-  taxRate?: number | undefined;
-  priceIncludingTax?: boolean | undefined;
-  listingPrice?: number | undefined;
-  sellingPrice?: number | undefined;
+  currency: string;
+  taxType: TaxType;
+  taxRate: number;
+  priceIncludingTax: boolean;
+  listingPrice: number;
+  sellingPrice: number;
   minOrderQuantity?: number | undefined;
   maxOrderQuantity?: number | null | undefined;
   incrementalQuantity?: number | undefined;
@@ -52,12 +52,12 @@ export const ProductPricing$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  currency: z.string().optional(),
-  tax_type: TaxType$inboundSchema.optional(),
-  tax_rate: z.number().optional(),
-  price_including_tax: z.boolean().optional(),
-  listing_price: z.number().optional(),
-  selling_price: z.number().optional(),
+  currency: z.string(),
+  tax_type: TaxType$inboundSchema,
+  tax_rate: z.number(),
+  price_including_tax: z.boolean(),
+  listing_price: z.number(),
+  selling_price: z.number(),
   min_order_quantity: z.number().int().default(1),
   max_order_quantity: z.nullable(z.number().int()).optional(),
   incremental_quantity: z.number().int().default(1),
@@ -78,12 +78,12 @@ export const ProductPricing$inboundSchema: z.ZodType<
 
 /** @internal */
 export type ProductPricing$Outbound = {
-  currency?: string | undefined;
-  tax_type?: string | undefined;
-  tax_rate?: number | undefined;
-  price_including_tax?: boolean | undefined;
-  listing_price?: number | undefined;
-  selling_price?: number | undefined;
+  currency: string;
+  tax_type: string;
+  tax_rate: number;
+  price_including_tax: boolean;
+  listing_price: number;
+  selling_price: number;
   min_order_quantity: number;
   max_order_quantity?: number | null | undefined;
   incremental_quantity: number;
@@ -96,12 +96,12 @@ export const ProductPricing$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProductPricing
 > = z.object({
-  currency: z.string().optional(),
-  taxType: TaxType$outboundSchema.optional(),
-  taxRate: z.number().optional(),
-  priceIncludingTax: z.boolean().optional(),
-  listingPrice: z.number().optional(),
-  sellingPrice: z.number().optional(),
+  currency: z.string(),
+  taxType: TaxType$outboundSchema,
+  taxRate: z.number(),
+  priceIncludingTax: z.boolean(),
+  listingPrice: z.number(),
+  sellingPrice: z.number(),
   minOrderQuantity: z.number().int().default(1),
   maxOrderQuantity: z.nullable(z.number().int()).optional(),
   incrementalQuantity: z.number().int().default(1),

package/src/models/components/productshipping.ts

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