ce-storefront 0.3.5 → 0.3.7

package/src/models/components/variantdetail.ts

@@ -5,20 +5,27 @@
 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 {
-  ProductPackaging,
-  ProductPackaging$inboundSchema,
-  ProductPackaging$Outbound,
-  ProductPackaging$outboundSchema,
-} from "./productpackaging.js";
 import {
   ProductPricing,
   ProductPricing$inboundSchema,
@@ -55,148 +62,97 @@ import {
   Seo$Outbound,
   Seo$outboundSchema,
 } from "./seo.js";
+import {
+  VariantOption,
+  VariantOption$inboundSchema,
+  VariantOption$Outbound,
+  VariantOption$outboundSchema,
+} from "./variantoption.js";
 
-export type VariantDetailAssociatedOptions = {};
-
-export type VariantDetailMetadata = {
-  key?: string | undefined;
-  value?: string | undefined;
-};
+export const VariantDetailProductType = {
+  Physical: "physical",
+  Digital: "digital",
+  Bundle: "bundle",
+} as const;
+export type VariantDetailProductType = ClosedEnum<
+  typeof VariantDetailProductType
+>;
 
 export type VariantDetail = {
   /**
    * variant id
    */
-  id?: string | undefined;
+  id: string;
   /**
-   * variant name
+   * product id
    */
-  name?: string | undefined;
-  shortDescription?: string | undefined;
-  description?: string | undefined;
-  stockAvailable?: boolean | undefined;
-  isDefault?: boolean | undefined;
-  associatedOptions?: VariantDetailAssociatedOptions | undefined;
-  metadata?: Array<VariantDetailMetadata> | null | undefined;
+  productId: string;
   /**
    * variant sku
    */
   sku?: string | undefined;
-  pricing?: ProductPricing | undefined;
-  videos?: Array<ProductVideo> | undefined;
+  slug?: string | undefined;
+  /**
+   * variant name
+   */
+  name: string;
+  /**
+   * variant name
+   */
+  productName: string;
+  shortDescription: string;
+  active: boolean;
+  stockAvailable: boolean;
+  /**
+   * Indicates whether this item is associated with any active (product-specific) coupons
+   */
+  onOffer?: boolean | undefined;
+  onPromotion?: boolean | undefined;
+  onSubscription?: boolean | undefined;
+  /**
+   * Indicates whether a variant is marked as the default variant for a product
+   */
+  isDefault: boolean;
+  associatedOptions: { [k: string]: AssociatedOption };
   images?: Array<ProductImage> | undefined;
-  shipping?: ProductShipping | undefined;
-  packaging?: ProductPackaging | undefined;
-  promotion?: Array<ProductPromotion> | undefined;
+  pricing: ProductPricing;
   subscription?: Array<ProductSubscription> | undefined;
+  promotion?: Array<ProductPromotion> | undefined;
+  productType: VariantDetailProductType;
+  description?: string | undefined;
+  categoryIds?: Array<string> | undefined;
+  tags?: Array<string> | null | undefined;
+  reviewRatingSum?: number | undefined;
+  reviewsCount?: number | undefined;
+  hsnCode?: string | undefined;
+  variantOptions: Array<VariantOption>;
+  productAttributes?: Array<ProductAttribute> | undefined;
+  variantAttributes?: Array<ProductAttribute> | undefined;
+  videos?: Array<ProductVideo> | undefined;
+  shipping?: ProductShipping | null | undefined;
   seo?: Seo | undefined;
+  metadata?: { [k: string]: string } | undefined;
 };
 
 /** @internal */
-export const VariantDetailAssociatedOptions$inboundSchema: z.ZodType<
-  VariantDetailAssociatedOptions,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-/** @internal */
-export type VariantDetailAssociatedOptions$Outbound = {};
-
-/** @internal */
-export const VariantDetailAssociatedOptions$outboundSchema: z.ZodType<
-  VariantDetailAssociatedOptions$Outbound,
-  z.ZodTypeDef,
-  VariantDetailAssociatedOptions
-> = 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 VariantDetailAssociatedOptions$ {
-  /** @deprecated use `VariantDetailAssociatedOptions$inboundSchema` instead. */
-  export const inboundSchema = VariantDetailAssociatedOptions$inboundSchema;
-  /** @deprecated use `VariantDetailAssociatedOptions$outboundSchema` instead. */
-  export const outboundSchema = VariantDetailAssociatedOptions$outboundSchema;
-  /** @deprecated use `VariantDetailAssociatedOptions$Outbound` instead. */
-  export type Outbound = VariantDetailAssociatedOptions$Outbound;
-}
-
-export function variantDetailAssociatedOptionsToJSON(
-  variantDetailAssociatedOptions: VariantDetailAssociatedOptions,
-): string {
-  return JSON.stringify(
-    VariantDetailAssociatedOptions$outboundSchema.parse(
-      variantDetailAssociatedOptions,
-    ),
-  );
-}
-
-export function variantDetailAssociatedOptionsFromJSON(
-  jsonString: string,
-): SafeParseResult<VariantDetailAssociatedOptions, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VariantDetailAssociatedOptions$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VariantDetailAssociatedOptions' from JSON`,
-  );
-}
-
-/** @internal */
-export const VariantDetailMetadata$inboundSchema: z.ZodType<
-  VariantDetailMetadata,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  key: z.string().optional(),
-  value: z.string().optional(),
-});
+export const VariantDetailProductType$inboundSchema: z.ZodNativeEnum<
+  typeof VariantDetailProductType
+> = z.nativeEnum(VariantDetailProductType);
 
 /** @internal */
