ce-storefront 0.12.5 → 0.13.1

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/generateotpwithemail.ts

@@ -0,0 +1,115 @@
+/*
+ * 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 GenerateOtpWithEmailOtpAction = {
+  Register: "register",
+  ResetPassword: "reset-password",
+  VerifyEmail: "verify-email",
+  UpdateEmail: "update-email",
+} as const;
+export type GenerateOtpWithEmailOtpAction = ClosedEnum<
+  typeof GenerateOtpWithEmailOtpAction
+>;
+
+export type GenerateOtpWithEmail = {
+  channel?: "email" | undefined;
+  email: string;
+  otpAction: GenerateOtpWithEmailOtpAction;
+};
+
+/** @internal */
+export const GenerateOtpWithEmailOtpAction$inboundSchema: z.ZodNativeEnum<
+  typeof GenerateOtpWithEmailOtpAction
+> = z.nativeEnum(GenerateOtpWithEmailOtpAction);
+
+/** @internal */
+export const GenerateOtpWithEmailOtpAction$outboundSchema: z.ZodNativeEnum<
+  typeof GenerateOtpWithEmailOtpAction
+> = GenerateOtpWithEmailOtpAction$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace GenerateOtpWithEmailOtpAction$ {
+  /** @deprecated use `GenerateOtpWithEmailOtpAction$inboundSchema` instead. */
+  export const inboundSchema = GenerateOtpWithEmailOtpAction$inboundSchema;
+  /** @deprecated use `GenerateOtpWithEmailOtpAction$outboundSchema` instead. */
+  export const outboundSchema = GenerateOtpWithEmailOtpAction$outboundSchema;
+}
+
+/** @internal */
+export const GenerateOtpWithEmail$inboundSchema: z.ZodType<
+  GenerateOtpWithEmail,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  channel: z.literal("email").optional(),
+  email: z.string(),
+  otp_action: GenerateOtpWithEmailOtpAction$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "otp_action": "otpAction",
+  });
+});
+
+/** @internal */
+export type GenerateOtpWithEmail$Outbound = {
+  channel: "email";
+  email: string;
+  otp_action: string;
+};
+
+/** @internal */
+export const GenerateOtpWithEmail$outboundSchema: z.ZodType<
+  GenerateOtpWithEmail$Outbound,
+  z.ZodTypeDef,
+  GenerateOtpWithEmail
+> = z.object({
+  channel: z.literal("email").default("email" as const),
+  email: z.string(),
+  otpAction: GenerateOtpWithEmailOtpAction$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    otpAction: "otp_action",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace GenerateOtpWithEmail$ {
+  /** @deprecated use `GenerateOtpWithEmail$inboundSchema` instead. */
+  export const inboundSchema = GenerateOtpWithEmail$inboundSchema;
+  /** @deprecated use `GenerateOtpWithEmail$outboundSchema` instead. */
+  export const outboundSchema = GenerateOtpWithEmail$outboundSchema;
+  /** @deprecated use `GenerateOtpWithEmail$Outbound` instead. */
+  export type Outbound = GenerateOtpWithEmail$Outbound;
+}
+
+export function generateOtpWithEmailToJSON(
+  generateOtpWithEmail: GenerateOtpWithEmail,
+): string {
+  return JSON.stringify(
+    GenerateOtpWithEmail$outboundSchema.parse(generateOtpWithEmail),
+  );
+}
+
+export function generateOtpWithEmailFromJSON(
+  jsonString: string,
+): SafeParseResult<GenerateOtpWithEmail, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GenerateOtpWithEmail$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GenerateOtpWithEmail' from JSON`,
+  );
+}

package/src/models/components/generateotpwithphone.ts

