ce-storefront 0.3.5 → 0.3.7

package/src/models/components/productattribute.ts

@@ -3,7 +3,6 @@
  */
 
 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";
@@ -12,11 +11,6 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * Attribute for numeric values
  */
 export type NumberAttribute = {
-  attributeType?: "number" | undefined;
-  /**
-   * For numeric attributes
-   */
-  attributeValue: number;
   /**
    * Unique identifier for the attribute
    */
@@ -25,17 +19,21 @@ export type NumberAttribute = {
    * Name of the attribute
    */
   name: string;
+  /**
+   * A lookup safe version of the name that is lowercased and spaces are replaced with underscores. For instance, if name is `Product Type`, key will be `product_type`
+   */
+  key: string;
+  type?: "number" | undefined;
+  /**
+   * For numeric attributes
+   */
+  value: number;
 };
 
 /**
  * Attribute for date values
  */
 export type DateAttribute = {
-  attributeType?: "date" | undefined;
-  /**
-   * For date attributes
-   */
-  attributeValue: Date;
   /**
    * Unique identifier for the attribute
    */
@@ -44,17 +42,21 @@ export type DateAttribute = {
    * Name of the attribute
    */
   name: string;
+  /**
+   * A lookup safe version of the name that is lowercased and spaces are replaced with underscores. For instance, if name is `Product Type`, key will be `product_type`
+   */
+  key: string;
+  type?: "date" | undefined;
+  /**
+   * For date attributes
+   */
+  value: Date;
 };
 
 /**
  * Attribute for text values
  */
 export type TextAttribute = {
-  attributeType?: "text" | undefined;
-  /**
-   * For text attributes
-   */
-  attributeValue: string;
   /**
    * Unique identifier for the attribute
    */
@@ -63,17 +65,21 @@ export type TextAttribute = {
    * Name of the attribute
    */
   name: string;
+  /**
+   * A lookup safe version of the name that is lowercased and spaces are replaced with underscores. For instance, if name is `Product Type`, key will be `product_type`
+   */
+  key?: string | undefined;
+  type?: "text" | undefined;
+  /**
+   * For text attributes
+   */
+  value: string;
 };
 
 /**
  * Attribute for multi-select values
  */
 export type MultiSelectAttribute = {
-  attributeType?: "multi-select" | undefined;
-  /**
-   * For multi-select attributes
-   */
-  attributeValue: Array<string>;
   /**
    * Unique identifier for the attribute
    */
@@ -82,17 +88,21 @@ export type MultiSelectAttribute = {
    * Name of the attribute
    */
   name: string;
+  /**
+   * A lookup safe version of the name that is lowercased and spaces are replaced with underscores. For instance, if name is `Product Type`, key will be `product_type`
+   */
+  key: string;
+  type?: "multi-select" | undefined;
+  /**
+   * For multi-select attributes
+   */
+  value: Array<string>;
 };
 
 /**
  * Attribute for single-select values
  */
 export type SingleSelectAttribute = {
-  attributeType?: "single-select" | undefined;
-  /**
-   * For single-select attributes
-   */
-  attributeValue: string;
   /**
    * Unique identifier for the attribute
    */
@@ -101,10 +111,22 @@ export type SingleSelectAttribute = {
    * Name of the attribute
    */
   name: string;
+  /**
+   * A lookup safe version of the name that is lowercased and spaces are replaced with underscores. For instance, if name is `Product Type`, key will be `product_type`
+   */
+  key: string;
+  type?: "single-select" | undefined;
+  /**
+   * For single-select attributes
+   */
+  value: string;
 };
 
-export type AttributeValue = {
+export type ColorAttributeValue = {
   name: string;
+  /**
+   * The hex code of the color (e.g., #000000).
+   */
   hexcode: string;
 };
 
@@ -112,8 +134,6 @@ export type AttributeValue = {
  * Attribute for colors
  */
 export type ColorAttribute = {
-  attributeType?: "color" | undefined;
-  attributeValue: Array<AttributeValue>;
   /**
    * Unique identifier for the attribute
    */
@@ -122,15 +142,21 @@ export type ColorAttribute = {
    * Name of the attribute
    */
   name: string;
+  /**
+   * A lookup safe version of the name that is lowercased and spaces are replaced with underscores. For instance, if name is `Product Type`, key will be `product_type`
+   */
+  key: string;
+  type?: "color" | undefined;
+  value: Array<ColorAttributeValue>;
 };
 
 export type ProductAttribute =
-  | (ColorAttribute & { attributeType: "color" })
-  | (SingleSelectAttribute & { attributeType: "single-select" })
-  | (MultiSelectAttribute & { attributeType: "multi-select" })
-  | (TextAttribute & { attributeType: "text" })
-  | (DateAttribute & { attributeType: "date" })
-  | (NumberAttribute & { attributeType: "number" });
+  | (ColorAttribute & { type: "color" })
+  | (SingleSelectAttribute & { type: "single-select" })
+  | (MultiSelectAttribute & { type: "multi-select" })
+  | (TextAttribute & { type: "text" })
+  | (DateAttribute & { type: "date" })
+  | (NumberAttribute & { type: "number" });
 
 /** @internal */
 export const NumberAttribute$inboundSchema: z.ZodType<
@@ -138,23 +164,20 @@ export const NumberAttribute$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  attribute_type: z.literal("number").optional(),
-  attribute_value: z.number(),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "attribute_type": "attributeType",
-    "attribute_value": "attributeValue",
-  });
+  key: z.string(),
+  type: z.literal("number").optional(),
+  value: z.number(),
 });
 
 /** @internal */
 export type NumberAttribute$Outbound = {
-  attribute_type: "number";
-  attribute_value: number;
   id: string;
   name: string;
+  key: string;
+  type: "number";
+  value: number;
 };
 
 /** @internal */
@@ -163,15 +186,11 @@ export const NumberAttribute$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   NumberAttribute
 > = z.object({
-  attributeType: z.literal("number").default("number" as const),
-  attributeValue: z.number(),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    attributeType: "attribute_type",
-    attributeValue: "attribute_value",
-  });
+  key: z.string(),
+  type: z.literal("number").default("number" as const),
+  value: z.number(),
 });
 
 /**
@@ -209,25 +228,20 @@ export const DateAttribute$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  attribute_type: z.literal("date").optional(),
-  attribute_value: z.string().datetime({ offset: true }).transform(v =>
-    new Date(v)
-  ),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "attribute_type": "attributeType",
-    "attribute_value": "attributeValue",
-  });
+  key: z.string(),
+  type: z.literal("date").optional(),
+  value: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });
 
 /** @internal */
 export type DateAttribute$Outbound = {
-  attribute_type: "date";
-  attribute_value: string;
   id: string;
   name: string;
+  key: string;
+  type: "date";
+  value: string;
 };
 
 /** @internal */
@@ -236,15 +250,11 @@ export const DateAttribute$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DateAttribute
 > = z.object({
-  attributeType: z.literal("date").default("date" as const),
-  attributeValue: z.date().transform(v => v.toISOString()),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    attributeType: "attribute_type",
-    attributeValue: "attribute_value",
-  });
+  key: z.string(),
+  type: z.literal("date").default("date" as const),
+  value: z.date().transform(v => v.toISOString()),
 });
 
 /**
@@ -280,23 +290,20 @@ export const TextAttribute$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  attribute_type: z.literal("text").optional(),
-  attribute_value: z.string(),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "attribute_type": "attributeType",
-    "attribute_value": "attributeValue",
-  });
+  key: z.string().optional(),
+  type: z.literal("text").optional(),
+  value: z.string(),
 });
 
 /** @internal */
 export type TextAttribute$Outbound = {
-  attribute_type: "text";
-  attribute_value: string;
   id: string;
   name: string;
+  key?: string | undefined;
+  type: "text";
+  value: string;
 };
 
 /** @internal */