-export type VariantDetailMetadata$Outbound = {
-  key?: string | undefined;
-  value?: string | undefined;
-};
-
-/** @internal */
-export const VariantDetailMetadata$outboundSchema: z.ZodType<
-  VariantDetailMetadata$Outbound,
-  z.ZodTypeDef,
-  VariantDetailMetadata
-> = z.object({
-  key: z.string().optional(),
-  value: z.string().optional(),
-});
+export const VariantDetailProductType$outboundSchema: z.ZodNativeEnum<
+  typeof VariantDetailProductType
+> = VariantDetailProductType$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace VariantDetailMetadata$ {
-  /** @deprecated use `VariantDetailMetadata$inboundSchema` instead. */
-  export const inboundSchema = VariantDetailMetadata$inboundSchema;
-  /** @deprecated use `VariantDetailMetadata$outboundSchema` instead. */
-  export const outboundSchema = VariantDetailMetadata$outboundSchema;
-  /** @deprecated use `VariantDetailMetadata$Outbound` instead. */
-  export type Outbound = VariantDetailMetadata$Outbound;
-}
-
-export function variantDetailMetadataToJSON(
-  variantDetailMetadata: VariantDetailMetadata,
-): string {
-  return JSON.stringify(
-    VariantDetailMetadata$outboundSchema.parse(variantDetailMetadata),
-  );
-}
-
-export function variantDetailMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<VariantDetailMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VariantDetailMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VariantDetailMetadata' from JSON`,
-  );
+export namespace VariantDetailProductType$ {
+  /** @deprecated use `VariantDetailProductType$inboundSchema` instead. */
+  export const inboundSchema = VariantDetailProductType$inboundSchema;
+  /** @deprecated use `VariantDetailProductType$outboundSchema` instead. */
+  export const outboundSchema = VariantDetailProductType$outboundSchema;
 }
 
 /** @internal */
@@ -205,54 +161,94 @@ export const VariantDetail$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  short_description: z.string().optional(),
-  description: z.string().optional(),
-  stock_available: z.boolean().optional(),
-  is_default: z.boolean().optional(),
-  associated_options: z.lazy(() => VariantDetailAssociatedOptions$inboundSchema)
-    .optional(),
-  metadata: z.nullable(
-    z.array(z.lazy(() => VariantDetailMetadata$inboundSchema)),
-  ).optional(),
+  id: z.string(),
+  product_id: z.string(),
   sku: z.string().optional(),
-  pricing: ProductPricing$inboundSchema.optional(),
-  videos: z.array(ProductVideo$inboundSchema).optional(),
+  slug: z.string().optional(),
+  name: z.string(),
+  product_name: z.string(),
+  short_description: z.string(),
+  active: z.boolean(),
+  stock_available: z.boolean(),
+  on_offer: z.boolean().default(false),
+  on_promotion: z.boolean().default(false),
+  on_subscription: z.boolean().default(false),
+  is_default: z.boolean(),
+  associated_options: z.record(AssociatedOption$inboundSchema),
   images: z.array(ProductImage$inboundSchema).optional(),
-  shipping: ProductShipping$inboundSchema.optional(),
-  packaging: ProductPackaging$inboundSchema.optional(),
-  promotion: z.array(ProductPromotion$inboundSchema).optional(),
+  pricing: ProductPricing$inboundSchema,
   subscription: z.array(ProductSubscription$inboundSchema).optional(),
