ce-storefront 0.3.4 → 0.3.6

package/src/models/components/productlistresponse.ts

@@ -13,33 +13,79 @@ import {
   Pagination$outboundSchema,
 } from "./pagination.js";
 import {
-  ProductList,
-  ProductList$inboundSchema,
-  ProductList$Outbound,
-  ProductList$outboundSchema,
-} from "./productlist.js";
+  Product,
+  Product$inboundSchema,
+  Product$Outbound,
+  Product$outboundSchema,
+} from "./product.js";
+
+export type Products = Array<Product>;
 
 export type ProductListResponse = {
-  products?: Array<ProductList> | undefined;
+  products?: Array<Product> | undefined;
   /**
    * pagination metadata structure
    */
   pagination?: Pagination | undefined;
 };
 
+/** @internal */
+export const Products$inboundSchema: z.ZodType<
+  Products,
+  z.ZodTypeDef,
+  unknown
+> = z.array(Product$inboundSchema);
+
+/** @internal */
+export type Products$Outbound = Array<Product$Outbound>;
+
+/** @internal */
+export const Products$outboundSchema: z.ZodType<
+  Products$Outbound,
+  z.ZodTypeDef,
+  Products
+> = z.array(Product$outboundSchema);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Products$ {
+  /** @deprecated use `Products$inboundSchema` instead. */
+  export const inboundSchema = Products$inboundSchema;
+  /** @deprecated use `Products$outboundSchema` instead. */
+  export const outboundSchema = Products$outboundSchema;
+  /** @deprecated use `Products$Outbound` instead. */
+  export type Outbound = Products$Outbound;
+}
+
+export function productsToJSON(products: Products): string {
+  return JSON.stringify(Products$outboundSchema.parse(products));
+}
+
+export function productsFromJSON(
+  jsonString: string,
+): SafeParseResult<Products, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Products$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Products' from JSON`,
+  );
+}
+
 /** @internal */
 export const ProductListResponse$inboundSchema: z.ZodType<
   ProductListResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  products: z.array(ProductList$inboundSchema).optional(),
+  products: z.array(Product$inboundSchema).optional(),
   pagination: Pagination$inboundSchema.optional(),
 });
 
 /** @internal */
 export type ProductListResponse$Outbound = {
-  products?: Array<ProductList$Outbound> | undefined;
+  products?: Array<Product$Outbound> | undefined;
   pagination?: Pagination$Outbound | undefined;
 };
 
@@ -49,7 +95,7 @@ export const ProductListResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ProductListResponse
 > = z.object({
-  products: z.array(ProductList$outboundSchema).optional(),
+  products: z.array(Product$outboundSchema).optional(),
   pagination: Pagination$outboundSchema.optional(),
 });
 

package/src/models/components/productshipping.ts

@@ -15,7 +15,6 @@ export type ProductShipping = {
   shipsInternationally?: boolean | undefined;
   midCode?: string | undefined;
   countryOfOrigin?: string | undefined;
-  taxRegion?: string | undefined;
   taxType?: string | undefined;
   taxRate?: number | undefined;
 };
@@ -32,7 +31,6 @@ export const ProductShipping$inboundSchema: z.ZodType<
   ships_internationally: z.boolean().optional(),
   mid_code: z.string().optional(),
   country_of_origin: z.string().default("India"),
-  tax_region: z.string().optional(),
   tax_type: z.string().optional(),
   tax_rate: z.number().optional(),
 }).transform((v) => {
@@ -43,7 +41,6 @@ export const ProductShipping$inboundSchema: z.ZodType<
     "ships_internationally": "shipsInternationally",
     "mid_code": "midCode",
     "country_of_origin": "countryOfOrigin",
-    "tax_region": "taxRegion",
     "tax_type": "taxType",
     "tax_rate": "taxRate",
   });
@@ -57,7 +54,6 @@ export type ProductShipping$Outbound = {
   ships_internationally?: boolean | undefined;
   mid_code?: string | undefined;
   country_of_origin: string;
-  tax_region?: string | undefined;
   tax_type?: string | undefined;
   tax_rate?: number | undefined;
 };
@@ -74,7 +70,6 @@ export const ProductShipping$outboundSchema: z.ZodType<
   shipsInternationally: z.boolean().optional(),
   midCode: z.string().optional(),
   countryOfOrigin: z.string().default("India"),
