ce-storefront 0.13.3 → 0.14.1

package/src/lib/config.ts

@@ -80,7 +80,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0",
-  sdkVersion: "0.13.3",
-  genVersion: "2.621.3",
-  userAgent: "speakeasy-sdk/typescript 0.13.3 2.621.3 1.0 ce-storefront",
+  sdkVersion: "0.14.1",
+  genVersion: "2.632.2",
+  userAgent: "speakeasy-sdk/typescript 0.14.1 2.632.2 1.0 ce-storefront",
 } as const;

package/src/lib/files.ts

@@ -38,3 +38,45 @@ export async function readableStreamToArrayBuffer(
 
   return concatenatedChunks.buffer as ArrayBuffer;
 }
+
+/**
+ * Determines the MIME content type based on a file's extension.
+ * Returns null if the extension is not recognized.
+ */
+export function getContentTypeFromFileName(fileName: string): string | null {
+  if (!fileName) return null;
+
+  const ext = fileName.toLowerCase().split(".").pop();
+  if (!ext) return null;
+
+  const mimeTypes: Record<string, string> = {
+    json: "application/json",
+    xml: "application/xml",
+    html: "text/html",
+    htm: "text/html",
+    txt: "text/plain",
+    csv: "text/csv",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    js: "application/javascript",
+    css: "text/css",
+    zip: "application/zip",
+    tar: "application/x-tar",
+    gz: "application/gzip",
+    mp4: "video/mp4",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+  };
+
+  return mimeTypes[ext] || null;
+}

package/src/lib/matchers.ts

@@ -3,11 +3,10 @@
  */
 
 import { CeError } from "../models/errors/ceerror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { Result } from "../types/fp.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
-import { safeParse } from "./schemas.js";
 
 export type Encoding =
   | "jsonl"