+  promotion: z.array(ProductPromotion$inboundSchema).optional(),
+  product_type: VariantDetailProductType$inboundSchema,
+  description: z.string().optional(),
+  category_ids: z.array(z.string()).optional(),
+  tags: z.nullable(z.array(z.string())).optional(),
+  review_rating_sum: z.number().optional(),
+  reviews_count: z.number().int().optional(),
+  hsn_code: z.string().optional(),
+  variant_options: z.array(VariantOption$inboundSchema),
+  product_attributes: z.array(ProductAttribute$inboundSchema).optional(),
+  variant_attributes: z.array(ProductAttribute$inboundSchema).optional(),
+  videos: z.array(ProductVideo$inboundSchema).optional(),
+  shipping: z.nullable(ProductShipping$inboundSchema).optional(),
   seo: Seo$inboundSchema.optional(),
+  metadata: z.record(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
+    "product_id": "productId",
+    "product_name": "productName",
     "short_description": "shortDescription",
     "stock_available": "stockAvailable",
+    "on_offer": "onOffer",
+    "on_promotion": "onPromotion",
+    "on_subscription": "onSubscription",
     "is_default": "isDefault",
     "associated_options": "associatedOptions",
+    "product_type": "productType",
+    "category_ids": "categoryIds",
+    "review_rating_sum": "reviewRatingSum",
+    "reviews_count": "reviewsCount",
+    "hsn_code": "hsnCode",
+    "variant_options": "variantOptions",
+    "product_attributes": "productAttributes",
+    "variant_attributes": "variantAttributes",
   });
 });
 
 /** @internal */
 export type VariantDetail$Outbound = {
-  id?: string | undefined;
-  name?: string | undefined;
-  short_description?: string | undefined;
-  description?: string | undefined;
-  stock_available?: boolean | undefined;
-  is_default?: boolean | undefined;
-  associated_options?: VariantDetailAssociatedOptions$Outbound | undefined;
-  metadata?: Array<VariantDetailMetadata$Outbound> | null | undefined;
+  id: string;
+  product_id: string;
   sku?: string | undefined;
-  pricing?: ProductPricing$Outbound | undefined;
-  videos?: Array<ProductVideo$Outbound> | undefined;
+  slug?: string | undefined;
+  name: string;
+  product_name: string;
+  short_description: string;
+  active: boolean;
+  stock_available: boolean;
+  on_offer: boolean;
+  on_promotion: boolean;
+  on_subscription: boolean;
+  is_default: boolean;
+  associated_options: { [k: string]: AssociatedOption$Outbound };
   images?: Array<ProductImage$Outbound> | undefined;
-  shipping?: ProductShipping$Outbound | undefined;
-  packaging?: ProductPackaging$Outbound | undefined;
-  promotion?: Array<ProductPromotion$Outbound> | undefined;
+  pricing: ProductPricing$Outbound;
   subscription?: Array<ProductSubscription$Outbound> | undefined;
+  promotion?: Array<ProductPromotion$Outbound> | undefined;
+  product_type: string;
+  description?: string | undefined;
+  category_ids?: Array<string> | undefined;
+  tags?: Array<string> | null | undefined;
+  review_rating_sum?: number | undefined;
+  reviews_count?: number | undefined;
+  hsn_code?: string | undefined;
+  variant_options: Array<VariantOption$Outbound>;
+  product_attributes?: Array<ProductAttribute$Outbound> | undefined;
+  variant_attributes?: Array<ProductAttribute$Outbound> | undefined;
+  videos?: Array<ProductVideo$Outbound> | undefined;
+  shipping?: ProductShipping$Outbound | null | undefined;
   seo?: Seo$Outbound | undefined;
+  metadata?: { [k: string]: string } | undefined;
 };
 
 /** @internal */
@@ -261,32 +257,57 @@ export const VariantDetail$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   VariantDetail
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  shortDescription: z.string().optional(),
-  description: z.string().optional(),
-  stockAvailable: z.boolean().optional(),
-  isDefault: z.boolean().optional(),
-  associatedOptions: z.lazy(() => VariantDetailAssociatedOptions$outboundSchema)
-    .optional(),
-  metadata: z.nullable(
-    z.array(z.lazy(() => VariantDetailMetadata$outboundSchema)),
-  ).optional(),
+  id: z.string(),
+  productId: z.string(),
   sku: z.string().optional(),