@@ -305,15 +312,11 @@ export const TextAttribute$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   TextAttribute
 > = z.object({
-  attributeType: z.literal("text").default("text" as const),
-  attributeValue: z.string(),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    attributeType: "attribute_type",
-    attributeValue: "attribute_value",
-  });
+  key: z.string().optional(),
+  type: z.literal("text").default("text" as const),
+  value: z.string(),
 });
 
 /**
@@ -349,23 +352,20 @@ export const MultiSelectAttribute$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  attribute_type: z.literal("multi-select").optional(),
-  attribute_value: z.array(z.string()),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "attribute_type": "attributeType",
-    "attribute_value": "attributeValue",
-  });
+  key: z.string(),
+  type: z.literal("multi-select").optional(),
+  value: z.array(z.string()),
 });
 
 /** @internal */
 export type MultiSelectAttribute$Outbound = {
-  attribute_type: "multi-select";
-  attribute_value: Array<string>;
   id: string;
   name: string;
+  key: string;
+  type: "multi-select";
+  value: Array<string>;
 };
 
 /** @internal */
@@ -374,15 +374,11 @@ export const MultiSelectAttribute$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   MultiSelectAttribute
 > = z.object({
-  attributeType: z.literal("multi-select").default("multi-select" as const),
-  attributeValue: z.array(z.string()),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    attributeType: "attribute_type",
-    attributeValue: "attribute_value",
-  });
+  key: z.string(),
+  type: z.literal("multi-select").default("multi-select" as const),
+  value: z.array(z.string()),
 });
 
 /**
@@ -422,23 +418,20 @@ export const SingleSelectAttribute$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  attribute_type: z.literal("single-select").optional(),
-  attribute_value: z.string(),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "attribute_type": "attributeType",
-    "attribute_value": "attributeValue",
-  });
+  key: z.string(),
+  type: z.literal("single-select").optional(),
+  value: z.string(),
 });
 
 /** @internal */
 export type SingleSelectAttribute$Outbound = {
-  attribute_type: "single-select";
-  attribute_value: string;
   id: string;
   name: string;
+  key: string;
+  type: "single-select";
+  value: string;
 };
 
 /** @internal */