@@ -0,0 +1,148 @@
+/*
+ * 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 Channel = {
+  Sms: "sms",
+  Whatsapp: "whatsapp",
+} as const;
+export type Channel = ClosedEnum<typeof Channel>;
+
+export const OtpAction = {
+  Register: "register",
+  ResetPassword: "reset-password",
+  VerifyPhone: "verify-phone",
+  UpdatePhone: "update-phone",
+} as const;
+export type OtpAction = ClosedEnum<typeof OtpAction>;
+
+export type GenerateOtpWithPhone = {
+  channel: Channel;
+  /**
+   * Two-letter code begin with a plus sign prefix that identifies different countries. By default it will be +91 if not provided.
+   */
+  countryCode?: string | null | undefined;
+  /**
+   * 10 digit phone number without country code.
+   */
+  phone: string;
+  otpAction: OtpAction;
+};
+
+/** @internal */
+export const Channel$inboundSchema: z.ZodNativeEnum<typeof Channel> = z
+  .nativeEnum(Channel);
+
+/** @internal */
+export const Channel$outboundSchema: z.ZodNativeEnum<typeof Channel> =
+  Channel$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Channel$ {
+  /** @deprecated use `Channel$inboundSchema` instead. */
+  export const inboundSchema = Channel$inboundSchema;
+  /** @deprecated use `Channel$outboundSchema` instead. */
+  export const outboundSchema = Channel$outboundSchema;
+}
+
+/** @internal */
+export const OtpAction$inboundSchema: z.ZodNativeEnum<typeof OtpAction> = z
+  .nativeEnum(OtpAction);
+
+/** @internal */
+export const OtpAction$outboundSchema: z.ZodNativeEnum<typeof OtpAction> =
+  OtpAction$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OtpAction$ {
+  /** @deprecated use `OtpAction$inboundSchema` instead. */
+  export const inboundSchema = OtpAction$inboundSchema;
+  /** @deprecated use `OtpAction$outboundSchema` instead. */
+  export const outboundSchema = OtpAction$outboundSchema;
+}
+
+/** @internal */
+export const GenerateOtpWithPhone$inboundSchema: z.ZodType<
+  GenerateOtpWithPhone,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  channel: Channel$inboundSchema,
+  country_code: z.nullable(z.string()).optional(),
+  phone: z.string(),
+  otp_action: OtpAction$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "country_code": "countryCode",
+    "otp_action": "otpAction",
+  });
+});
+
+/** @internal */
+export type GenerateOtpWithPhone$Outbound = {
+  channel: string;
+  country_code?: string | null | undefined;
+  phone: string;
+  otp_action: string;
+};
+
+/** @internal */
+export const GenerateOtpWithPhone$outboundSchema: z.ZodType<
+  GenerateOtpWithPhone$Outbound,
+  z.ZodTypeDef,
+  GenerateOtpWithPhone
+> = z.object({
+  channel: Channel$outboundSchema,
+  countryCode: z.nullable(z.string()).optional(),
+  phone: z.string(),
+  otpAction: OtpAction$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    countryCode: "country_code",
+    otpAction: "otp_action",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace GenerateOtpWithPhone$ {
+  /** @deprecated use `GenerateOtpWithPhone$inboundSchema` instead. */
+  export const inboundSchema = GenerateOtpWithPhone$inboundSchema;
+  /** @deprecated use `GenerateOtpWithPhone$outboundSchema` instead. */
+  export const outboundSchema = GenerateOtpWithPhone$outboundSchema;
+  /** @deprecated use `GenerateOtpWithPhone$Outbound` instead. */
+  export type Outbound = GenerateOtpWithPhone$Outbound;
+}
+
+export function generateOtpWithPhoneToJSON(
+  generateOtpWithPhone: GenerateOtpWithPhone,
+): string {
+  return JSON.stringify(
+    GenerateOtpWithPhone$outboundSchema.parse(generateOtpWithPhone),
+  );
+}
+
+export function generateOtpWithPhoneFromJSON(
+  jsonString: string,
+): SafeParseResult<GenerateOtpWithPhone, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GenerateOtpWithPhone$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GenerateOtpWithPhone' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -3,6 +3,8 @@
  */
 
 export * from "./anonymoususer.js";
+export * from "./appliedcoupon.js";
+export * from "./appliedpromotion.js";
 export * from "./associatedoption.js";
 export * from "./banktransfer.js";
 export * from "./booleanattribute.js";
@@ -23,6 +25,8 @@ export * from "./dateattribute.js";
 export * from "./discountbasedpromotion.js";
 export * from "./fixedpricepromotion.js";
 export * from "./freegoodspromotion.js";
+export * from "./generateotpwithemail.js";
+export * from "./generateotpwithphone.js";
 export * from "./item.js";
 export * from "./juspaypaymentgatewayparams.js";
 export * from "./juspaypaymentinfo.js";

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",