-  pricing: ProductPricing$outboundSchema.optional(),
-  videos: z.array(ProductVideo$outboundSchema).optional(),
+  slug: z.string().optional(),
+  name: z.string(),
+  productName: z.string(),
+  shortDescription: z.string(),
+  active: z.boolean(),
+  stockAvailable: z.boolean(),
+  onOffer: z.boolean().default(false),
+  onPromotion: z.boolean().default(false),
+  onSubscription: z.boolean().default(false),
+  isDefault: z.boolean(),
+  associatedOptions: z.record(AssociatedOption$outboundSchema),
   images: z.array(ProductImage$outboundSchema).optional(),
-  shipping: ProductShipping$outboundSchema.optional(),
-  packaging: ProductPackaging$outboundSchema.optional(),
-  promotion: z.array(ProductPromotion$outboundSchema).optional(),
+  pricing: ProductPricing$outboundSchema,
   subscription: z.array(ProductSubscription$outboundSchema).optional(),
+  promotion: z.array(ProductPromotion$outboundSchema).optional(),
+  productType: VariantDetailProductType$outboundSchema,
+  description: z.string().optional(),
+  categoryIds: z.array(z.string()).optional(),
+  tags: z.nullable(z.array(z.string())).optional(),
+  reviewRatingSum: z.number().optional(),
+  reviewsCount: z.number().int().optional(),
+  hsnCode: z.string().optional(),
+  variantOptions: z.array(VariantOption$outboundSchema),
+  productAttributes: z.array(ProductAttribute$outboundSchema).optional(),
+  variantAttributes: z.array(ProductAttribute$outboundSchema).optional(),
+  videos: z.array(ProductVideo$outboundSchema).optional(),
+  shipping: z.nullable(ProductShipping$outboundSchema).optional(),
   seo: Seo$outboundSchema.optional(),
+  metadata: z.record(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
+    productId: "product_id",
+    productName: "product_name",
     shortDescription: "short_description",
     stockAvailable: "stock_available",
+    onOffer: "on_offer",
+    onPromotion: "on_promotion",
+    onSubscription: "on_subscription",
     isDefault: "is_default",
     associatedOptions: "associated_options",
+    productType: "product_type",
+    categoryIds: "category_ids",
+    reviewRatingSum: "review_rating_sum",
+    reviewsCount: "reviews_count",
+    hsnCode: "hsn_code",
+    variantOptions: "variant_options",
+    productAttributes: "product_attributes",
+    variantAttributes: "variant_attributes",
   });
 });
 

package/src/models/components/variantoption.ts