@@ -447,15 +440,11 @@ export const SingleSelectAttribute$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   SingleSelectAttribute
 > = z.object({
-  attributeType: z.literal("single-select").default("single-select" as const),
-  attributeValue: z.string(),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    attributeType: "attribute_type",
-    attributeValue: "attribute_value",
-  });
+  key: z.string(),
+  type: z.literal("single-select").default("single-select" as const),
+  value: z.string(),
 });
 
 /**
@@ -490,8 +479,8 @@ export function singleSelectAttributeFromJSON(
 }
 
 /** @internal */
-export const AttributeValue$inboundSchema: z.ZodType<
-  AttributeValue,
+export const ColorAttributeValue$inboundSchema: z.ZodType<
+  ColorAttributeValue,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -500,16 +489,16 @@ export const AttributeValue$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type AttributeValue$Outbound = {
+export type ColorAttributeValue$Outbound = {
   name: string;
   hexcode: string;
 };
 
 /** @internal */
-export const AttributeValue$outboundSchema: z.ZodType<
-  AttributeValue$Outbound,
+export const ColorAttributeValue$outboundSchema: z.ZodType<
+  ColorAttributeValue$Outbound,
   z.ZodTypeDef,
-  AttributeValue
+  ColorAttributeValue
 > = z.object({
   name: z.string(),
   hexcode: z.string(),
@@ -519,26 +508,30 @@ export const AttributeValue$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 AttributeValue$ {
-  /** @deprecated use `AttributeValue$inboundSchema` instead. */
-  export const inboundSchema = AttributeValue$inboundSchema;
-  /** @deprecated use `AttributeValue$outboundSchema` instead. */
-  export const outboundSchema = AttributeValue$outboundSchema;
-  /** @deprecated use `AttributeValue$Outbound` instead. */
-  export type Outbound = AttributeValue$Outbound;
+export namespace ColorAttributeValue$ {
+  /** @deprecated use `ColorAttributeValue$inboundSchema` instead. */
+  export const inboundSchema = ColorAttributeValue$inboundSchema;
+  /** @deprecated use `ColorAttributeValue$outboundSchema` instead. */
+  export const outboundSchema = ColorAttributeValue$outboundSchema;
+  /** @deprecated use `ColorAttributeValue$Outbound` instead. */
+  export type Outbound = ColorAttributeValue$Outbound;
 }
 
-export function attributeValueToJSON(attributeValue: AttributeValue): string {
-  return JSON.stringify(AttributeValue$outboundSchema.parse(attributeValue));
+export function colorAttributeValueToJSON(
+  colorAttributeValue: ColorAttributeValue,
+): string {
+  return JSON.stringify(
+    ColorAttributeValue$outboundSchema.parse(colorAttributeValue),
+  );
 }
 
-export function attributeValueFromJSON(
+export function colorAttributeValueFromJSON(
   jsonString: string,
-): SafeParseResult<AttributeValue, SDKValidationError> {
+): SafeParseResult<ColorAttributeValue, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AttributeValue$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AttributeValue' from JSON`,
+    (x) => ColorAttributeValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ColorAttributeValue' from JSON`,
   );
 }
 
@@ -548,23 +541,20 @@ export const ColorAttribute$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  attribute_type: z.literal("color").optional(),
-  attribute_value: z.array(z.lazy(() => AttributeValue$inboundSchema)),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "attribute_type": "attributeType",
-    "attribute_value": "attributeValue",
-  });
+  key: z.string(),
+  type: z.literal("color").optional(),
+  value: z.array(z.lazy(() => ColorAttributeValue$inboundSchema)),
 });
 
 /** @internal */
 export type ColorAttribute$Outbound = {
-  attribute_type: "color";
-  attribute_value: Array<AttributeValue$Outbound>;
   id: string;
   name: string;
+  key: string;
+  type: "color";
+  value: Array<ColorAttributeValue$Outbound>;
 };
 
 /** @internal */