@@ -176,17 +175,19 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
+  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
-): MatchFunc<T, E | CeError | SDKValidationError> {
+): MatchFunc<T, E | CeError | ResponseValidationError> {
   return async function matchFunc(
     response: Response,
+    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
-    [result: Result<T, E | CeError | SDKValidationError>, raw: unknown]
+    [result: Result<T, E | CeError | ResponseValidationError>, raw: unknown]
   > {
     let raw: unknown;
     let matcher: Matcher<T, E> | undefined;
@@ -205,21 +206,22 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new CeError(
-          "Unexpected API response status or content-type",
+        error: new CeError("Unexpected Status or Content-Type", {
           response,
-          responseBody,
-        ),
-      }, responseBody];
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
         break;
       case "jsonl":
         raw = response.body;
@@ -231,16 +233,19 @@ export function match<T, E>(
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         encoding satisfies never;
@@ -250,11 +255,7 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new CeError(
-          "API error occurred",
-          response,
-          typeof raw === "string" ? raw : "",
-        ),
+        error: new CeError("API error occurred", { request, response, body }),
       }, raw];
     }
 
@@ -266,6 +267,9 @@ export function match<T, E>(
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
       };
     } else if (resultKey) {
       data = {
@@ -284,18 +288,20 @@ export function match<T, E>(
     }
 
     if ("err" in matcher) {
-      const result = safeParse(
+      const result = safeParseResponse(
         data,
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
+        { request, response, body },
       );
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(
+        safeParseResponse(
           data,
           (v: unknown) => matcher.schema.parse(v),
           "Response validation failed",
+          { request, response, body },
         ),
         raw,
       ];
@@ -318,25 +324,22 @@ export function unpackHeaders(headers: Headers): Record<string, string[]> {
   return out;
 }
 
-/**
- * Discards the response body to free up resources.
- *
- * To learn why this is need, see the undici docs:
- * https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function discardResponseBody(res: Response) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
-
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
   try {
-    let done = false;
-    while (!done) {
-      const res = await reader.read();
-      done = res.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
   }
 }

package/src/lib/security.ts

@@ -6,8 +6,8 @@ import * as components from "../models/components/index.js";
 
 type OAuth2PasswordFlow = {
   username: string;
-  password?: string | undefined;
-  clientID: string;
+  password: string;
+  clientID?: string | undefined;
   clientSecret?: string | undefined;
   tokenURL: string;
 };

package/src/models/components/coloroption.ts

@@ -94,7 +94,7 @@ export const ColorOption$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   name: z.string(),
-  type: z.literal("color").optional(),
+  type: z.literal("color").default("color").optional(),
   value: z.lazy(() => ColorOptionValue$inboundSchema),
 });
 

package/src/models/components/customeraddress.ts

@@ -63,7 +63,7 @@ export const CustomerAddress$inboundSchema: z.ZodType<
   pincode: z.string(),
   city: z.string(),
   state: z.string(),
-  country: z.literal("India").optional(),
+  country: z.literal("India").default("India").optional(),
   tax_identification_number: z.nullable(z.string()),
   business_name: z.nullable(z.string()),
   is_phone_verified: z.boolean(),

package/src/models/components/customeraddressinput.ts

@@ -61,7 +61,7 @@ export const CustomerAddressInput$inboundSchema: z.ZodType<
   pincode: z.string(),
   city: z.string(),
   state: z.string(),
-  country: z.literal("India").optional(),
+  country: z.literal("India").default("India").optional(),
   tax_identification_number: z.nullable(z.string()),
   business_name: z.nullable(z.string()),
 }).transform((v) => {

package/src/models/components/discountbasedpromotion.ts

@@ -82,7 +82,7 @@ export const DiscountBasedPromotion$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  promotion_type: z.literal("discount").optional(),
+  promotion_type: z.literal("discount").default("discount").optional(),
   discount_type: DiscountType$inboundSchema,
   discount_percent: z.number().optional(),
   discount_fixed_amount: z.number().int().optional(),

package/src/models/components/fixedpricepromotion.ts

@@ -51,7 +51,7 @@ export const FixedPricePromotion$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  promotion_type: z.literal("fixed-price").optional(),
+  promotion_type: z.literal("fixed-price").default("fixed-price").optional(),
   offer_price: z.number(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/freegoodspromotion.ts

@@ -58,7 +58,7 @@ export const FreeGoodsPromotion$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  promotion_type: z.literal("free-goods").optional(),
+  promotion_type: z.literal("free-goods").default("free-goods").optional(),
   buy_quantity: z.number().int(),
   get_quantity: z.number().int(),
 }).transform((v) => {

package/src/models/components/generateotpwithemail.ts

@@ -52,7 +52,7 @@ export const GenerateOtpWithEmail$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  channel: z.literal("email").optional(),
+  channel: z.literal("email").default("email").optional(),
   email: z.string(),
   otp_action: GenerateOtpWithEmailOtpAction$inboundSchema,
 }).transform((v) => {

package/src/models/components/juspaypaymentinfo.ts

@@ -203,11 +203,12 @@ export const Payload$inboundSchema: z.ZodType<Payload, z.ZodTypeDef, unknown> =
     customerEmail: z.string().optional(),
     currency: z.string().optional(),
     description: z.string().optional(),
-    "options.createMandate": z.literal("REQUIRED").optional(),
+    "options.createMandate": z.literal("REQUIRED").default("REQUIRED")
+      .optional(),
     "mandate.maxAmount": z.string().optional(),
     "mandate.start_date ": z.string().optional(),
     "mandate.end_date ": z.string().optional(),
-    "mandate.frequency": z.literal("MONTHLY").optional(),
+    "mandate.frequency": z.literal("MONTHLY").default("MONTHLY").optional(),
     "mandate.rule_value ": MandateRuleValue$inboundSchema.optional(),
   }).transform((v) => {
     return remap$(v, {

package/src/models/components/orderpayment.ts

@@ -41,10 +41,10 @@ import {
  * Order Payment
  */
 export type OrderPayment =
+  | CardPayment
   | NetbankingPayment
   | UpiPayment
   | WalletPayment
-  | CardPayment
   | BankTransfer;
 
 /** @internal */
@@ -53,19 +53,19 @@ export const OrderPayment$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
+  CardPayment$inboundSchema,
   NetbankingPayment$inboundSchema,
   UpiPayment$inboundSchema,
   WalletPayment$inboundSchema,
-  CardPayment$inboundSchema,
   BankTransfer$inboundSchema,
 ]);
 
 /** @internal */
 export type OrderPayment$Outbound =
+  | CardPayment$Outbound
   | NetbankingPayment$Outbound
   | UpiPayment$Outbound
   | WalletPayment$Outbound
-  | CardPayment$Outbound
   | BankTransfer$Outbound;
 
 /** @internal */
@@ -74,10 +74,10 @@ export const OrderPayment$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OrderPayment
 > = z.union([
+  CardPayment$outboundSchema,
   NetbankingPayment$outboundSchema,
   UpiPayment$outboundSchema,
   WalletPayment$outboundSchema,
-  CardPayment$outboundSchema,
   BankTransfer$outboundSchema,
 ]);
 

package/src/models/components/payupaymentinfo.ts

@@ -81,8 +81,8 @@ export const SiDetails$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   billingAmount: z.number().optional(),
-  billingCurrency: z.literal("INR").optional(),
-  billingCycle: z.literal("MONTHLY").optional(),
+  billingCurrency: z.literal("INR").default("INR").optional(),
+  billingCycle: z.literal("MONTHLY").default("MONTHLY").optional(),
   billingInterval: z.number().int().optional(),
   paymentStartDate: z.string().transform(v => new RFCDate(v)).optional(),
   paymentEndDate: z.string().transform(v => new RFCDate(v)).optional(),
@@ -154,7 +154,7 @@ export const PayuPaymentInfo$inboundSchema: z.ZodType<
   lastname: z.string().optional(),
   email: z.string().optional(),
   phone: z.string().optional(),
-  si: z.literal(1).optional(),
+  si: z.literal(1).default(1).optional(),
   si_details: z.lazy(() => SiDetails$inboundSchema).optional(),
   furl: z.string().optional(),
   surl: z.string().optional(),

package/src/models/components/product.ts

@@ -8,6 +8,12 @@ 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 {
+  Category,
+  Category$inboundSchema,
+  Category$Outbound,
+  Category$outboundSchema,
+} from "./category.js";
 import {
   ProductAttribute,
   ProductAttribute$inboundSchema,
@@ -101,6 +107,7 @@ export type Product = {
   hasVariant: boolean;
   tags: Array<string> | null;
   categoryIds: Array<string>;
+  categories: Array<Category>;
   reviewsRatingSum: number;
   reviewsCount: number;
   attributes: Array<ProductAttribute>;
@@ -153,6 +160,7 @@ export const Product$inboundSchema: z.ZodType<Product, z.ZodTypeDef, unknown> =
     has_variant: z.boolean(),
     tags: z.nullable(z.array(z.string())),
     category_ids: z.array(z.string()),
+    categories: z.array(Category$inboundSchema),
     reviews_rating_sum: z.number(),
     reviews_count: z.number().int(),
     attributes: z.array(ProductAttribute$inboundSchema),
@@ -197,6 +205,7 @@ export type Product$Outbound = {
   has_variant: boolean;
   tags: Array<string> | null;
   category_ids: Array<string>;
+  categories: Array<Category$Outbound>;
   reviews_rating_sum: number;
   reviews_count: number;
   attributes: Array<ProductAttribute$Outbound>;
@@ -230,6 +239,7 @@ export const Product$outboundSchema: z.ZodType<
   hasVariant: z.boolean(),
   tags: z.nullable(z.array(z.string())),
   categoryIds: z.array(z.string()),
+  categories: z.array(Category$outboundSchema),
   reviewsRatingSum: z.number(),
   reviewsCount: z.number().int(),
   attributes: z.array(ProductAttribute$outboundSchema),

package/src/models/components/productdetail.ts

@@ -8,6 +8,12 @@ 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 {
+  Category,
+  Category$inboundSchema,
+  Category$Outbound,
+  Category$outboundSchema,
+} from "./category.js";
 import {
   ProductAttribute,
   ProductAttribute$inboundSchema,
@@ -121,6 +127,7 @@ export type ProductDetail = {
   hasVariant: boolean;
   tags: Array<string> | null;
   categoryIds: Array<string>;
+  categories: Array<Category>;
   reviewsRatingSum: number;
   reviewsCount: number;
   attributes: Array<ProductAttribute>;
@@ -192,6 +199,7 @@ export const ProductDetail$inboundSchema: z.ZodType<
   has_variant: z.boolean(),
   tags: z.nullable(z.array(z.string())),
   category_ids: z.array(z.string()),
+  categories: z.array(Category$inboundSchema),
   reviews_rating_sum: z.number(),
   reviews_count: z.number().int(),
   attributes: z.array(ProductAttribute$inboundSchema),
@@ -247,6 +255,7 @@ export type ProductDetail$Outbound = {
   has_variant: boolean;
   tags: Array<string> | null;
   category_ids: Array<string>;
+  categories: Array<Category$Outbound>;
   reviews_rating_sum: number;
   reviews_count: number;
   attributes: Array<ProductAttribute$Outbound>;
@@ -288,6 +297,7 @@ export const ProductDetail$outboundSchema: z.ZodType<
   hasVariant: z.boolean(),
   tags: z.nullable(z.array(z.string())),
   categoryIds: z.array(z.string()),
+  categories: z.array(Category$outboundSchema),
   reviewsRatingSum: z.number(),
   reviewsCount: z.number().int(),
   attributes: z.array(ProductAttribute$outboundSchema),

package/src/models/components/productpromotion.ts

@@ -33,35 +33,25 @@ import {
 } from "./volumebasedpromotion.js";
 
 export type Details =
-  | (FixedPricePromotion & { promotionType: "fixed-price" })
-  | (VolumeBasedPromotion & { promotionType: "volume-based" })
   | (FreeGoodsPromotion & { promotionType: "free-goods" })
-  | (DiscountBasedPromotion & { promotionType: "discount" });
+  | (DiscountBasedPromotion & { promotionType: "discount" })
+  | (FixedPricePromotion & { promotionType: "fixed-price" })
+  | (VolumeBasedPromotion & { promotionType: "volume-based" });
 
 export type ProductPromotion = {
   id: string;
   startsAt: Date;
   expiresAt: Date | null;
   details:
-    | (FixedPricePromotion & { promotionType: "fixed-price" })
-    | (VolumeBasedPromotion & { promotionType: "volume-based" })
     | (FreeGoodsPromotion & { promotionType: "free-goods" })
-    | (DiscountBasedPromotion & { promotionType: "discount" });
+    | (DiscountBasedPromotion & { promotionType: "discount" })
+    | (FixedPricePromotion & { promotionType: "fixed-price" })
+    | (VolumeBasedPromotion & { promotionType: "volume-based" });
 };
 
 /** @internal */
 export const Details$inboundSchema: z.ZodType<Details, z.ZodTypeDef, unknown> =
   z.union([
-    FixedPricePromotion$inboundSchema.and(
-      z.object({ promotion_type: z.literal("fixed-price") }).transform((v) => ({
-        promotionType: v.promotion_type,
-      })),
-    ),
-    VolumeBasedPromotion$inboundSchema.and(
-      z.object({ promotion_type: z.literal("volume-based") }).transform((
-        v,
-      ) => ({ promotionType: v.promotion_type })),
-    ),
     FreeGoodsPromotion$inboundSchema.and(
       z.object({ promotion_type: z.literal("free-goods") }).transform((v) => ({
         promotionType: v.promotion_type,
@@ -72,14 +62,24 @@ export const Details$inboundSchema: z.ZodType<Details, z.ZodTypeDef, unknown> =
         promotionType: v.promotion_type,
       })),
     ),
+    FixedPricePromotion$inboundSchema.and(
+      z.object({ promotion_type: z.literal("fixed-price") }).transform((v) => ({
+        promotionType: v.promotion_type,
+      })),
+    ),
+    VolumeBasedPromotion$inboundSchema.and(
+      z.object({ promotion_type: z.literal("volume-based") }).transform((
+        v,
+      ) => ({ promotionType: v.promotion_type })),
+    ),
   ]);
 
 /** @internal */
 export type Details$Outbound =
-  | (FixedPricePromotion$Outbound & { promotion_type: "fixed-price" })
-  | (VolumeBasedPromotion$Outbound & { promotion_type: "volume-based" })
   | (FreeGoodsPromotion$Outbound & { promotion_type: "free-goods" })
-  | (DiscountBasedPromotion$Outbound & { promotion_type: "discount" });
+  | (DiscountBasedPromotion$Outbound & { promotion_type: "discount" })
+  | (FixedPricePromotion$Outbound & { promotion_type: "fixed-price" })
+  | (VolumeBasedPromotion$Outbound & { promotion_type: "volume-based" });
 
 /** @internal */
 export const Details$outboundSchema: z.ZodType<
@@ -87,23 +87,23 @@ export const Details$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Details
 > = z.union([
-  FixedPricePromotion$outboundSchema.and(
-    z.object({ promotionType: z.literal("fixed-price") }).transform((v) => ({
+  FreeGoodsPromotion$outboundSchema.and(
+    z.object({ promotionType: z.literal("free-goods") }).transform((v) => ({
       promotion_type: v.promotionType,
     })),
   ),
-  VolumeBasedPromotion$outboundSchema.and(
-    z.object({ promotionType: z.literal("volume-based") }).transform((v) => ({
+  DiscountBasedPromotion$outboundSchema.and(
+    z.object({ promotionType: z.literal("discount") }).transform((v) => ({
       promotion_type: v.promotionType,
     })),
   ),
-  FreeGoodsPromotion$outboundSchema.and(
-    z.object({ promotionType: z.literal("free-goods") }).transform((v) => ({
+  FixedPricePromotion$outboundSchema.and(
+    z.object({ promotionType: z.literal("fixed-price") }).transform((v) => ({
       promotion_type: v.promotionType,
     })),
   ),
-  DiscountBasedPromotion$outboundSchema.and(
-    z.object({ promotionType: z.literal("discount") }).transform((v) => ({
+  VolumeBasedPromotion$outboundSchema.and(
+    z.object({ promotionType: z.literal("volume-based") }).transform((v) => ({
       promotion_type: v.promotionType,
     })),
   ),
@@ -148,16 +148,6 @@ export const ProductPromotion$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
   details: z.union([
-    FixedPricePromotion$inboundSchema.and(
-      z.object({ promotion_type: z.literal("fixed-price") }).transform((v) => ({
-        promotionType: v.promotion_type,
-      })),
-    ),
-    VolumeBasedPromotion$inboundSchema.and(
-      z.object({ promotion_type: z.literal("volume-based") }).transform((
-        v,
-      ) => ({ promotionType: v.promotion_type })),
-    ),
     FreeGoodsPromotion$inboundSchema.and(
       z.object({ promotion_type: z.literal("free-goods") }).transform((v) => ({
         promotionType: v.promotion_type,
@@ -168,6 +158,16 @@ export const ProductPromotion$inboundSchema: z.ZodType<
         promotionType: v.promotion_type,
       })),
     ),
+    FixedPricePromotion$inboundSchema.and(
+      z.object({ promotion_type: z.literal("fixed-price") }).transform((v) => ({
+        promotionType: v.promotion_type,
+      })),
+    ),
+    VolumeBasedPromotion$inboundSchema.and(
+      z.object({ promotion_type: z.literal("volume-based") }).transform((
+        v,
+      ) => ({ promotionType: v.promotion_type })),
+    ),
   ]),
 }).transform((v) => {
   return remap$(v, {
@@ -182,10 +182,10 @@ export type ProductPromotion$Outbound = {
   starts_at: string;
   expires_at: string | null;
   details:
-    | (FixedPricePromotion$Outbound & { promotion_type: "fixed-price" })
-    | (VolumeBasedPromotion$Outbound & { promotion_type: "volume-based" })
     | (FreeGoodsPromotion$Outbound & { promotion_type: "free-goods" })
-    | (DiscountBasedPromotion$Outbound & { promotion_type: "discount" });
+    | (DiscountBasedPromotion$Outbound & { promotion_type: "discount" })
+    | (FixedPricePromotion$Outbound & { promotion_type: "fixed-price" })
+    | (VolumeBasedPromotion$Outbound & { promotion_type: "volume-based" });
 };
 
 /** @internal */
@@ -198,23 +198,23 @@ export const ProductPromotion$outboundSchema: z.ZodType<
   startsAt: z.date().transform(v => v.toISOString()),
   expiresAt: z.nullable(z.date().transform(v => v.toISOString())),
   details: z.union([
-    FixedPricePromotion$outboundSchema.and(
-      z.object({ promotionType: z.literal("fixed-price") }).transform((v) => ({
+    FreeGoodsPromotion$outboundSchema.and(
+      z.object({ promotionType: z.literal("free-goods") }).transform((v) => ({
         promotion_type: v.promotionType,
       })),
     ),
-    VolumeBasedPromotion$outboundSchema.and(
-      z.object({ promotionType: z.literal("volume-based") }).transform((v) => ({
+    DiscountBasedPromotion$outboundSchema.and(
+      z.object({ promotionType: z.literal("discount") }).transform((v) => ({
         promotion_type: v.promotionType,
       })),
     ),
-    FreeGoodsPromotion$outboundSchema.and(
-      z.object({ promotionType: z.literal("free-goods") }).transform((v) => ({
+    FixedPricePromotion$outboundSchema.and(
+      z.object({ promotionType: z.literal("fixed-price") }).transform((v) => ({
         promotion_type: v.promotionType,
       })),
     ),
-    DiscountBasedPromotion$outboundSchema.and(
-      z.object({ promotionType: z.literal("discount") }).transform((v) => ({
+    VolumeBasedPromotion$outboundSchema.and(
+      z.object({ promotionType: z.literal("volume-based") }).transform((v) => ({
         promotion_type: v.promotionType,
       })),
     ),