@@ -0,0 +1,214 @@
+/*
+ * 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";
+
+export const OptionType = {
+  SingleSelect: "single-select",
+  Color: "color",
+} as const;
+export type OptionType = ClosedEnum<typeof OptionType>;
+
+export type Two = {};
+
+export type OptionValue = Two | string;
+
+export type VariantOption = {
+  optionName?: string | undefined;
+  optionType?: OptionType | undefined;
+  /**
+   * When option_type is color, value will contain an array of objects like:
+   *
+   * @remarks
+   * ```json
+   * [
+   *     {
+   *     "name": "first_color",
+   *     "hexcode": "#000000"
+   *     },
+   *     {
+   *     "name": "second_color",
+   *     "hexcode": "#FFFFFF"
+   *     }
+   * ]
+   * ```
+   */
+  optionValue?: Array<Two | string> | undefined;
+};
+
+/** @internal */
+export const OptionType$inboundSchema: z.ZodNativeEnum<typeof OptionType> = z
+  .nativeEnum(OptionType);
+
+/** @internal */
+export const OptionType$outboundSchema: z.ZodNativeEnum<typeof OptionType> =
+  OptionType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OptionType$ {
+  /** @deprecated use `OptionType$inboundSchema` instead. */
+  export const inboundSchema = OptionType$inboundSchema;
+  /** @deprecated use `OptionType$outboundSchema` instead. */
+  export const outboundSchema = OptionType$outboundSchema;
+}
+
+/** @internal */
+export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z
+  .object({});
+
+/** @internal */
+export type Two$Outbound = {};
+
+/** @internal */
+export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = 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 Two$ {
+  /** @deprecated use `Two$inboundSchema` instead. */
+  export const inboundSchema = Two$inboundSchema;
+  /** @deprecated use `Two$outboundSchema` instead. */
+  export const outboundSchema = Two$outboundSchema;
+  /** @deprecated use `Two$Outbound` instead. */
+  export type Outbound = Two$Outbound;
+}
+
+export function twoToJSON(two: Two): string {
+  return JSON.stringify(Two$outboundSchema.parse(two));
+}
+
+export function twoFromJSON(
+  jsonString: string,
+): SafeParseResult<Two, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two' from JSON`,
+  );
+}
+
+/** @internal */
+export const OptionValue$inboundSchema: z.ZodType<
+  OptionValue,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.lazy(() => Two$inboundSchema), z.string()]);
+
+/** @internal */
+export type OptionValue$Outbound = Two$Outbound | string;
+
+/** @internal */
+export const OptionValue$outboundSchema: z.ZodType<
+  OptionValue$Outbound,
+  z.ZodTypeDef,
+  OptionValue
+> = z.union([z.lazy(() => Two$outboundSchema), z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OptionValue$ {
+  /** @deprecated use `OptionValue$inboundSchema` instead. */
+  export const inboundSchema = OptionValue$inboundSchema;
+  /** @deprecated use `OptionValue$outboundSchema` instead. */
+  export const outboundSchema = OptionValue$outboundSchema;
+  /** @deprecated use `OptionValue$Outbound` instead. */
+  export type Outbound = OptionValue$Outbound;
+}
+
+export function optionValueToJSON(optionValue: OptionValue): string {
+  return JSON.stringify(OptionValue$outboundSchema.parse(optionValue));
+}
+
+export function optionValueFromJSON(
+  jsonString: string,
+): SafeParseResult<OptionValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OptionValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OptionValue' from JSON`,
+  );
+}
+
+/** @internal */
+export const VariantOption$inboundSchema: z.ZodType<
+  VariantOption,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  option_name: z.string().optional(),
+  option_type: OptionType$inboundSchema.optional(),
+  option_value: z.array(z.union([z.lazy(() => Two$inboundSchema), z.string()]))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "option_name": "optionName",
+    "option_type": "optionType",
+    "option_value": "optionValue",
+  });
+});
+
+/** @internal */
+export type VariantOption$Outbound = {
+  option_name?: string | undefined;
+  option_type?: string | undefined;
+  option_value?: Array<Two$Outbound | string> | undefined;
+};
+
+/** @internal */
+export const VariantOption$outboundSchema: z.ZodType<
+  VariantOption$Outbound,
+  z.ZodTypeDef,
+  VariantOption
+> = z.object({
+  optionName: z.string().optional(),
+  optionType: OptionType$outboundSchema.optional(),
+  optionValue: z.array(z.union([z.lazy(() => Two$outboundSchema), z.string()]))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    optionName: "option_name",
+    optionType: "option_type",
+    optionValue: "option_value",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VariantOption$ {
+  /** @deprecated use `VariantOption$inboundSchema` instead. */
+  export const inboundSchema = VariantOption$inboundSchema;
+  /** @deprecated use `VariantOption$outboundSchema` instead. */
+  export const outboundSchema = VariantOption$outboundSchema;
+  /** @deprecated use `VariantOption$Outbound` instead. */
+  export type Outbound = VariantOption$Outbound;
+}
+
+export function variantOptionToJSON(variantOption: VariantOption): string {
+  return JSON.stringify(VariantOption$outboundSchema.parse(variantOption));
+}
+
+export function variantOptionFromJSON(
+  jsonString: string,
+): SafeParseResult<VariantOption, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VariantOption$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VariantOption' from JSON`,
+  );
+}

package/src/models/components/volumebasedpromotion.ts

@@ -21,10 +21,6 @@ export type Slabs = {
 
 export type VolumeBasedPromotion = {
   promotionType?: "discount" | undefined;
-  /**
-   * Optional ID for a specific customer group.
-   */
-  customerGroupId?: string | null | undefined;
   slabs: Array<Slabs>;
 };
 
@@ -95,19 +91,16 @@ export const VolumeBasedPromotion$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   promotion_type: z.literal("discount").optional(),
-  customer_group_id: z.nullable(z.string()).optional(),
   slabs: z.array(z.lazy(() => Slabs$inboundSchema)),
 }).transform((v) => {
   return remap$(v, {
     "promotion_type": "promotionType",
-    "customer_group_id": "customerGroupId",
   });
 });
 
 /** @internal */
 export type VolumeBasedPromotion$Outbound = {
   promotion_type: "discount";
-  customer_group_id?: string | null | undefined;
   slabs: Array<Slabs$Outbound>;
 };
 
@@ -118,12 +111,10 @@ export const VolumeBasedPromotion$outboundSchema: z.ZodType<
   VolumeBasedPromotion
 > = z.object({
   promotionType: z.literal("discount").default("discount" as const),
-  customerGroupId: z.nullable(z.string()).optional(),
   slabs: z.array(z.lazy(() => Slabs$outboundSchema)),
 }).transform((v) => {
   return remap$(v, {
     promotionType: "promotion_type",
-    customerGroupId: "customer_group_id",
   });
 });