@@ -573,15 +563,11 @@ export const ColorAttribute$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ColorAttribute
 > = z.object({
-  attributeType: z.literal("color").default("color" as const),
-  attributeValue: z.array(z.lazy(() => AttributeValue$outboundSchema)),
   id: z.string(),
   name: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    attributeType: "attribute_type",
-    attributeValue: "attribute_value",
-  });
+  key: z.string(),
+  type: z.literal("color").default("color" as const),
+  value: z.array(z.lazy(() => ColorAttributeValue$outboundSchema)),
 });
 
 /**
@@ -618,45 +604,39 @@ export const ProductAttribute$inboundSchema: z.ZodType<
   unknown
 > = z.union([
   z.lazy(() => ColorAttribute$inboundSchema).and(
-    z.object({ attribute_type: z.literal("color") }).transform((v) => ({
-      attributeType: v.attribute_type,
-    })),
+    z.object({ type: z.literal("color") }).transform((v) => ({ type: v.type })),
   ),
   z.lazy(() => SingleSelectAttribute$inboundSchema).and(
-    z.object({ attribute_type: z.literal("single-select") }).transform((v) => ({
-      attributeType: v.attribute_type,
+    z.object({ type: z.literal("single-select") }).transform((v) => ({
+      type: v.type,
     })),
   ),
   z.lazy(() => MultiSelectAttribute$inboundSchema).and(
-    z.object({ attribute_type: z.literal("multi-select") }).transform((v) => ({
-      attributeType: v.attribute_type,
+    z.object({ type: z.literal("multi-select") }).transform((v) => ({
+      type: v.type,
     })),
   ),
   z.lazy(() => TextAttribute$inboundSchema).and(
-    z.object({ attribute_type: z.literal("text") }).transform((v) => ({
-      attributeType: v.attribute_type,
-    })),
+    z.object({ type: z.literal("text") }).transform((v) => ({ type: v.type })),
   ),
   z.lazy(() => DateAttribute$inboundSchema).and(
-    z.object({ attribute_type: z.literal("date") }).transform((v) => ({
-      attributeType: v.attribute_type,
-    })),
+    z.object({ type: z.literal("date") }).transform((v) => ({ type: v.type })),
   ),
   z.lazy(() => NumberAttribute$inboundSchema).and(
-    z.object({ attribute_type: z.literal("number") }).transform((v) => ({
-      attributeType: v.attribute_type,
+    z.object({ type: z.literal("number") }).transform((v) => ({
+      type: v.type,
     })),
   ),
 ]);
 
 /** @internal */
 export type ProductAttribute$Outbound =