-  taxRegion: z.string().optional(),
   taxType: z.string().optional(),
   taxRate: z.number().optional(),
 }).transform((v) => {
@@ -85,7 +80,6 @@ export const ProductShipping$outboundSchema: z.ZodType<
     shipsInternationally: "ships_internationally",
     midCode: "mid_code",
     countryOfOrigin: "country_of_origin",
-    taxRegion: "tax_region",
     taxType: "tax_type",
     taxRate: "tax_rate",
   });

package/src/models/components/{promotion.ts → promotiondetail.ts}

@@ -17,18 +17,18 @@ export const PromotionType = {
 } as const;
 export type PromotionType = ClosedEnum<typeof PromotionType>;
 
-export type PromotionDetails = {};
+export type PromotionDetailDetails = {};
 
 /**
  * promotion model
  */
-export type Promotion = {
+export type PromotionDetail = {
   id?: string | undefined;
   name?: string | undefined;
   description?: string | undefined;
   promotionType?: PromotionType | undefined;
   tags?: Array<string> | undefined;
-  details?: PromotionDetails | undefined;
+  details?: PromotionDetailDetails | undefined;
   hasRedemptionLimit?: boolean | undefined;
   redemptionLimit?: number | undefined;
   redemptionCount?: number | undefined;
@@ -64,56 +64,56 @@ export namespace PromotionType$ {
 }
 
 /** @internal */
-export const PromotionDetails$inboundSchema: z.ZodType<
-  PromotionDetails,
+export const PromotionDetailDetails$inboundSchema: z.ZodType<
+  PromotionDetailDetails,
   z.ZodTypeDef,
   unknown
 > = z.object({});
 
 /** @internal */
-export type PromotionDetails$Outbound = {};
+export type PromotionDetailDetails$Outbound = {};
 
 /** @internal */
-export const PromotionDetails$outboundSchema: z.ZodType<
-  PromotionDetails$Outbound,
+export const PromotionDetailDetails$outboundSchema: z.ZodType<
+  PromotionDetailDetails$Outbound,
   z.ZodTypeDef,
-  PromotionDetails
+  PromotionDetailDetails
 > = 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 PromotionDetails$ {
-  /** @deprecated use `PromotionDetails$inboundSchema` instead. */
-  export const inboundSchema = PromotionDetails$inboundSchema;
-  /** @deprecated use `PromotionDetails$outboundSchema` instead. */
-  export const outboundSchema = PromotionDetails$outboundSchema;
-  /** @deprecated use `PromotionDetails$Outbound` instead. */
-  export type Outbound = PromotionDetails$Outbound;
+export namespace PromotionDetailDetails$ {
+  /** @deprecated use `PromotionDetailDetails$inboundSchema` instead. */
+  export const inboundSchema = PromotionDetailDetails$inboundSchema;
+  /** @deprecated use `PromotionDetailDetails$outboundSchema` instead. */
+  export const outboundSchema = PromotionDetailDetails$outboundSchema;
+  /** @deprecated use `PromotionDetailDetails$Outbound` instead. */
+  export type Outbound = PromotionDetailDetails$Outbound;
 }
 
-export function promotionDetailsToJSON(
-  promotionDetails: PromotionDetails,
+export function promotionDetailDetailsToJSON(
+  promotionDetailDetails: PromotionDetailDetails,
 ): string {
   return JSON.stringify(
-    PromotionDetails$outboundSchema.parse(promotionDetails),
+    PromotionDetailDetails$outboundSchema.parse(promotionDetailDetails),
   );
 }
 
-export function promotionDetailsFromJSON(
+export function promotionDetailDetailsFromJSON(
   jsonString: string,
-): SafeParseResult<PromotionDetails, SDKValidationError> {
+): SafeParseResult<PromotionDetailDetails, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PromotionDetails$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PromotionDetails' from JSON`,
+    (x) => PromotionDetailDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromotionDetailDetails' from JSON`,
   );
 }
 
 /** @internal */
-export const Promotion$inboundSchema: z.ZodType<
-  Promotion,
+export const PromotionDetail$inboundSchema: z.ZodType<
+  PromotionDetail,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -122,7 +122,7 @@ export const Promotion$inboundSchema: z.ZodType<
   description: z.string().optional(),
   promotion_type: PromotionType$inboundSchema.optional(),
   tags: z.array(z.string()).optional(),
-  details: z.lazy(() => PromotionDetails$inboundSchema).optional(),
+  details: z.lazy(() => PromotionDetailDetails$inboundSchema).optional(),
   has_redemption_limit: z.boolean().optional(),
   redemption_limit: z.number().int().optional(),
   redemption_count: z.number().int().optional(),
@@ -157,13 +157,13 @@ export const Promotion$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type Promotion$Outbound = {
+export type PromotionDetail$Outbound = {
   id?: string | undefined;
   name?: string | undefined;
   description?: string | undefined;
   promotion_type?: string | undefined;
   tags?: Array<string> | undefined;
-  details?: PromotionDetails$Outbound | undefined;
+  details?: PromotionDetailDetails$Outbound | undefined;
   has_redemption_limit?: boolean | undefined;
   redemption_limit?: number | undefined;
   redemption_count?: number | undefined;
@@ -178,17 +178,17 @@ export type Promotion$Outbound = {
 };
 
 /** @internal */
-export const Promotion$outboundSchema: z.ZodType<
-  Promotion$Outbound,
+export const PromotionDetail$outboundSchema: z.ZodType<
+  PromotionDetail$Outbound,
   z.ZodTypeDef,
-  Promotion
+  PromotionDetail
 > = z.object({
   id: z.string().optional(),
   name: z.string().optional(),
   description: z.string().optional(),
   promotionType: PromotionType$outboundSchema.optional(),
   tags: z.array(z.string()).optional(),
-  details: z.lazy(() => PromotionDetails$outboundSchema).optional(),
+  details: z.lazy(() => PromotionDetailDetails$outboundSchema).optional(),
   hasRedemptionLimit: z.boolean().optional(),
   redemptionLimit: z.number().int().optional(),
   redemptionCount: z.number().int().optional(),
@@ -221,25 +221,27 @@ export const Promotion$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Promotion$ {
-  /** @deprecated use `Promotion$inboundSchema` instead. */
-  export const inboundSchema = Promotion$inboundSchema;
-  /** @deprecated use `Promotion$outboundSchema` instead. */
-  export const outboundSchema = Promotion$outboundSchema;
-  /** @deprecated use `Promotion$Outbound` instead. */
-  export type Outbound = Promotion$Outbound;
+export namespace PromotionDetail$ {
+  /** @deprecated use `PromotionDetail$inboundSchema` instead. */
+  export const inboundSchema = PromotionDetail$inboundSchema;
+  /** @deprecated use `PromotionDetail$outboundSchema` instead. */
+  export const outboundSchema = PromotionDetail$outboundSchema;
+  /** @deprecated use `PromotionDetail$Outbound` instead. */
+  export type Outbound = PromotionDetail$Outbound;
 }
 
-export function promotionToJSON(promotion: Promotion): string {
-  return JSON.stringify(Promotion$outboundSchema.parse(promotion));
+export function promotionDetailToJSON(
+  promotionDetail: PromotionDetail,
+): string {
+  return JSON.stringify(PromotionDetail$outboundSchema.parse(promotionDetail));
 }
 
-export function promotionFromJSON(
+export function promotionDetailFromJSON(
   jsonString: string,
-): SafeParseResult<Promotion, SDKValidationError> {
+): SafeParseResult<PromotionDetail, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Promotion$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Promotion' from JSON`,
+    (x) => PromotionDetail$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromotionDetail' from JSON`,
   );
 }

package/src/models/components/seo.ts

@@ -3,54 +3,41 @@
  */
 
 import * as z from "zod";
-import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Seo = {
-  metaTitle?: string | undefined;
-  metaDescription?: string | undefined;
-  metaKeywords?: Array<string> | undefined;
   slug?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  keywords?: Array<string> | undefined;
 };
 
 /** @internal */
 export const Seo$inboundSchema: z.ZodType<Seo, z.ZodTypeDef, unknown> = z
   .object({
-    meta_title: z.string().optional(),
-    meta_description: z.string().optional(),
-    meta_keywords: z.array(z.string()).optional(),
     slug: z.string().optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      "meta_title": "metaTitle",
-      "meta_description": "metaDescription",
-      "meta_keywords": "metaKeywords",
-    });
+    title: z.string().optional(),
+    description: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
   });
 
 /** @internal */
 export type Seo$Outbound = {
-  meta_title?: string | undefined;
-  meta_description?: string | undefined;
-  meta_keywords?: Array<string> | undefined;
   slug?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  keywords?: Array<string> | undefined;
 };
 
 /** @internal */
 export const Seo$outboundSchema: z.ZodType<Seo$Outbound, z.ZodTypeDef, Seo> = z
   .object({
-    metaTitle: z.string().optional(),
-    metaDescription: z.string().optional(),
-    metaKeywords: z.array(z.string()).optional(),
     slug: z.string().optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      metaTitle: "meta_title",
-      metaDescription: "meta_description",
-      metaKeywords: "meta_keywords",
-    });
+    title: z.string().optional(),
+    description: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
   });
 
 /**

package/src/models/components/sku.ts

@@ -0,0 +1,244 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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";
+import {
+  AssociatedOption,
+  AssociatedOption$inboundSchema,
+  AssociatedOption$Outbound,
+  AssociatedOption$outboundSchema,
+} from "./associatedoption.js";
+import {
+  ProductAttribute,
+  ProductAttribute$inboundSchema,
+  ProductAttribute$Outbound,
+  ProductAttribute$outboundSchema,
+} from "./productattribute.js";
+import {
+  ProductImage,
+  ProductImage$inboundSchema,
+  ProductImage$Outbound,
+  ProductImage$outboundSchema,
+} from "./productimage.js";
+import {
+  ProductPricing,
+  ProductPricing$inboundSchema,
+  ProductPricing$Outbound,
+  ProductPricing$outboundSchema,
+} from "./productpricing.js";
+import {
+  ProductPromotion,
+  ProductPromotion$inboundSchema,
+  ProductPromotion$Outbound,
+  ProductPromotion$outboundSchema,
+} from "./productpromotion.js";
+import {
+  ProductSubscription,
+  ProductSubscription$inboundSchema,
+  ProductSubscription$Outbound,
+  ProductSubscription$outboundSchema,
+} from "./productsubscription.js";
+
+export const SKUProductType = {
+  Physical: "physical",
+  Digital: "digital",
+  Bundle: "bundle",
+} as const;
+export type SKUProductType = ClosedEnum<typeof SKUProductType>;
+
+export type Sku = {
+  productId: string;
+  variantId?: string | null | undefined;
+  sku: string;
+  productName: string;
+  variantName?: string | null | undefined;
+  productType: SKUProductType;
+  slug?: string | undefined;
+  shortDescription?: string | undefined;
+  active?: boolean | undefined;
+  stockAvailable?: boolean | undefined;
+  onOffer?: boolean | undefined;
+  onSubscription?: boolean | undefined;
+  onPromotion?: boolean | undefined;
+  categoryIds?: Array<string> | undefined;
+  tags?: Array<string> | undefined;
+  reviewsCount?: number | undefined;
+  reviewsRatingSum?: number | undefined;
+  attributes?: Array<ProductAttribute> | undefined;
+  images?: Array<ProductImage> | undefined;
+  pricing?: ProductPricing | undefined;
+  promotion?: ProductPromotion | null | undefined;
+  subscription?: Array<ProductSubscription> | undefined;
+  associatedOptions?: { [k: string]: AssociatedOption } | undefined;
+};
+
+/** @internal */
+export const SKUProductType$inboundSchema: z.ZodNativeEnum<
+  typeof SKUProductType
+> = z.nativeEnum(SKUProductType);
+
+/** @internal */
+export const SKUProductType$outboundSchema: z.ZodNativeEnum<
+  typeof SKUProductType
+> = SKUProductType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace SKUProductType$ {
+  /** @deprecated use `SKUProductType$inboundSchema` instead. */
+  export const inboundSchema = SKUProductType$inboundSchema;
+  /** @deprecated use `SKUProductType$outboundSchema` instead. */
+  export const outboundSchema = SKUProductType$outboundSchema;
+}
+
+/** @internal */
+export const Sku$inboundSchema: z.ZodType<Sku, z.ZodTypeDef, unknown> = z
+  .object({
+    product_id: z.string(),
+    variant_id: z.nullable(z.string()).optional(),
+    sku: z.string(),
+    product_name: z.string(),
+    variant_name: z.nullable(z.string()).optional(),
+    product_type: SKUProductType$inboundSchema,
+    slug: z.string().optional(),
+    short_description: z.string().optional(),
+    active: z.boolean().default(true),
+    stock_available: z.boolean().default(true),
+    on_offer: z.boolean().default(false),
+    on_subscription: z.boolean().default(false),
+    on_promotion: z.boolean().default(false),
+    category_ids: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    reviews_count: z.number().int().optional(),
+    reviews_rating_sum: z.number().optional(),
+    attributes: z.array(ProductAttribute$inboundSchema).optional(),
+    images: z.array(ProductImage$inboundSchema).optional(),
+    pricing: ProductPricing$inboundSchema.optional(),
+    promotion: z.nullable(ProductPromotion$inboundSchema).optional(),
+    subscription: z.array(ProductSubscription$inboundSchema).optional(),
+    associated_options: z.record(AssociatedOption$inboundSchema).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "product_id": "productId",
+      "variant_id": "variantId",
+      "product_name": "productName",
+      "variant_name": "variantName",
+      "product_type": "productType",
+      "short_description": "shortDescription",
+      "stock_available": "stockAvailable",
+      "on_offer": "onOffer",
+      "on_subscription": "onSubscription",
+      "on_promotion": "onPromotion",
+      "category_ids": "categoryIds",
+      "reviews_count": "reviewsCount",
+      "reviews_rating_sum": "reviewsRatingSum",
+      "associated_options": "associatedOptions",
+    });
+  });
+
+/** @internal */
+export type Sku$Outbound = {
+  product_id: string;
+  variant_id?: string | null | undefined;
+  sku: string;
+  product_name: string;
+  variant_name?: string | null | undefined;
+  product_type: string;
+  slug?: string | undefined;
+  short_description?: string | undefined;
+  active: boolean;
+  stock_available: boolean;
+  on_offer: boolean;
+  on_subscription: boolean;
+  on_promotion: boolean;
+  category_ids?: Array<string> | undefined;
+  tags?: Array<string> | undefined;
+  reviews_count?: number | undefined;
+  reviews_rating_sum?: number | undefined;
+  attributes?: Array<ProductAttribute$Outbound> | undefined;
+  images?: Array<ProductImage$Outbound> | undefined;
+  pricing?: ProductPricing$Outbound | undefined;
+  promotion?: ProductPromotion$Outbound | null | undefined;
+  subscription?: Array<ProductSubscription$Outbound> | undefined;
+  associated_options?: { [k: string]: AssociatedOption$Outbound } | undefined;
+};
+
+/** @internal */
+export const Sku$outboundSchema: z.ZodType<Sku$Outbound, z.ZodTypeDef, Sku> = z
+  .object({
+    productId: z.string(),
+    variantId: z.nullable(z.string()).optional(),
+    sku: z.string(),
+    productName: z.string(),
+    variantName: z.nullable(z.string()).optional(),
+    productType: SKUProductType$outboundSchema,
+    slug: z.string().optional(),
+    shortDescription: z.string().optional(),
+    active: z.boolean().default(true),
+    stockAvailable: z.boolean().default(true),
+    onOffer: z.boolean().default(false),
+    onSubscription: z.boolean().default(false),
+    onPromotion: z.boolean().default(false),
+    categoryIds: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    reviewsCount: z.number().int().optional(),
+    reviewsRatingSum: z.number().optional(),
+    attributes: z.array(ProductAttribute$outboundSchema).optional(),
+    images: z.array(ProductImage$outboundSchema).optional(),
+    pricing: ProductPricing$outboundSchema.optional(),
+    promotion: z.nullable(ProductPromotion$outboundSchema).optional(),
+    subscription: z.array(ProductSubscription$outboundSchema).optional(),
+    associatedOptions: z.record(AssociatedOption$outboundSchema).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      productId: "product_id",
+      variantId: "variant_id",
+      productName: "product_name",
+      variantName: "variant_name",
+      productType: "product_type",
+      shortDescription: "short_description",
+      stockAvailable: "stock_available",
+      onOffer: "on_offer",
+      onSubscription: "on_subscription",
+      onPromotion: "on_promotion",
+      categoryIds: "category_ids",
+      reviewsCount: "reviews_count",
+      reviewsRatingSum: "reviews_rating_sum",
+      associatedOptions: "associated_options",
+    });
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Sku$ {
+  /** @deprecated use `Sku$inboundSchema` instead. */
+  export const inboundSchema = Sku$inboundSchema;
+  /** @deprecated use `Sku$outboundSchema` instead. */
+  export const outboundSchema = Sku$outboundSchema;
+  /** @deprecated use `Sku$Outbound` instead. */
+  export type Outbound = Sku$Outbound;
+}
+
+export function skuToJSON(sku: Sku): string {
+  return JSON.stringify(Sku$outboundSchema.parse(sku));
+}
+
+export function skuFromJSON(
+  jsonString: string,
+): SafeParseResult<Sku, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Sku$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Sku' from JSON`,
+  );
+}