-  | (ColorAttribute$Outbound & { attribute_type: "color" })
-  | (SingleSelectAttribute$Outbound & { attribute_type: "single-select" })
-  | (MultiSelectAttribute$Outbound & { attribute_type: "multi-select" })
-  | (TextAttribute$Outbound & { attribute_type: "text" })
-  | (DateAttribute$Outbound & { attribute_type: "date" })
-  | (NumberAttribute$Outbound & { attribute_type: "number" });
+  | (ColorAttribute$Outbound & { type: "color" })
+  | (SingleSelectAttribute$Outbound & { type: "single-select" })
+  | (MultiSelectAttribute$Outbound & { type: "multi-select" })
+  | (TextAttribute$Outbound & { type: "text" })
+  | (DateAttribute$Outbound & { type: "date" })
+  | (NumberAttribute$Outbound & { type: "number" });
 
 /** @internal */
 export const ProductAttribute$outboundSchema: z.ZodType<
@@ -665,33 +645,27 @@ export const ProductAttribute$outboundSchema: z.ZodType<
   ProductAttribute
 > = z.union([
   z.lazy(() => ColorAttribute$outboundSchema).and(
-    z.object({ attributeType: z.literal("color") }).transform((v) => ({
-      attribute_type: v.attributeType,
-    })),
+    z.object({ type: z.literal("color") }).transform((v) => ({ type: v.type })),
   ),
   z.lazy(() => SingleSelectAttribute$outboundSchema).and(
-    z.object({ attributeType: z.literal("single-select") }).transform((v) => ({
-      attribute_type: v.attributeType,
+    z.object({ type: z.literal("single-select") }).transform((v) => ({
+      type: v.type,
     })),
   ),
   z.lazy(() => MultiSelectAttribute$outboundSchema).and(
-    z.object({ attributeType: z.literal("multi-select") }).transform((v) => ({
-      attribute_type: v.attributeType,
+    z.object({ type: z.literal("multi-select") }).transform((v) => ({
+      type: v.type,
     })),
   ),
   z.lazy(() => TextAttribute$outboundSchema).and(
-    z.object({ attributeType: z.literal("text") }).transform((v) => ({
-      attribute_type: v.attributeType,
-    })),
+    z.object({ type: z.literal("text") }).transform((v) => ({ type: v.type })),
   ),
   z.lazy(() => DateAttribute$outboundSchema).and(
-    z.object({ attributeType: z.literal("date") }).transform((v) => ({
-      attribute_type: v.attributeType,
-    })),
+    z.object({ type: z.literal("date") }).transform((v) => ({ type: v.type })),
   ),
   z.lazy(() => NumberAttribute$outboundSchema).and(
-    z.object({ attributeType: z.literal("number") }).transform((v) => ({
-      attribute_type: v.attributeType,
+    z.object({ type: z.literal("number") }).transform((v) => ({
+      type: v.type,
     })),
   ),
 ]);

package/src/models/components/productcategory.ts

@@ -20,7 +20,7 @@ export type ChildCategories = {
 export type ProductCategory = {
   id: string;
   name: string;
-  description: string;
+  description?: string | null | undefined;
   parentCategoryId?: string | null | undefined;
   productCount?: number | undefined;
   active: boolean;
@@ -112,7 +112,7 @@ export const ProductCategory$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   name: z.string(),
-  description: z.string(),
+  description: z.nullable(z.string()).optional(),
   parent_category_id: z.nullable(z.string()).optional(),
   product_count: z.number().int().optional(),
   active: z.boolean(),
@@ -131,7 +131,7 @@ export const ProductCategory$inboundSchema: z.ZodType<
 export type ProductCategory$Outbound = {
   id: string;
   name: string;
-  description: string;
+  description?: string | null | undefined;
   parent_category_id?: string | null | undefined;
   product_count?: number | undefined;
   active: boolean;
@@ -146,7 +146,7 @@ export const ProductCategory$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   name: z.string(),
-  description: z.string(),
+  description: z.nullable(z.string()).optional(),
   parentCategoryId: z.nullable(z.string()).optional(),
   productCount: z.number().int().optional(),
   active: z.boolean(),