@01.software/cli 0.21.0 → 0.21.2

package/dist/index.js

@@ -248,6 +248,15 @@ var EMBEDDED_ADMIN_ENDPOINT_OPERATIONS = {
 };
 var EVENTS_ENDPOINT_OPERATIONS = {
   registrations: {
+    register: operation("event-registrations", "post", "/register"),
+    guestLookup: operation("event-registrations", "post", "/guest/lookup"),
+    guestLookupByUrl: operation("event-registrations", "get", "/guest/:token"),
+    guestCancel: operation("event-registrations", "post", "/guest/cancel"),
+    guestCancelByUrl: operation(
+      "event-registrations",
+      "post",
+      "/guest/:token/cancel"
+    ),
     listMine: operation("event-registrations", "get", "/my")
   },
   events: {
@@ -1620,8 +1629,27 @@ function registerCrudCommands(program, getClient, getFormat) {
   });
 }
 
-// ../../internal/contracts/src/tenant/index.ts
+// ../../internal/contracts/src/datetime.ts
 import { z } from "zod";
+function isoDatetimeSchema(options = {}) {
+  const date = z.regexes.date.source.slice(1, -1);
+  const time = z.regexes.time({}).source.slice(1, -1);
+  const zone = options.offset ? "Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)" : "Z";
+  const pattern = new RegExp(`^${date}T(?:${time}(?:${zone}))$`);
+  return z.string().superRefine((value, ctx) => {
+    if (!pattern.test(value)) {
+      ctx.addIssue({
+        origin: "string",
+        code: "invalid_format",
+        format: "datetime",
+        pattern: pattern.toString()
+      });
+    }
+  }).meta({ format: "date-time", pattern: pattern.source });
+}
+
+// ../../internal/contracts/src/tenant/index.ts
+import { z as z2 } from "zod";
 
 // ../../internal/contracts/src/tenant/features.ts
 var TENANT_CUSTOM_FIELD_TYPES = [
@@ -1633,51 +1661,51 @@ var TENANT_CUSTOM_FIELD_TYPES = [
 ];
 
 // ../../internal/contracts/src/tenant/index.ts
-var tenantFieldConfigStateSchema = z.object({
-  hiddenFields: z.array(z.string()),
-  isHidden: z.boolean()
+var tenantFieldConfigStateSchema = z2.object({
+  hiddenFields: z2.array(z2.string()),
+  isHidden: z2.boolean()
 }).strict();
-var tenantContextQuerySchema = z.object({
-  counts: z.literal("true").optional()
+var tenantContextQuerySchema = z2.object({
+  counts: z2.literal("true").optional()
 }).strict();
-var tenantContextToolInputSchema = z.object({
-  includeCounts: z.boolean().optional().default(false).describe(
+var tenantContextToolInputSchema = z2.object({
+  includeCounts: z2.boolean().optional().default(false).describe(
     "Include per-collection document counts and config status (bypasses cache, slower)"
   )
 }).strict();
-var tenantContextResponseSchema = z.object({
-  tenant: z.object({
-    id: z.string(),
-    name: z.string(),
-    plan: z.string(),
-    planSource: z.string().optional(),
-    authoritative: z.boolean().optional(),
-    capabilityVersion: z.string().optional()
+var tenantContextResponseSchema = z2.object({
+  tenant: z2.object({
+    id: z2.string(),
+    name: z2.string(),
+    plan: z2.string(),
+    planSource: z2.string().optional(),
+    authoritative: z2.boolean().optional(),
+    capabilityVersion: z2.string().optional()
   }).strict(),
-  features: z.array(z.string()),
-  collections: z.object({
-    active: z.array(z.string()),
-    inactive: z.array(z.string())
+  features: z2.array(z2.string()),
+  collections: z2.object({
+    active: z2.array(z2.string()),
+    inactive: z2.array(z2.string())
   }).strict(),
-  fieldConfigs: z.record(z.string(), tenantFieldConfigStateSchema),
-  counts: z.record(z.string(), z.number()).optional(),
-  config: z.object({
-    webhookConfigured: z.boolean()
+  fieldConfigs: z2.record(z2.string(), tenantFieldConfigStateSchema),
+  counts: z2.record(z2.string(), z2.number()).optional(),
+  config: z2.object({
+    webhookConfigured: z2.boolean()
   }).strict().optional()
 }).strict();
-var tenantFeatureProgressFeatureSchema = z.enum(["ecommerce"]);
-var tenantFeatureProgressInputSchema = z.object({
+var tenantFeatureProgressFeatureSchema = z2.enum(["ecommerce"]);
+var tenantFeatureProgressInputSchema = z2.object({
   feature: tenantFeatureProgressFeatureSchema.describe(
     "Feature to inspect for tenant implementation readiness"
   ),
-  includeEvidence: z.boolean().optional().default(false).describe("Include sanitized counts and static surface evidence")
+  includeEvidence: z2.boolean().optional().default(false).describe("Include sanitized counts and static surface evidence")
 }).strict();
-var tenantFeatureProgressStatusSchema = z.enum([
+var tenantFeatureProgressStatusSchema = z2.enum([
   "ready",
   "attention",
   "blocked"
 ]);
-var tenantFeatureProgressItemStateSchema = z.enum([
+var tenantFeatureProgressItemStateSchema = z2.enum([
   "complete",
   "incomplete",
   "blocked",
@@ -1687,161 +1715,161 @@ var tenantFeatureProgressItemStateSchema = z.enum([
   "manual",
   "not-applicable"
 ]);
-var tenantFeatureProgressSeveritySchema = z.enum([
+var tenantFeatureProgressSeveritySchema = z2.enum([
   "required",
   "recommended",
   "optional"
 ]);
-var tenantFeatureProgressEvidenceValueSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null()
+var tenantFeatureProgressEvidenceValueSchema = z2.union([
+  z2.string(),
+  z2.number(),
+  z2.boolean(),
+  z2.null()
 ]);
-var tenantFeatureProgressItemSchema = z.object({
-  id: z.string(),
-  title: z.string(),
+var tenantFeatureProgressItemSchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
   state: tenantFeatureProgressItemStateSchema,
   severity: tenantFeatureProgressSeveritySchema,
-  summary: z.string(),
-  evidence: z.record(z.string(), tenantFeatureProgressEvidenceValueSchema).optional()
+  summary: z2.string(),
+  evidence: z2.record(z2.string(), tenantFeatureProgressEvidenceValueSchema).optional()
 }).strict();
-var tenantFeatureProgressGroupSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  summary: z.string().optional(),
-  items: z.array(tenantFeatureProgressItemSchema)
+var tenantFeatureProgressGroupSchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  summary: z2.string().optional(),
+  items: z2.array(tenantFeatureProgressItemSchema)
 }).strict();
-var tenantFeatureProgressResponseSchema = z.object({
-  schemaVersion: z.literal(1),
+var tenantFeatureProgressResponseSchema = z2.object({
+  schemaVersion: z2.literal(1),
   feature: tenantFeatureProgressFeatureSchema,
   status: tenantFeatureProgressStatusSchema,
-  generatedAt: z.string(),
-  tenant: z.object({
-    id: z.string(),
-    name: z.string(),
-    plan: z.string()
+  generatedAt: z2.string(),
+  tenant: z2.object({
+    id: z2.string(),
+    name: z2.string(),
+    plan: z2.string()
   }).strict(),
-  capability: z.object({
-    effectiveFeatures: z.array(z.string()),
-    planBlocked: z.array(z.string()),
-    closureAdded: z.array(z.string())
+  capability: z2.object({
+    effectiveFeatures: z2.array(z2.string()),
+    planBlocked: z2.array(z2.string()),
+    closureAdded: z2.array(z2.string())
   }).strict(),
-  config: z.object({
-    fulfillmentMode: z.enum(["shipping", "none"])
+  config: z2.object({
+    fulfillmentMode: z2.enum(["shipping", "none"])
   }).strict(),
-  summary: z.object({
-    complete: z.number().int().nonnegative(),
-    total: z.number().int().nonnegative(),
-    blocking: z.number().int().nonnegative(),
-    manual: z.number().int().nonnegative(),
-    unknown: z.number().int().nonnegative()
+  summary: z2.object({
+    complete: z2.number().int().nonnegative(),
+    total: z2.number().int().nonnegative(),
+    blocking: z2.number().int().nonnegative(),
+    manual: z2.number().int().nonnegative(),
+    unknown: z2.number().int().nonnegative()
   }).strict(),
-  groups: z.array(tenantFeatureProgressGroupSchema)
+  groups: z2.array(tenantFeatureProgressGroupSchema)
 }).strict();
 var COLLECTION_SCHEMA_CONTRACT_VERSION = 1;
-var collectionSchemaEndpointParamsSchema = z.object({
-  collectionSlug: z.string().min(1, "collectionSlug is required")
+var collectionSchemaEndpointParamsSchema = z2.object({
+  collectionSlug: z2.string().min(1, "collectionSlug is required")
 }).strict();
-var collectionFieldOptionSchema = z.object({
-  label: z.string(),
-  value: z.string()
+var collectionFieldOptionSchema = z2.object({
+  label: z2.string(),
+  value: z2.string()
 }).strict();
-var collectionCustomFieldRequiredSchema = z.literal(true).optional();
-var collectionCustomFieldDefinitionSchema = z.discriminatedUnion(
+var collectionCustomFieldRequiredSchema = z2.literal(true).optional();
+var collectionCustomFieldDefinitionSchema = z2.discriminatedUnion(
   "type",
   [
-    z.object({
-      key: z.string().min(1),
-      type: z.enum(
+    z2.object({
+      key: z2.string().min(1),
+      type: z2.enum(
         TENANT_CUSTOM_FIELD_TYPES.filter((type) => type !== "select")
       ),
       required: collectionCustomFieldRequiredSchema
     }).strict(),
-    z.object({
-      key: z.string().min(1),
-      type: z.literal("select"),
+    z2.object({
+      key: z2.string().min(1),
+      type: z2.literal("select"),
       required: collectionCustomFieldRequiredSchema,
-      options: z.array(z.string().min(1)).min(1)
+      options: z2.array(z2.string().min(1)).min(1)
     }).strict()
   ]
 );
-var collectionCustomFieldsSchema = z.object({
-  storagePath: z.literal("customData"),
-  definitions: z.array(collectionCustomFieldDefinitionSchema)
+var collectionCustomFieldsSchema = z2.object({
+  storagePath: z2.literal("customData"),
+  definitions: z2.array(collectionCustomFieldDefinitionSchema)
 }).strict();
-var collectionFieldSchema = z.lazy(
-  () => z.object({
-    name: z.string(),
-    path: z.string(),
-    type: z.string(),
-    required: z.literal(true).optional(),
-    unique: z.literal(true).optional(),
-    hasMany: z.literal(true).optional(),
-    relationTo: z.union([z.string(), z.array(z.string())]).optional(),
-    options: z.array(collectionFieldOptionSchema).optional(),
-    hidden: z.literal(true).optional(),
-    systemManaged: z.literal(true).optional(),
-    writable: z.boolean().optional(),
-    fields: z.array(collectionFieldSchema).optional()
+var collectionFieldSchema = z2.lazy(
+  () => z2.object({
+    name: z2.string(),
+    path: z2.string(),
+    type: z2.string(),
+    required: z2.literal(true).optional(),
+    unique: z2.literal(true).optional(),
+    hasMany: z2.literal(true).optional(),
+    relationTo: z2.union([z2.string(), z2.array(z2.string())]).optional(),
+    options: z2.array(collectionFieldOptionSchema).optional(),
+    hidden: z2.literal(true).optional(),
+    systemManaged: z2.literal(true).optional(),
+    writable: z2.boolean().optional(),
+    fields: z2.array(collectionFieldSchema).optional()
   }).strict()
 );
-var collectionSchemaResponseSchema = z.object({
-  contractVersion: z.literal(COLLECTION_SCHEMA_CONTRACT_VERSION),
-  mode: z.literal("effective"),
-  collection: z.object({
-    slug: z.string(),
-    timestamps: z.boolean(),
-    alwaysActive: z.boolean(),
-    feature: z.string().nullable(),
-    systemFields: z.array(z.string()),
-    visibility: z.object({
-      collectionHidden: z.boolean(),
-      hiddenFields: z.array(z.string())
+var collectionSchemaResponseSchema = z2.object({
+  contractVersion: z2.literal(COLLECTION_SCHEMA_CONTRACT_VERSION),
+  mode: z2.literal("effective"),
+  collection: z2.object({
+    slug: z2.string(),
+    timestamps: z2.boolean(),
+    alwaysActive: z2.boolean(),
+    feature: z2.string().nullable(),
+    systemFields: z2.array(z2.string()),
+    visibility: z2.object({
+      collectionHidden: z2.boolean(),
+      hiddenFields: z2.array(z2.string())
     }).strict(),
-    fields: z.array(collectionFieldSchema),
+    fields: z2.array(collectionFieldSchema),
     customFields: collectionCustomFieldsSchema.optional()
   }).strict()
 }).strict();
 
 // ../../internal/contracts/src/ecommerce/index.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../../internal/contracts/src/ecommerce/product-upsert.ts
-import { z as z2 } from "zod";
-var IdSchema = z2.union([z2.string(), z2.number()]).transform(String);
-var RemovedLegacyMediaFieldSchema = z2.unknown().optional();
+import { z as z3 } from "zod";
+var IdSchema = z3.union([z3.string(), z3.number()]).transform(String);
+var RemovedLegacyMediaFieldSchema = z3.unknown().optional();
 var productFieldShape = {
   id: IdSchema.optional(),
-  title: z2.string().min(1).optional(),
-  subtitle: z2.string().optional().nullable(),
-  description: z2.string().optional().nullable(),
-  status: z2.string().optional(),
-  slug: z2.string().optional(),
-  images: z2.array(IdSchema).optional(),
+  title: z3.string().min(1).optional(),
+  subtitle: z3.string().optional().nullable(),
+  description: z3.string().optional().nullable(),
+  status: z3.string().optional(),
+  slug: z3.string().optional(),
+  images: z3.array(IdSchema).optional(),
   mediaSets: RemovedLegacyMediaFieldSchema,
-  vendor: z2.string().optional().nullable(),
-  productType: z2.string().optional().nullable(),
+  vendor: z3.string().optional().nullable(),
+  productType: z3.string().optional().nullable(),
   brand: IdSchema.optional().nullable(),
   shippingPolicy: IdSchema.optional().nullable(),
-  weight: z2.number().int().min(0).optional().nullable(),
-  minOrderQuantity: z2.number().int().min(1).optional().nullable(),
-  maxOrderQuantity: z2.number().int().min(1).optional().nullable(),
-  isFeatured: z2.boolean().optional(),
-  publishedAt: z2.string().optional().nullable(),
-  categories: z2.array(IdSchema).optional(),
-  tags: z2.array(IdSchema).optional(),
-  markets: z2.array(IdSchema).optional().nullable(),
-  seo: z2.object({
-    title: z2.string().optional().nullable(),
-    description: z2.string().optional().nullable()
+  weight: z3.number().int().min(0).optional().nullable(),
+  minOrderQuantity: z3.number().int().min(1).optional().nullable(),
+  maxOrderQuantity: z3.number().int().min(1).optional().nullable(),
+  isFeatured: z3.boolean().optional(),
+  publishedAt: z3.string().optional().nullable(),
+  categories: z3.array(IdSchema).optional(),
+  tags: z3.array(IdSchema).optional(),
+  markets: z3.array(IdSchema).optional().nullable(),
+  seo: z3.object({
+    title: z3.string().optional().nullable(),
+    description: z3.string().optional().nullable()
   }).optional().nullable(),
-  metadata: z2.unknown().optional()
+  metadata: z3.unknown().optional()
 };
 var PRODUCT_UPSERT_PRODUCT_FIELDS = Object.keys(
   productFieldShape
 );
-var ProductFieldsSchema = z2.object(productFieldShape).passthrough().superRefine((value, ctx) => {
+var ProductFieldsSchema = z3.object(productFieldShape).passthrough().superRefine((value, ctx) => {
   for (const field of ["primaryMediaItemId", "thumbnail"]) {
     if (Object.prototype.hasOwnProperty.call(value, field)) {
       ctx.addIssue({
@@ -1852,18 +1880,18 @@ var ProductFieldsSchema = z2.object(productFieldShape).passthrough().superRefine
     }
   }
 });
-var OptionValueObjectSchema = z2.object({
+var OptionValueObjectSchema = z3.object({
   id: IdSchema.optional(),
-  value: z2.string().min(1, "Option value `value` is required"),
-  slug: z2.string().optional(),
-  swatch: z2.object({
-    type: z2.enum(["color", "media"]).optional().nullable(),
-    color: z2.string().optional().nullable(),
+  value: z3.string().min(1, "Option value `value` is required"),
+  slug: z3.string().optional(),
+  swatch: z3.object({
+    type: z3.enum(["color", "media"]).optional().nullable(),
+    color: z3.string().optional().nullable(),
     mediaItemId: IdSchema.optional().nullable()
   }).optional().nullable(),
   thumbnail: RemovedLegacyMediaFieldSchema,
   images: RemovedLegacyMediaFieldSchema,
-  metadata: z2.unknown().optional()
+  metadata: z3.unknown().optional()
 });
 var OptionValueInputSchema = OptionValueObjectSchema.passthrough().superRefine((value, ctx) => {
   if (Object.prototype.hasOwnProperty.call(value, "swatchColor")) {
@@ -1874,16 +1902,16 @@ var OptionValueInputSchema = OptionValueObjectSchema.passthrough().superRefine((
     });
   }
 });
-var OptionInputSchema = z2.object({
+var OptionInputSchema = z3.object({
   id: IdSchema.optional(),
-  title: z2.string().min(1, "Option `title` is required"),
-  slug: z2.string().optional(),
-  values: z2.array(OptionValueInputSchema).min(1, "Each option must have at least one value")
+  title: z3.string().min(1, "Option `title` is required"),
+  slug: z3.string().optional(),
+  values: z3.array(OptionValueInputSchema).min(1, "Each option must have at least one value")
 });
-var VariantOptionValueObjectSchema = z2.object({
-  valueSlug: z2.string().optional(),
+var VariantOptionValueObjectSchema = z3.object({
+  valueSlug: z3.string().optional(),
   valueId: IdSchema.optional(),
-  value: z2.string().optional()
+  value: z3.string().optional()
 }).refine((data) => Boolean(data.valueSlug ?? data.valueId ?? data.value), {
   message: "Variant option value object requires valueSlug, valueId, or value"
 });
@@ -1896,51 +1924,51 @@ function catalogAmountDecimalPlaces(value) {
   const dot = text.indexOf(".");
   return dot === -1 ? 0 : text.length - dot - 1;
 }
-var CatalogAmountSchema = z2.number().min(0).refine(
+var CatalogAmountSchema = z3.number().min(0).refine(
   (value) => catalogAmountDecimalPlaces(value) <= MAX_CATALOG_AMOUNT_DECIMAL_PLACES,
   {
     message: `Amount must have at most ${MAX_CATALOG_AMOUNT_DECIMAL_PLACES} decimal places; the store currency may allow fewer.`
   }
 );
-var VariantMarketPriceInputSchema = z2.object({
+var VariantMarketPriceInputSchema = z3.object({
   market: IdSchema,
   price: CatalogAmountSchema,
   compareAtPrice: CatalogAmountSchema.optional().nullable()
 });
-var VariantInputSchema = z2.object({
+var VariantInputSchema = z3.object({
   id: IdSchema.optional(),
-  optionValues: z2.union([
-    z2.record(
-      z2.string(),
-      z2.union([z2.string(), VariantOptionValueObjectSchema])
+  optionValues: z3.union([
+    z3.record(
+      z3.string(),
+      z3.union([z3.string(), VariantOptionValueObjectSchema])
     ),
-    z2.array(IdSchema)
+    z3.array(IdSchema)
   ]).optional(),
-  sku: z2.string().optional().nullable(),
-  title: z2.string().optional().nullable(),
+  sku: z3.string().optional().nullable(),
+  title: z3.string().optional().nullable(),
   price: CatalogAmountSchema,
   compareAtPrice: CatalogAmountSchema.optional().nullable(),
-  stock: z2.number().int().min(0).optional(),
-  isUnlimited: z2.boolean().optional(),
-  inventoryPolicy: z2.enum(["deny", "continue"]).optional(),
-  weight: z2.number().int().min(0).optional().nullable(),
-  requiresShipping: z2.boolean().optional(),
-  barcode: z2.string().optional().nullable(),
-  externalId: z2.string().optional().nullable(),
-  isActive: z2.boolean().optional(),
-  images: z2.array(IdSchema).optional(),
-  marketPrices: z2.array(VariantMarketPriceInputSchema).optional(),
+  stock: z3.number().int().min(0).optional(),
+  isUnlimited: z3.boolean().optional(),
+  inventoryPolicy: z3.enum(["deny", "continue"]).optional(),
+  weight: z3.number().int().min(0).optional().nullable(),
+  requiresShipping: z3.boolean().optional(),
+  barcode: z3.string().optional().nullable(),
+  externalId: z3.string().optional().nullable(),
+  isActive: z3.boolean().optional(),
+  images: z3.array(IdSchema).optional(),
+  marketPrices: z3.array(VariantMarketPriceInputSchema).optional(),
   thumbnail: RemovedLegacyMediaFieldSchema,
   featuredMediaItemId: RemovedLegacyMediaFieldSchema,
-  metadata: z2.unknown().optional()
+  metadata: z3.unknown().optional()
 });
-var ProductUpsertObjectSchema = z2.object({
+var ProductUpsertObjectSchema = z3.object({
   /** Required on graph edit when the server graph is non-empty (`productId` set); optional for first seed on an empty graph. */
-  graphRevision: z2.string().optional(),
+  graphRevision: z3.string().optional(),
   productId: IdSchema.optional(),
   product: ProductFieldsSchema.optional(),
-  options: z2.array(OptionInputSchema).max(10).optional().default([]),
-  variants: z2.array(VariantInputSchema).max(500).optional().default([])
+  options: z3.array(OptionInputSchema).max(10).optional().default([]),
+  variants: z3.array(VariantInputSchema).max(500).optional().default([])
 });
 var ProductUpsertSchema = ProductUpsertObjectSchema.superRefine(
   (data, ctx) => {
@@ -1983,16 +2011,16 @@ var ProductUpsertSchema = ProductUpsertObjectSchema.superRefine(
 );
 
 // ../../internal/contracts/src/ecommerce/cart.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../../internal/contracts/src/ecommerce/commerce-common.ts
-import { z as z3 } from "zod";
-var currencyCodeSchema = z3.string().regex(
+import { z as z4 } from "zod";
+var currencyCodeSchema = z4.string().regex(
   /^[A-Z]{3}$/,
   "currency must be a three-letter uppercase ISO 4217 code"
 );
-var minorAmountSchema = z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var moneySchema = z3.object({
+var minorAmountSchema = z4.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var moneySchema = z4.object({
   amountMinor: minorAmountSchema,
   currency: currencyCodeSchema
 }).strict();
@@ -2007,17 +2035,17 @@ var MAX_COMMERCE_ADDRESS_LENGTH = 500;
 var MAX_COMMERCE_EMAIL_LENGTH = 254;
 var MAX_COMMERCE_PHONE_LENGTH = 32;
 var MAX_COMMERCE_POSTAL_CODE_LENGTH = 32;
-var commerceResourceIdSchema = z3.string().min(1).max(MAX_COMMERCE_RESOURCE_ID_LENGTH);
-var commerceCapabilitySchema = z3.string().min(1).max(MAX_COMMERCE_CAPABILITY_LENGTH);
-var commerceCustomerTokenSchema = z3.string().min(1).max(MAX_COMMERCE_CUSTOMER_TOKEN_LENGTH);
-var publicAttributeKeySchema = z3.string().min(1).max(MAX_COMMERCE_EXTENSION_KEY_LENGTH).refine((key) => !key.startsWith("__"), {
+var commerceResourceIdSchema = z4.string().min(1).max(MAX_COMMERCE_RESOURCE_ID_LENGTH);
+var commerceCapabilitySchema = z4.string().min(1).max(MAX_COMMERCE_CAPABILITY_LENGTH);
+var commerceCustomerTokenSchema = z4.string().min(1).max(MAX_COMMERCE_CUSTOMER_TOKEN_LENGTH);
+var publicAttributeKeySchema = z4.string().min(1).max(MAX_COMMERCE_EXTENSION_KEY_LENGTH).refine((key) => !key.startsWith("__"), {
   message: "attribute key uses a reserved platform prefix"
 });
-var publicAttributeSchema = z3.object({
+var publicAttributeSchema = z4.object({
   key: publicAttributeKeySchema,
-  value: z3.string().max(MAX_COMMERCE_EXTENSION_VALUE_LENGTH)
+  value: z4.string().max(MAX_COMMERCE_EXTENSION_VALUE_LENGTH)
 }).strict();
-var publicAttributesSchema = z3.array(publicAttributeSchema).max(MAX_COMMERCE_EXTENSION_ENTRIES).superRefine((attributes, ctx) => {
+var publicAttributesSchema = z4.array(publicAttributeSchema).max(MAX_COMMERCE_EXTENSION_ENTRIES).superRefine((attributes, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   attributes.forEach(({ key }, index) => {
     if (seen.has(key)) {
@@ -2030,12 +2058,12 @@ var publicAttributesSchema = z3.array(publicAttributeSchema).max(MAX_COMMERCE_EX
     seen.add(key);
   });
 });
-var integrationMetadataKeySchema = z3.string().min(1).max(MAX_COMMERCE_EXTENSION_KEY_LENGTH).refine((key) => !key.includes("[") && !key.includes("]"), {
+var integrationMetadataKeySchema = z4.string().min(1).max(MAX_COMMERCE_EXTENSION_KEY_LENGTH).refine((key) => !key.includes("[") && !key.includes("]"), {
   message: "integration metadata keys must not use bracket notation"
 });
-var integrationMetadataSchema = z3.record(
+var integrationMetadataSchema = z4.record(
   integrationMetadataKeySchema,
-  z3.string().max(MAX_COMMERCE_EXTENSION_VALUE_LENGTH)
+  z4.string().max(MAX_COMMERCE_EXTENSION_VALUE_LENGTH)
 ).superRefine((metadata, ctx) => {
   if (Object.keys(metadata).length > MAX_COMMERCE_EXTENSION_ENTRIES) {
     ctx.addIssue({
@@ -2047,22 +2075,22 @@ var integrationMetadataSchema = z3.record(
     });
   }
 });
-var customerSnapshotSchema = z3.object({
-  email: z3.string().email().max(MAX_COMMERCE_EMAIL_LENGTH),
-  name: z3.string().min(1).max(MAX_COMMERCE_SHORT_TEXT_LENGTH).optional(),
-  phone: z3.string().min(1).max(MAX_COMMERCE_PHONE_LENGTH).optional()
+var customerSnapshotSchema = z4.object({
+  email: z4.string().email().max(MAX_COMMERCE_EMAIL_LENGTH),
+  name: z4.string().min(1).max(MAX_COMMERCE_SHORT_TEXT_LENGTH).optional(),
+  phone: z4.string().min(1).max(MAX_COMMERCE_PHONE_LENGTH).optional()
 }).strict();
-var checkoutShippingAddressSchema = z3.object({
-  recipientName: z3.string().min(1).max(MAX_COMMERCE_SHORT_TEXT_LENGTH),
-  phone: z3.string().min(1).max(MAX_COMMERCE_PHONE_LENGTH),
-  countryCode: z3.string().trim().length(2).optional(),
-  regionCode: z3.string().trim().min(1).max(64).optional(),
-  postalCode: z3.string().min(1).max(MAX_COMMERCE_POSTAL_CODE_LENGTH),
-  address: z3.string().min(1).max(MAX_COMMERCE_ADDRESS_LENGTH),
-  detailAddress: z3.string().min(1).max(MAX_COMMERCE_ADDRESS_LENGTH),
-  deliveryMessage: z3.string().max(MAX_COMMERCE_EXTENSION_VALUE_LENGTH).optional()
+var checkoutShippingAddressSchema = z4.object({
+  recipientName: z4.string().min(1).max(MAX_COMMERCE_SHORT_TEXT_LENGTH),
+  phone: z4.string().min(1).max(MAX_COMMERCE_PHONE_LENGTH),
+  countryCode: z4.string().trim().length(2).optional(),
+  regionCode: z4.string().trim().min(1).max(64).optional(),
+  postalCode: z4.string().min(1).max(MAX_COMMERCE_POSTAL_CODE_LENGTH),
+  address: z4.string().min(1).max(MAX_COMMERCE_ADDRESS_LENGTH),
+  detailAddress: z4.string().min(1).max(MAX_COMMERCE_ADDRESS_LENGTH),
+  deliveryMessage: z4.string().max(MAX_COMMERCE_EXTENSION_VALUE_LENGTH).optional()
 }).strict();
-var commerceIdempotencyKeySchema = z3.string().max(255).refine(
+var commerceIdempotencyKeySchema = z4.string().max(255).refine(
   (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
     value
   ) || /^ik_[A-Za-z0-9_-]{22}$/.test(value),
@@ -2073,9 +2101,9 @@ var commerceIdempotencyKeySchema = z3.string().max(255).refine(
 var MAX_CART_LINE_QUANTITY = 99;
 var MAX_CART_DISCOUNT_CODES = 250;
 var MAX_CART_DISCOUNT_CODE_LENGTH = 128;
-var cartDiscountCodeSchema = z4.object({
-  code: z4.string().min(1).max(MAX_CART_DISCOUNT_CODE_LENGTH),
-  applicable: z4.boolean()
+var cartDiscountCodeSchema = z5.object({
+  code: z5.string().min(1).max(MAX_CART_DISCOUNT_CODE_LENGTH),
+  applicable: z5.boolean()
 }).strict();
 var CART_WARNING_CODES = [
   "DISCOUNT_CODE_NOT_HONOURED",
@@ -2091,16 +2119,16 @@ var CART_WARNING_CODES = [
   "MERCHANDISE_NOT_ENOUGH_STOCK",
   "MERCHANDISE_OUT_OF_STOCK"
 ];
-var cartWarningCodeSchema = z4.enum(CART_WARNING_CODES);
-var cartWarningSchema = z4.object({
+var cartWarningCodeSchema = z5.enum(CART_WARNING_CODES);
+var cartWarningSchema = z5.object({
   code: cartWarningCodeSchema,
-  message: z4.string().min(1),
-  target: z4.string().min(1)
+  message: z5.string().min(1),
+  target: z5.string().min(1)
 }).strict();
-var updateDiscountCodesBodySchema = z4.object({
+var updateDiscountCodesBodySchema = z5.object({
   cartToken: commerceCapabilitySchema,
-  expectedRevision: z4.number().int().nonnegative(),
-  discountCodes: z4.array(z4.string().trim().min(1).max(MAX_CART_DISCOUNT_CODE_LENGTH)).max(
+  expectedRevision: z5.number().int().nonnegative(),
+  discountCodes: z5.array(z5.string().trim().min(1).max(MAX_CART_DISCOUNT_CODE_LENGTH)).max(
     MAX_CART_DISCOUNT_CODES,
     `discountCodes cannot contain more than ${MAX_CART_DISCOUNT_CODES} values`
   )
@@ -2109,43 +2137,43 @@ var updateDiscountCodesParamsSchema = updateDiscountCodesBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
 var MAX_CART_LINE_ADMISSIONS = 32;
-var publicMediaSizeSchema = z4.object({
-  width: z4.number().nullable().optional(),
-  height: z4.number().nullable().optional(),
-  mimeType: z4.string().nullable().optional(),
-  filename: z4.string().nullable().optional(),
-  url: z4.string().nullable().optional()
+var publicMediaSizeSchema = z5.object({
+  width: z5.number().nullable().optional(),
+  height: z5.number().nullable().optional(),
+  mimeType: z5.string().nullable().optional(),
+  filename: z5.string().nullable().optional(),
+  url: z5.string().nullable().optional()
 }).strict();
-var publicMediaAssetSchema = z4.union([
-  z4.string(),
-  z4.object({
-    id: z4.union([z4.string(), z4.number()]).nullable().optional(),
-    alt: z4.string().nullable().optional(),
-    width: z4.number().nullable().optional(),
-    height: z4.number().nullable().optional(),
-    mimeType: z4.string().nullable().optional(),
-    filename: z4.string().nullable().optional(),
-    url: z4.string().nullable().optional(),
-    sizes: z4.record(z4.string(), publicMediaSizeSchema).optional()
+var publicMediaAssetSchema = z5.union([
+  z5.string(),
+  z5.object({
+    id: z5.union([z5.string(), z5.number()]).nullable().optional(),
+    alt: z5.string().nullable().optional(),
+    width: z5.number().nullable().optional(),
+    height: z5.number().nullable().optional(),
+    mimeType: z5.string().nullable().optional(),
+    filename: z5.string().nullable().optional(),
+    url: z5.string().nullable().optional(),
+    sizes: z5.record(z5.string(), publicMediaSizeSchema).optional()
   }).strict()
 ]);
-var publicCartReferenceSchema = z4.object({
-  id: z4.string().min(1),
-  title: z4.string().min(1),
-  handle: z4.string().min(1).nullable(),
+var publicCartReferenceSchema = z5.object({
+  id: z5.string().min(1),
+  title: z5.string().min(1),
+  handle: z5.string().min(1).nullable(),
   image: publicMediaAssetSchema.nullable()
 }).strict();
-var publicCartMarketSchema = z4.object({
-  id: z4.string().min(1),
-  handle: z4.string().min(1),
-  name: z4.string().min(1)
+var publicCartMarketSchema = z5.object({
+  id: z5.string().min(1),
+  handle: z5.string().min(1),
+  name: z5.string().min(1)
 }).strict();
-var publicCartItemAdmissionSchema = z4.object({
-  eventId: z4.string().min(1),
-  occurrenceId: z4.string().min(1),
-  admissionTypeId: z4.string().min(1)
+var publicCartItemAdmissionSchema = z5.object({
+  eventId: z5.string().min(1),
+  occurrenceId: z5.string().min(1),
+  admissionTypeId: z5.string().min(1)
 }).strict();
-var cartLineAdmissionsInputSchema = z4.array(publicCartItemAdmissionSchema).max(
+var cartLineAdmissionsInputSchema = z5.array(publicCartItemAdmissionSchema).max(
   MAX_CART_LINE_ADMISSIONS,
   `admissions cannot contain more than ${MAX_CART_LINE_ADMISSIONS} values`
 ).min(1, "admissions must contain at least one value").superRefine((admissions, ctx) => {
@@ -2162,37 +2190,37 @@ var cartLineAdmissionsInputSchema = z4.array(publicCartItemAdmissionSchema).max(
     seen.add(key);
   });
 });
-var cartTokenField = z4.string().min(1, "cartToken is required");
-var cartMarketField = z4.string().trim().min(1).optional();
-var cartEntityIdField = z4.union([z4.string(), z4.number()]).transform(String);
-var createCartSchema = z4.object({
+var cartTokenField = z5.string().min(1, "cartToken is required");
+var cartMarketField = z5.string().trim().min(1).optional();
+var cartEntityIdField = z5.union([z5.string(), z5.number()]).transform(String);
+var createCartSchema = z5.object({
   market: cartMarketField,
   attributes: publicAttributesSchema.optional()
 }).strict();
-var getCartSchema = z4.object({ cartToken: cartTokenField }).strict();
-var addCartItemSchema = z4.object({
+var getCartSchema = z5.object({ cartToken: cartTokenField }).strict();
+var addCartItemSchema = z5.object({
   cartToken: cartTokenField,
   product: cartEntityIdField,
   variant: cartEntityIdField,
   option: cartEntityIdField.optional(),
-  quantity: z4.number().int().positive("quantity must be a positive integer"),
+  quantity: z5.number().int().positive("quantity must be a positive integer"),
   market: cartMarketField,
   admissions: cartLineAdmissionsInputSchema.optional()
 }).strict();
-var updateCartItemSchema = z4.object({
+var updateCartItemSchema = z5.object({
   cartToken: cartTokenField,
   cartItemId: cartEntityIdField,
-  quantity: z4.number().int().positive("quantity must be a positive integer")
+  quantity: z5.number().int().positive("quantity must be a positive integer")
 }).strict();
-var removeCartItemSchema = z4.object({
+var removeCartItemSchema = z5.object({
   cartToken: cartTokenField,
   cartItemId: cartEntityIdField
 }).strict();
-var updateCartAttributesSchema = z4.object({
+var updateCartAttributesSchema = z5.object({
   cartToken: cartTokenField,
   attributes: publicAttributesSchema
 }).strict();
-var clearCartSchema = z4.object({ cartToken: cartTokenField }).strict();
+var clearCartSchema = z5.object({ cartToken: cartTokenField }).strict();
 function compareAdmissions(left, right) {
   for (const field of ["eventId", "occurrenceId", "admissionTypeId"]) {
     if (left[field] < right[field]) return -1;
@@ -2200,7 +2228,7 @@ function compareAdmissions(left, right) {
   }
   return 0;
 }
-var publicCartItemAdmissionsSchema = z4.array(publicCartItemAdmissionSchema).max(MAX_CART_LINE_ADMISSIONS).superRefine((admissions, ctx) => {
+var publicCartItemAdmissionsSchema = z5.array(publicCartItemAdmissionSchema).max(MAX_CART_LINE_ADMISSIONS).superRefine((admissions, ctx) => {
   let previous;
   admissions.forEach((admission, index) => {
     const comparison = previous ? compareAdmissions(admission, previous) : void 0;
@@ -2214,16 +2242,16 @@ var publicCartItemAdmissionsSchema = z4.array(publicCartItemAdmissionSchema).max
     previous = admission;
   });
 });
-var publicCartItemSchema = z4.object({
-  id: z4.string().min(1),
+var publicCartItemSchema = z5.object({
+  id: z5.string().min(1),
   product: publicCartReferenceSchema,
   variant: publicCartReferenceSchema,
   admissions: publicCartItemAdmissionsSchema,
-  quantity: z4.number().int().positive().max(MAX_CART_LINE_QUANTITY),
+  quantity: z5.number().int().positive().max(MAX_CART_LINE_QUANTITY),
   unitPriceMinor: minorAmountSchema,
   discountMinor: minorAmountSchema,
   estimatedLineTotalMinor: minorAmountSchema,
-  requiresShipping: z4.boolean()
+  requiresShipping: z5.boolean()
 }).strict().superRefine((item, ctx) => {
   const expectedLineTotal = BigInt(item.unitPriceMinor) * BigInt(item.quantity) - BigInt(item.discountMinor);
   if (expectedLineTotal < 0n) {
@@ -2242,21 +2270,21 @@ var publicCartItemSchema = z4.object({
     });
   }
 });
-var publicCartSchema = z4.object({
-  id: z4.string().min(1),
-  status: z4.enum(["active", "completed", "abandoned"]),
-  revision: z4.number().int().nonnegative(),
+var publicCartSchema = z5.object({
+  id: z5.string().min(1),
+  status: z5.enum(["active", "completed", "abandoned"]),
+  revision: z5.number().int().nonnegative(),
   currency: currencyCodeSchema,
   market: publicCartMarketSchema,
   subtotalMinor: minorAmountSchema,
   discountMinor: minorAmountSchema,
   estimatedTotalMinor: minorAmountSchema,
-  discountCodes: z4.array(cartDiscountCodeSchema),
+  discountCodes: z5.array(cartDiscountCodeSchema),
   attributes: publicAttributesSchema,
-  items: z4.array(publicCartItemSchema),
-  expiresAt: z4.string().datetime({ offset: true }),
-  createdAt: z4.string().datetime({ offset: true }),
-  updatedAt: z4.string().datetime({ offset: true })
+  items: z5.array(publicCartItemSchema),
+  expiresAt: isoDatetimeSchema({ offset: true }),
+  createdAt: isoDatetimeSchema({ offset: true }),
+  updatedAt: isoDatetimeSchema({ offset: true })
 }).strict().superRefine((cart, ctx) => {
   const expectedSubtotal = cart.items.reduce(
     (total, item) => total + BigInt(item.unitPriceMinor) * BigInt(item.quantity),
@@ -2295,17 +2323,17 @@ var publicCartSchema = z4.object({
     });
   }
 });
-var cartMutationResultSchema = z4.object({
+var cartMutationResultSchema = z5.object({
   cart: publicCartSchema,
-  warnings: z4.array(cartWarningSchema)
+  warnings: z5.array(cartWarningSchema)
 }).strict();
-var createCartParamsSchema = z4.object({
+var createCartParamsSchema = z5.object({
   market: commerceResourceIdSchema.optional(),
   attributes: publicAttributesSchema.optional()
 }).strict();
-var createCartResultSchema = z4.object({
+var createCartResultSchema = z5.object({
   cart: publicCartSchema,
-  warnings: z4.array(cartWarningSchema),
+  warnings: z5.array(cartWarningSchema),
   cartToken: commerceCapabilitySchema
 }).strict().superRefine((result, ctx) => {
   if (result.cart.revision !== 0) {
@@ -2316,8 +2344,8 @@ var createCartResultSchema = z4.object({
     });
   }
 });
-var retrieveCartParamsSchema = z4.object({ cartToken: commerceCapabilitySchema }).strict();
-var addItemAdmissionsSchema = z4.tuple([publicCartItemAdmissionSchema], publicCartItemAdmissionSchema).readonly().superRefine((admissions, ctx) => {
+var retrieveCartParamsSchema = z5.object({ cartToken: commerceCapabilitySchema }).strict();
+var addItemAdmissionsSchema = z5.tuple([publicCartItemAdmissionSchema], publicCartItemAdmissionSchema).readonly().superRefine((admissions, ctx) => {
   if (admissions.length > MAX_CART_LINE_ADMISSIONS) {
     ctx.addIssue({
       code: "too_big",
@@ -2339,44 +2367,44 @@ var addItemAdmissionsSchema = z4.tuple([publicCartItemAdmissionSchema], publicCa
     }
   });
 });
-var addItemBodySchema = z4.object({
+var addItemBodySchema = z5.object({
   cartToken: commerceCapabilitySchema,
-  expectedRevision: z4.number().int().nonnegative(),
+  expectedRevision: z5.number().int().nonnegative(),
   productId: commerceResourceIdSchema,
   variantId: commerceResourceIdSchema,
-  quantity: z4.number().int().positive().max(MAX_CART_LINE_QUANTITY),
+  quantity: z5.number().int().positive().max(MAX_CART_LINE_QUANTITY),
   admissions: addItemAdmissionsSchema.optional()
 }).strict();
 var addItemParamsSchema = addItemBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var updateItemBodySchema = z4.object({
+var updateItemBodySchema = z5.object({
   cartToken: commerceCapabilitySchema,
-  expectedRevision: z4.number().int().nonnegative(),
+  expectedRevision: z5.number().int().nonnegative(),
   cartItemId: commerceResourceIdSchema,
-  quantity: z4.number().int().positive().max(MAX_CART_LINE_QUANTITY)
+  quantity: z5.number().int().positive().max(MAX_CART_LINE_QUANTITY)
 }).strict();
 var updateItemParamsSchema = updateItemBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var removeItemBodySchema = z4.object({
+var removeItemBodySchema = z5.object({
   cartToken: commerceCapabilitySchema,
-  expectedRevision: z4.number().int().nonnegative(),
+  expectedRevision: z5.number().int().nonnegative(),
   cartItemId: commerceResourceIdSchema
 }).strict();
 var removeItemParamsSchema = removeItemBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var clearCartBodySchema = z4.object({
+var clearCartBodySchema = z5.object({
   cartToken: commerceCapabilitySchema,
-  expectedRevision: z4.number().int().nonnegative()
+  expectedRevision: z5.number().int().nonnegative()
 }).strict();
 var clearCartParamsSchema = clearCartBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var updateCartAttributesBodySchema = z4.object({
+var updateCartAttributesBodySchema = z5.object({
   cartToken: commerceCapabilitySchema,
-  expectedRevision: z4.number().int().nonnegative(),
+  expectedRevision: z5.number().int().nonnegative(),
   attributes: publicAttributesSchema
 }).strict();
 var updateCartAttributesParamsSchema = updateCartAttributesBodySchema.extend({
@@ -2396,32 +2424,32 @@ var serverUpdateItemParamsSchema = serverUpdateItemBodySchema.extend({
 });
 
 // ../../internal/contracts/src/ecommerce/checkout.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // ../../internal/contracts/src/ecommerce/managed-payment-provider.ts
 var CHECKOUT_PAYMENT_SESSION_PROVIDERS = ["toss", "portone"];
 
 // ../../internal/contracts/src/ecommerce/payment-session.ts
-import { z as z5 } from "zod";
-var tossProviderOrderIdSchema = z5.string().min(6).max(64).regex(
+import { z as z6 } from "zod";
+var tossProviderOrderIdSchema = z6.string().min(6).max(64).regex(
   /^[A-Za-z0-9_-]+$/,
   "providerOrderId may contain only ASCII letters, digits, underscores, and hyphens"
 );
-var accountAliasUuidV4Schema = z5.string().regex(
+var accountAliasUuidV4Schema = z6.string().regex(
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
   "providerCustomerKey must be ANONYMOUS or a UUIDv4 account alias"
 );
-var tossProviderCustomerKeySchema = z5.union([
-  z5.literal("ANONYMOUS"),
+var tossProviderCustomerKeySchema = z6.union([
+  z6.literal("ANONYMOUS"),
   accountAliasUuidV4Schema
 ]);
 var createPaymentSessionBaseBodyShape = {
   checkoutToken: commerceCapabilitySchema
 };
-var createTossPaymentSessionBodySchema = z5.object({
+var createTossPaymentSessionBodySchema = z6.object({
   ...createPaymentSessionBaseBodyShape,
-  provider: z5.literal("toss"),
-  providerOptions: z5.object({ profile: z5.literal("widget_v2") }).strict()
+  provider: z6.literal("toss"),
+  providerOptions: z6.object({ profile: z6.literal("widget_v2") }).strict()
 }).strict();
 var PORTONE_HOSTED_PAYMENT_METHODS = [
   "CARD_KR",
@@ -2453,24 +2481,24 @@ var PORTONE_HOSTED_PAYMENT_METHODS = [
   "AU_PAY",
   "MERPAY"
 ];
-var portOneHostedPaymentMethodSchema = z5.enum(
+var portOneHostedPaymentMethodSchema = z6.enum(
   PORTONE_HOSTED_PAYMENT_METHODS
 );
 var PORTONE_STANDARD_PAYMENT_METHODS = ["CARD"];
-var portOneStandardPaymentMethodSchema = z5.enum(
+var portOneStandardPaymentMethodSchema = z6.enum(
   PORTONE_STANDARD_PAYMENT_METHODS
 );
 var PORTONE_STANDARD_CURRENCY = "CURRENCY_KRW";
-var portOneStandardProviderOptionsSchema = z5.object({
-  profile: z5.literal("standard_v2"),
+var portOneStandardProviderOptionsSchema = z6.object({
+  profile: z6.literal("standard_v2"),
   paymentMethod: portOneStandardPaymentMethodSchema
 }).strict();
-var createPortOnePaymentSessionBodySchema = z5.object({
+var createPortOnePaymentSessionBodySchema = z6.object({
   ...createPaymentSessionBaseBodyShape,
-  provider: z5.literal("portone"),
-  providerOptions: z5.discriminatedUnion("profile", [
-    z5.object({
-      profile: z5.literal("hosted_v2"),
+  provider: z6.literal("portone"),
+  providerOptions: z6.discriminatedUnion("profile", [
+    z6.object({
+      profile: z6.literal("hosted_v2"),
       paymentMethod: portOneHostedPaymentMethodSchema
     }).strict(),
     portOneStandardProviderOptionsSchema
@@ -2484,7 +2512,7 @@ function providerDiscriminatedUnion(schemas) {
   const variants = CHECKOUT_PAYMENT_SESSION_PROVIDERS.map(
     (provider) => schemas[provider]
   );
-  return z5.discriminatedUnion("provider", variants);
+  return z6.discriminatedUnion("provider", variants);
 }
 var createPaymentSessionBodySchema = providerDiscriminatedUnion(
   createPaymentSessionBodySchemasByProvider
@@ -2518,44 +2546,44 @@ var createServerPaymentSessionParamsSchema = providerDiscriminatedUnion({
     idempotencyKey: commerceIdempotencyKeySchema
   })
 });
-var retrieveBrowserPaymentSessionParamsSchema = z5.object({
+var retrieveBrowserPaymentSessionParamsSchema = z6.object({
   paymentSessionId: commerceResourceIdSchema,
   checkoutToken: commerceCapabilitySchema
 }).strict();
-var retrieveServerPaymentSessionParamsSchema = z5.object({ paymentSessionId: commerceResourceIdSchema }).strict();
-var cancelBrowserPaymentSessionBodySchema = z5.object({
+var retrieveServerPaymentSessionParamsSchema = z6.object({ paymentSessionId: commerceResourceIdSchema }).strict();
+var cancelBrowserPaymentSessionBodySchema = z6.object({
   paymentSessionId: commerceResourceIdSchema,
   checkoutToken: commerceCapabilitySchema
 }).strict();
 var cancelBrowserPaymentSessionParamsSchema = cancelBrowserPaymentSessionBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var cancelServerPaymentSessionBodySchema = z5.object({
+var cancelServerPaymentSessionBodySchema = z6.object({
   paymentSessionId: commerceResourceIdSchema
 }).strict();
 var cancelServerPaymentSessionParamsSchema = cancelServerPaymentSessionBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var cancelPaymentSessionParamsSchema = z5.union([
+var cancelPaymentSessionParamsSchema = z6.union([
   cancelBrowserPaymentSessionParamsSchema,
   cancelServerPaymentSessionParamsSchema
 ]);
-var confirmTossPaymentSessionBodySchema = z5.object({
+var confirmTossPaymentSessionBodySchema = z6.object({
   paymentSessionId: commerceResourceIdSchema,
-  action: z5.object({
-    type: z5.literal("toss_authorization"),
-    paymentKey: z5.string().min(1).max(512),
+  action: z6.object({
+    type: z6.literal("toss_authorization"),
+    paymentKey: z6.string().min(1).max(512),
     providerOrderId: tossProviderOrderIdSchema
   }).strict()
 }).strict();
 var confirmTossPaymentSessionParamsSchema = confirmTossPaymentSessionBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var portOneProviderIdentitySchema = z5.string().min(1).max(512).refine((value) => /\S/u.test(value), "Provider identity must not be blank");
-var portOnePaymentSelectorSchema = z5.object({
-  provider: z5.literal("portone"),
+var portOneProviderIdentitySchema = z6.string().min(1).max(512).refine((value) => /\S/u.test(value), "Provider identity must not be blank");
+var portOnePaymentSelectorSchema = z6.object({
+  provider: z6.literal("portone"),
   providerAccountKey: portOneProviderIdentitySchema,
-  environment: z5.enum(["test", "live"]),
+  environment: z6.enum(["test", "live"]),
   providerPaymentId: portOneProviderIdentitySchema
 }).strict();
 var reconcilePortOnePaymentBodySchema = portOnePaymentSelectorSchema;
@@ -2575,11 +2603,11 @@ var PAYMENT_PROVIDER_STATUSES = [
   "failed",
   "canceled"
 ];
-var paymentProviderStatusSchema = z5.enum(PAYMENT_PROVIDER_STATUSES);
-var customPaymentProviderSchema = z5.string().trim().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]{0,63}$/i, "provider must be a slug");
-var customPaymentIdentitySchema = z5.string().trim().min(1);
-var customPaymentCurrencyInputSchema = z5.string().trim().min(1).regex(/^[A-Za-z]{3}$/, "currency must be a three-letter ISO 4217 code").transform((currency) => currency.toUpperCase());
-var createCustomPaymentSessionBodySchema = z5.object({
+var paymentProviderStatusSchema = z6.enum(PAYMENT_PROVIDER_STATUSES);
+var customPaymentProviderSchema = z6.string().trim().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]{0,63}$/i, "provider must be a slug");
+var customPaymentIdentitySchema = z6.string().trim().min(1);
+var customPaymentCurrencyInputSchema = z6.string().trim().min(1).regex(/^[A-Za-z]{3}$/, "currency must be a three-letter ISO 4217 code").transform((currency) => currency.toUpperCase());
+var createCustomPaymentSessionBodySchema = z6.object({
   provider: customPaymentProviderSchema,
   checkoutToken: commerceCapabilitySchema,
   customerToken: commerceCustomerTokenSchema.optional()
@@ -2587,49 +2615,49 @@ var createCustomPaymentSessionBodySchema = z5.object({
 var createCustomPaymentSessionParamsSchema = createCustomPaymentSessionBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var customPaymentSessionSchema = z5.object({
+var customPaymentSessionSchema = z6.object({
   id: commerceResourceIdSchema,
   provider: customPaymentProviderSchema,
   providerSessionId: customPaymentIdentitySchema,
   money: moneySchema
 }).strict();
-var customPaymentSessionLookupSchema = z5.union([
-  z5.object({
+var customPaymentSessionLookupSchema = z6.union([
+  z6.object({
     providerSessionId: customPaymentIdentitySchema
   }).strict(),
-  z5.object({
+  z6.object({
     providerPaymentId: customPaymentIdentitySchema
   }).strict()
 ]);
-var retrieveCustomPaymentSessionBodySchema = z5.object({
+var retrieveCustomPaymentSessionBodySchema = z6.object({
   provider: customPaymentProviderSchema,
   by: customPaymentSessionLookupSchema
 }).strict();
-var retrievedCustomPaymentSessionSchema = z5.object({
+var retrievedCustomPaymentSessionSchema = z6.object({
   id: commerceResourceIdSchema,
   provider: customPaymentProviderSchema,
   providerSessionId: customPaymentIdentitySchema,
   providerPaymentId: customPaymentIdentitySchema.nullable(),
-  status: z5.enum(["pending", "captured", "failed", "canceled"]),
+  status: z6.enum(["pending", "captured", "failed", "canceled"]),
   providerStatus: paymentProviderStatusSchema,
-  finalizationStatus: z5.enum(["not_ready", "pending", "committed"]),
+  finalizationStatus: z6.enum(["not_ready", "pending", "committed"]),
   money: moneySchema,
   orderId: commerceResourceIdSchema.nullable()
 }).strict();
-var confirmCustomPaymentSessionBodySchema = z5.object({
+var confirmCustomPaymentSessionBodySchema = z6.object({
   provider: customPaymentProviderSchema,
   providerSessionId: customPaymentIdentitySchema,
   providerPaymentId: customPaymentIdentitySchema,
   providerEventId: customPaymentIdentitySchema,
-  amount: z5.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  amount: z6.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   currency: customPaymentCurrencyInputSchema,
   occurredAt: customPaymentIdentitySchema
 }).strict();
-var confirmCustomPaymentSessionResponseSchema = z5.object({
+var confirmCustomPaymentSessionResponseSchema = z6.object({
   orderId: commerceResourceIdSchema,
   transactionId: commerceResourceIdSchema,
-  status: z5.literal("paid"),
-  alreadyConfirmed: z5.boolean().optional()
+  status: z6.literal("paid"),
+  alreadyConfirmed: z6.boolean().optional()
 }).strict();
 var PORTONE_RECONCILIATION_DISPOSITIONS = [
   "applied",
@@ -2637,49 +2665,49 @@ var PORTONE_RECONCILIATION_DISPOSITIONS = [
   "recovered_after_ambiguous_result",
   "requires_attention"
 ];
-var portOneReconciliationDispositionSchema = z5.enum(
+var portOneReconciliationDispositionSchema = z6.enum(
   PORTONE_RECONCILIATION_DISPOSITIONS
 );
-var tossPaymentNextActionSchema = z5.object({
-  type: z5.literal("toss_widget"),
-  clientKey: z5.string().min(1).max(255),
-  paymentMethodVariantKey: z5.string().min(1).max(255),
-  agreementVariantKey: z5.string().min(1).max(255),
+var tossPaymentNextActionSchema = z6.object({
+  type: z6.literal("toss_widget"),
+  clientKey: z6.string().min(1).max(255),
+  paymentMethodVariantKey: z6.string().min(1).max(255),
+  agreementVariantKey: z6.string().min(1).max(255),
   providerOrderId: tossProviderOrderIdSchema,
   providerCustomerKey: tossProviderCustomerKeySchema,
-  orderName: z5.string().min(1).max(200),
-  customerName: z5.string().min(1).max(200).optional(),
-  customerEmail: z5.string().email().max(254).optional()
+  orderName: z6.string().min(1).max(200),
+  customerName: z6.string().min(1).max(200).optional(),
+  customerEmail: z6.string().email().max(254).optional()
 }).strict();
-var portOnePaymentNextActionSchema = z5.object({
-  type: z5.literal("portone_checkout"),
-  checkoutUrl: z5.string().url().startsWith("https://").max(2048).refine((value) => {
+var portOnePaymentNextActionSchema = z6.object({
+  type: z6.literal("portone_checkout"),
+  checkoutUrl: z6.string().url().startsWith("https://").max(2048).refine((value) => {
     const url = new URL(value);
     return url.username === "" && url.password === "";
   }, "checkoutUrl must not contain embedded credentials")
 }).strict();
 var PORTONE_STANDARD_ACTION_RETRY_POLICY = "same_action_only";
-var portOneSdkPaymentRequestSchema = z5.object({
-  type: z5.literal("portone_sdk"),
-  version: z5.literal("v2"),
-  storeId: z5.string().min(1).max(255),
-  channelKey: z5.string().min(1).max(255),
-  paymentId: z5.string().regex(/^[A-Za-z0-9]{6,40}$/),
-  orderName: z5.string().min(1).max(200),
-  totalAmount: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  currency: z5.literal(PORTONE_STANDARD_CURRENCY),
+var portOneSdkPaymentRequestSchema = z6.object({
+  type: z6.literal("portone_sdk"),
+  version: z6.literal("v2"),
+  storeId: z6.string().min(1).max(255),
+  channelKey: z6.string().min(1).max(255),
+  paymentId: z6.string().regex(/^[A-Za-z0-9]{6,40}$/),
+  orderName: z6.string().min(1).max(200),
+  totalAmount: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  currency: z6.literal(PORTONE_STANDARD_CURRENCY),
   payMethod: portOneStandardPaymentMethodSchema,
-  redirectUrl: z5.string().url().max(2048).refine((value) => {
+  redirectUrl: z6.string().url().max(2048).refine((value) => {
     const url = new URL(value);
     const loopback = url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1");
     return (url.protocol === "https:" || loopback) && !url.username && !url.password;
   }, "redirectUrl must be HTTPS (or development loopback) without embedded credentials")
 }).strict();
 var portOneSdkPaymentCapabilityNextActionSchema = portOneSdkPaymentRequestSchema.extend({
-  cancelable: z5.literal(false),
-  retryPolicy: z5.literal(PORTONE_STANDARD_ACTION_RETRY_POLICY)
+  cancelable: z6.literal(false),
+  retryPolicy: z6.literal(PORTONE_STANDARD_ACTION_RETRY_POLICY)
 }).strict();
-var portOneSdkPaymentNextActionSchema = z5.union([
+var portOneSdkPaymentNextActionSchema = z6.union([
   portOneSdkPaymentCapabilityNextActionSchema,
   portOneSdkPaymentRequestSchema
 ]).transform(
@@ -2689,7 +2717,7 @@ var portOneSdkPaymentNextActionSchema = z5.union([
     retryPolicy: PORTONE_STANDARD_ACTION_RETRY_POLICY
   }
 );
-var paymentNextActionSchema = z5.union([
+var paymentNextActionSchema = z6.union([
   tossPaymentNextActionSchema,
   portOnePaymentNextActionSchema,
   portOneSdkPaymentNextActionSchema
@@ -2701,7 +2729,7 @@ var PAYMENT_SESSION_ROLES = [
   "residual",
   "historical"
 ];
-var paymentSessionRoleSchema = z5.enum(PAYMENT_SESSION_ROLES);
+var paymentSessionRoleSchema = z6.enum(PAYMENT_SESSION_ROLES);
 var PAYMENT_RECONCILIATION_REASONS = [
   "provider_outcome_unknown",
   "local_commit_ambiguous",
@@ -2714,14 +2742,14 @@ var PAYMENT_RECONCILIATION_REASONS = [
   "late_capture",
   "cross_checkout_duplicate"
 ];
-var paymentReconciliationReasonSchema = z5.enum(
+var paymentReconciliationReasonSchema = z6.enum(
   PAYMENT_RECONCILIATION_REASONS
 );
 function requiredReconciliationSchema(reasons) {
-  const reasonSchema = z5.enum(reasons);
-  return z5.object({
-    status: z5.literal("required"),
-    reasons: z5.array(reasonSchema).min(1).readonly()
+  const reasonSchema = z6.enum(reasons);
+  return z6.object({
+    status: z6.literal("required"),
+    reasons: z6.array(reasonSchema).min(1).readonly()
   }).strict().superRefine((value, ctx) => {
     const indexes = new Map(reasons.map((reason, index) => [reason, index]));
     let previous = -1;
@@ -2738,16 +2766,16 @@ function requiredReconciliationSchema(reasons) {
     });
   });
 }
-var noReconciliationSchema = z5.object({ status: z5.literal("none") }).strict();
-var publicCaptureEvidenceSchema = z5.object({
-  amountMinor: z5.number().int().nonnegative(),
+var noReconciliationSchema = z6.object({ status: z6.literal("none") }).strict();
+var publicCaptureEvidenceSchema = z6.object({
+  amountMinor: z6.number().int().nonnegative(),
   currency: currencyCodeSchema,
-  observedAt: z5.string().datetime({ offset: true })
+  observedAt: isoDatetimeSchema({ offset: true })
 }).strict();
-var reconciliationRefundEvidenceSchema = z5.object({
-  providerRefundId: z5.string().min(1),
+var reconciliationRefundEvidenceSchema = z6.object({
+  providerRefundId: z6.string().min(1),
   money: moneySchema,
-  observedAt: z5.string().datetime({ offset: true })
+  observedAt: isoDatetimeSchema({ offset: true })
 }).strict();
 var PAYMENT_FAILURE_REASONS = [
   "payment_declined",
@@ -2757,86 +2785,86 @@ var PAYMENT_FAILURE_REASONS = [
   "provider_terminal_failure",
   "unknown_provider_terminal_failure"
 ];
-var paymentFailureReasonSchema = z5.enum(PAYMENT_FAILURE_REASONS);
-var orderReferenceSchema = z5.object({
-  id: z5.string().min(1),
-  orderNumber: z5.string().min(1)
+var paymentFailureReasonSchema = z6.enum(PAYMENT_FAILURE_REASONS);
+var orderReferenceSchema = z6.object({
+  id: z6.string().min(1),
+  orderNumber: z6.string().min(1)
 }).strict();
 var paymentSessionBaseShape = {
-  id: z5.string().min(1),
+  id: z6.string().min(1),
   money: moneySchema,
-  expiresAt: z5.string().datetime({ offset: true }).nullable()
+  expiresAt: isoDatetimeSchema({ offset: true }).nullable()
 };
 var suppressedNotReadyShape = {
-  presentationStatus: z5.literal("suppressed"),
-  finalizationStatus: z5.literal("not_ready"),
+  presentationStatus: z6.literal("suppressed"),
+  finalizationStatus: z6.literal("not_ready"),
   reconciliation: noReconciliationSchema,
-  order: z5.null()
+  order: z6.null()
 };
 function stateSchemas(nextAction) {
   return [
-    z5.object({
-      providerStatus: z5.enum(["requires_payment_method", "requires_action"]),
-      sessionRole: z5.literal("active"),
-      presentationStatus: z5.literal("actionable"),
-      finalizationStatus: z5.literal("not_ready"),
+    z6.object({
+      providerStatus: z6.enum(["requires_payment_method", "requires_action"]),
+      sessionRole: z6.literal("active"),
+      presentationStatus: z6.literal("actionable"),
+      finalizationStatus: z6.literal("not_ready"),
       nextAction,
       reconciliation: noReconciliationSchema,
-      order: z5.null()
+      order: z6.null()
     }),
-    z5.object({
-      providerStatus: z5.enum(["requires_payment_method", "requires_action"]),
-      sessionRole: z5.literal("residual"),
+    z6.object({
+      providerStatus: z6.enum(["requires_payment_method", "requires_action"]),
+      sessionRole: z6.literal("residual"),
       ...suppressedNotReadyShape
     }),
-    z5.object({
-      providerStatus: z5.literal("requires_confirmation"),
-      sessionRole: z5.enum(["active", "residual"]),
+    z6.object({
+      providerStatus: z6.literal("requires_confirmation"),
+      sessionRole: z6.enum(["active", "residual"]),
       ...suppressedNotReadyShape
     }),
-    z5.object({
-      providerStatus: z5.enum(["initializing", "processing", "authorized"]),
-      sessionRole: z5.enum(["active", "residual"]),
+    z6.object({
+      providerStatus: z6.enum(["initializing", "processing", "authorized"]),
+      sessionRole: z6.enum(["active", "residual"]),
       ...suppressedNotReadyShape
     }),
-    z5.object({
-      providerStatus: z5.literal("canceling"),
-      sessionRole: z5.enum(["active", "residual"]),
+    z6.object({
+      providerStatus: z6.literal("canceling"),
+      sessionRole: z6.enum(["active", "residual"]),
       ...suppressedNotReadyShape
     }),
-    z5.object({
-      providerStatus: z5.literal("unknown"),
-      sessionRole: z5.enum(["active", "residual"]),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("not_ready"),
+    z6.object({
+      providerStatus: z6.literal("unknown"),
+      sessionRole: z6.enum(["active", "residual"]),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("not_ready"),
       reconciliation: requiredReconciliationSchema([
         "provider_outcome_unknown"
       ]),
-      order: z5.null()
+      order: z6.null()
     }),
-    z5.object({
-      providerStatus: z5.literal("captured"),
-      sessionRole: z5.enum(["canonical_candidate", "residual"]),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("pending"),
+    z6.object({
+      providerStatus: z6.literal("captured"),
+      sessionRole: z6.enum(["canonical_candidate", "residual"]),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("pending"),
       reconciliation: noReconciliationSchema,
       providerEvidence: publicCaptureEvidenceSchema,
-      order: z5.null()
+      order: z6.null()
     }),
-    z5.object({
-      providerStatus: z5.literal("captured"),
-      sessionRole: z5.enum(["canonical", "historical"]),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("committed"),
+    z6.object({
+      providerStatus: z6.literal("captured"),
+      sessionRole: z6.enum(["canonical", "historical"]),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("committed"),
       reconciliation: noReconciliationSchema,
       providerEvidence: publicCaptureEvidenceSchema,
       order: orderReferenceSchema
     }),
-    z5.object({
-      providerStatus: z5.literal("captured"),
-      sessionRole: z5.enum(["canonical_candidate", "residual"]),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("pending"),
+    z6.object({
+      providerStatus: z6.literal("captured"),
+      sessionRole: z6.enum(["canonical_candidate", "residual"]),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("pending"),
       reconciliation: requiredReconciliationSchema([
         "local_commit_ambiguous",
         "amount_mismatch",
@@ -2844,13 +2872,13 @@ function stateSchemas(nextAction) {
         "excess_capture_pending_order"
       ]),
       providerEvidence: publicCaptureEvidenceSchema,
-      order: z5.null()
+      order: z6.null()
     }),
-    z5.object({
-      providerStatus: z5.literal("captured"),
-      sessionRole: z5.enum(["canonical", "residual"]),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("committed"),
+    z6.object({
+      providerStatus: z6.literal("captured"),
+      sessionRole: z6.enum(["canonical", "residual"]),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("committed"),
       reconciliation: requiredReconciliationSchema([
         "inventory_unavailable",
         "admission_unavailable",
@@ -2863,46 +2891,46 @@ function stateSchemas(nextAction) {
       providerEvidence: publicCaptureEvidenceSchema,
       order: orderReferenceSchema
     }),
-    z5.object({
-      providerStatus: z5.literal("failed"),
-      sessionRole: z5.literal("historical"),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("not_ready"),
+    z6.object({
+      providerStatus: z6.literal("failed"),
+      sessionRole: z6.literal("historical"),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("not_ready"),
       reconciliation: noReconciliationSchema,
-      failure: z5.object({
+      failure: z6.object({
         reason: paymentFailureReasonSchema,
-        message: z5.string().min(1).optional()
+        message: z6.string().min(1).optional()
       }).strict(),
-      order: z5.null()
+      order: z6.null()
     }),
-    z5.object({
-      providerStatus: z5.literal("canceled"),
-      sessionRole: z5.literal("historical"),
-      presentationStatus: z5.literal("suppressed"),
-      finalizationStatus: z5.literal("not_ready"),
-      cancellationReason: z5.enum([
+    z6.object({
+      providerStatus: z6.literal("canceled"),
+      sessionRole: z6.literal("historical"),
+      presentationStatus: z6.literal("suppressed"),
+      finalizationStatus: z6.literal("not_ready"),
+      cancellationReason: z6.enum([
         "expired",
         "customer",
         "operator",
         "provider"
       ]),
       reconciliation: noReconciliationSchema,
-      order: z5.null()
+      order: z6.null()
     })
   ];
 }
 function providerSessionSchemas(provider, action) {
   return stateSchemas(action).map(
-    (state) => z5.object({
+    (state) => z6.object({
       ...paymentSessionBaseShape,
-      provider: z5.literal(provider),
+      provider: z6.literal(provider),
       ...state.shape
     }).strict()
   );
 }
 var paymentNextActionSchemasByProvider = {
   toss: tossPaymentNextActionSchema,
-  portone: z5.union([
+  portone: z6.union([
     portOnePaymentNextActionSchema,
     portOneSdkPaymentNextActionSchema
   ])
@@ -2913,43 +2941,43 @@ var publicPaymentSessionVariants = CHECKOUT_PAYMENT_SESSION_PROVIDERS.flatMap(
     paymentNextActionSchemasByProvider[provider]
   )
 );
-var publicPaymentSessionSchema = z5.union(publicPaymentSessionVariants);
-var portOneReconciliationSummarySchema = z5.union([
+var publicPaymentSessionSchema = z6.union(publicPaymentSessionVariants);
+var portOneReconciliationSummarySchema = z6.union([
   noReconciliationSchema,
-  z5.object({
-    status: z5.literal("required"),
-    reasons: z5.array(paymentReconciliationReasonSchema).min(1).readonly()
+  z6.object({
+    status: z6.literal("required"),
+    reasons: z6.array(paymentReconciliationReasonSchema).min(1).readonly()
   }).strict()
 ]);
-var portOnePaymentCurrentStateSchema = z5.object({
-  paymentSession: z5.object({
+var portOnePaymentCurrentStateSchema = z6.object({
+  paymentSession: z6.object({
     id: commerceResourceIdSchema,
-    provider: z5.literal("portone"),
+    provider: z6.literal("portone"),
     providerStatus: paymentProviderStatusSchema,
-    finalizationStatus: z5.enum(["not_ready", "pending", "committed"]),
+    finalizationStatus: z6.enum(["not_ready", "pending", "committed"]),
     sessionRole: paymentSessionRoleSchema,
     reconciliation: portOneReconciliationSummarySchema
   }).strict(),
-  checkout: z5.object({ id: commerceResourceIdSchema }).strict(),
+  checkout: z6.object({ id: commerceResourceIdSchema }).strict(),
   order: orderReferenceSchema.nullable(),
   money: moneySchema
 }).strict();
-var findPortOnePaymentResultSchema = z5.discriminatedUnion("found", [
-  z5.object({ found: z5.literal(false) }).strict(),
-  z5.object({
-    found: z5.literal(true),
+var findPortOnePaymentResultSchema = z6.discriminatedUnion("found", [
+  z6.object({ found: z6.literal(false) }).strict(),
+  z6.object({
+    found: z6.literal(true),
     current: portOnePaymentCurrentStateSchema
   }).strict()
 ]);
-var reconcilePortOnePaymentResultSchema = z5.discriminatedUnion(
+var reconcilePortOnePaymentResultSchema = z6.discriminatedUnion(
   "found",
   [
-    z5.object({
-      found: z5.literal(false),
-      disposition: z5.literal("requires_attention")
+    z6.object({
+      found: z6.literal(false),
+      disposition: z6.literal("requires_attention")
     }).strict(),
-    z5.object({
-      found: z5.literal(true),
+    z6.object({
+      found: z6.literal(true),
       disposition: portOneReconciliationDispositionSchema,
       current: portOnePaymentCurrentStateSchema
     }).strict()
@@ -2960,19 +2988,19 @@ var CancelServerPaymentSessionParamsSchema = cancelServerPaymentSessionParamsSch
 var ConfirmTossPaymentSessionParamsSchema = confirmTossPaymentSessionParamsSchema;
 
 // ../../internal/contracts/src/ecommerce/checkout.ts
-var canonicalPublicCheckoutItemSchema = z6.object({
-  id: z6.string().min(1),
+var canonicalPublicCheckoutItemSchema = z7.object({
+  id: z7.string().min(1),
   product: publicCartReferenceSchema,
   variant: publicCartReferenceSchema,
-  productTitle: z6.string().min(1),
-  variantTitle: z6.string().min(1).nullable(),
-  sku: z6.string().min(1).nullable(),
+  productTitle: z7.string().min(1),
+  variantTitle: z7.string().min(1).nullable(),
+  sku: z7.string().min(1).nullable(),
   admissions: publicCartItemAdmissionsSchema,
-  quantity: z6.number().int().positive().max(MAX_CART_LINE_QUANTITY),
+  quantity: z7.number().int().positive().max(MAX_CART_LINE_QUANTITY),
   unitPriceMinor: minorAmountSchema,
   discountMinor: minorAmountSchema,
   lineTotalMinor: minorAmountSchema,
-  requiresShipping: z6.boolean()
+  requiresShipping: z7.boolean()
 }).strict().superRefine((item, ctx) => {
   const expectedLineTotal = BigInt(item.unitPriceMinor) * BigInt(item.quantity) - BigInt(item.discountMinor);
   if (expectedLineTotal < 0n) {
@@ -2991,7 +3019,7 @@ var canonicalPublicCheckoutItemSchema = z6.object({
     });
   }
 });
-var checkoutAmountsSchema = z6.object({
+var checkoutAmountsSchema = z7.object({
   currency: currencyCodeSchema,
   subtotalMinor: minorAmountSchema,
   shippingMinor: minorAmountSchema,
@@ -3007,66 +3035,66 @@ var checkoutAmountsSchema = z6.object({
     });
   }
 });
-var checkoutPaymentSessionRefSchema = z6.object({
-  id: z6.string().min(1),
-  provider: z6.enum(CHECKOUT_PAYMENT_SESSION_PROVIDERS),
+var checkoutPaymentSessionRefSchema = z7.object({
+  id: z7.string().min(1),
+  provider: z7.enum(CHECKOUT_PAYMENT_SESSION_PROVIDERS),
   providerStatus: paymentProviderStatusSchema
 }).strict();
-var openCheckoutPaymentStateSchema = z6.object({
+var openCheckoutPaymentStateSchema = z7.object({
   activePaymentSession: checkoutPaymentSessionRefSchema.nullable()
 }).strict();
-var spentCheckoutPaymentStateSchema = z6.object({
-  activePaymentSession: z6.null()
+var spentCheckoutPaymentStateSchema = z7.object({
+  activePaymentSession: z7.null()
 }).strict();
-var lightweightOrderReferenceSchema = z6.object({
-  id: z6.string().min(1),
-  orderNumber: z6.string().min(1)
+var lightweightOrderReferenceSchema = z7.object({
+  id: z7.string().min(1),
+  orderNumber: z7.string().min(1)
 }).strict();
 var publicCheckoutBaseShape = {
-  id: z6.string().min(1),
+  id: z7.string().min(1),
   amounts: checkoutAmountsSchema,
-  items: z6.array(canonicalPublicCheckoutItemSchema).min(1),
+  items: z7.array(canonicalPublicCheckoutItemSchema).min(1),
   customerSnapshot: customerSnapshotSchema,
   shippingAddress: checkoutShippingAddressSchema.nullable(),
   attributes: publicAttributesSchema,
-  expiresAt: z6.string().datetime({ offset: true }),
-  createdAt: z6.string().datetime({ offset: true }),
-  updatedAt: z6.string().datetime({ offset: true })
+  expiresAt: isoDatetimeSchema({ offset: true }),
+  createdAt: isoDatetimeSchema({ offset: true }),
+  updatedAt: isoDatetimeSchema({ offset: true })
 };
-var abandonedReasonSchema = z6.enum(["expired", "customer", "operator"]);
+var abandonedReasonSchema = z7.enum(["expired", "customer", "operator"]);
 var publicCheckoutVariants = [
-  z6.object({
+  z7.object({
     ...publicCheckoutBaseShape,
-    status: z6.literal("open"),
+    status: z7.literal("open"),
     paymentState: openCheckoutPaymentStateSchema,
-    order: z6.null()
+    order: z7.null()
   }).strict(),
-  z6.object({
+  z7.object({
     ...publicCheckoutBaseShape,
-    status: z6.literal("placed"),
-    placedAt: z6.string().datetime({ offset: true }),
+    status: z7.literal("placed"),
+    placedAt: isoDatetimeSchema({ offset: true }),
     paymentState: spentCheckoutPaymentStateSchema,
     order: lightweightOrderReferenceSchema
   }).strict(),
-  z6.object({
+  z7.object({
     ...publicCheckoutBaseShape,
-    status: z6.literal("placed"),
-    placedAt: z6.string().datetime({ offset: true }),
-    placedVia: z6.literal("late_capture"),
-    abandonedAt: z6.string().datetime({ offset: true }),
+    status: z7.literal("placed"),
+    placedAt: isoDatetimeSchema({ offset: true }),
+    placedVia: z7.literal("late_capture"),
+    abandonedAt: isoDatetimeSchema({ offset: true }),
     abandonedReason: abandonedReasonSchema,
     paymentState: spentCheckoutPaymentStateSchema,
     order: lightweightOrderReferenceSchema
   }).strict(),
-  z6.object({
+  z7.object({
     ...publicCheckoutBaseShape,
-    status: z6.literal("abandoned"),
-    abandonedAt: z6.string().datetime({ offset: true }),
+    status: z7.literal("abandoned"),
+    abandonedAt: isoDatetimeSchema({ offset: true }),
     abandonedReason: abandonedReasonSchema,
-    paymentState: z6.object({
-      activePaymentSession: z6.null()
+    paymentState: z7.object({
+      activePaymentSession: z7.null()
     }).strict(),
-    order: z6.null()
+    order: z7.null()
   }).strict()
 ];
 function validateCheckoutSnapshot(input, ctx) {
@@ -3094,7 +3122,7 @@ function validateCheckoutSnapshot(input, ctx) {
     });
   }
 }
-var publicCheckoutSchema = z6.union(publicCheckoutVariants).superRefine(validateCheckoutSnapshot);
+var publicCheckoutSchema = z7.union(publicCheckoutVariants).superRefine(validateCheckoutSnapshot);
 var serverCheckoutExtraShape = {
   clientReferenceId: commerceResourceIdSchema.nullable(),
   integrationMetadata: integrationMetadataSchema
@@ -3102,10 +3130,10 @@ var serverCheckoutExtraShape = {
 var serverCheckoutVariants = publicCheckoutVariants.map(
   (variant) => variant.extend(serverCheckoutExtraShape)
 );
-var serverCheckoutSchema = z6.union(serverCheckoutVariants).superRefine(validateCheckoutSnapshot);
-var retrieveCheckoutParamsSchema = z6.object({ checkoutToken: commerceCapabilitySchema }).strict();
-var retrieveServerCheckoutParamsSchema = z6.object({ checkoutId: commerceResourceIdSchema }).strict();
-var createCheckoutBodySchema = z6.object({
+var serverCheckoutSchema = z7.union(serverCheckoutVariants).superRefine(validateCheckoutSnapshot);
+var retrieveCheckoutParamsSchema = z7.object({ checkoutToken: commerceCapabilitySchema }).strict();
+var retrieveServerCheckoutParamsSchema = z7.object({ checkoutId: commerceResourceIdSchema }).strict();
+var createCheckoutBodySchema = z7.object({
   cartToken: commerceCapabilitySchema,
   customer: customerSnapshotSchema,
   shippingAddress: checkoutShippingAddressSchema.optional()
@@ -3121,20 +3149,20 @@ var createServerCheckoutBodySchema = createCheckoutBodySchema.safeExtend({
 var createServerCheckoutParamsSchema = createServerCheckoutBodySchema.extend({
   idempotencyKey: commerceIdempotencyKeySchema
 });
-var createCheckoutResultSchema = z6.object({
+var createCheckoutResultSchema = z7.object({
   checkout: publicCheckoutSchema,
   checkoutToken: commerceCapabilitySchema
 }).strict();
-var createServerCheckoutResultSchema = z6.object({
+var createServerCheckoutResultSchema = z7.object({
   checkout: serverCheckoutSchema,
   checkoutToken: commerceCapabilitySchema
 }).strict();
-var canonicalCheckoutQuerySchema = z6.object({
-  limit: z6.number().int().min(1).max(100).default(20),
-  cursor: z6.string().min(1).max(512).optional(),
-  status: z6.array(z6.enum(["open", "placed", "abandoned"])).optional(),
-  createdAtFrom: z6.string().datetime({ offset: true }).optional(),
-  createdAtTo: z6.string().datetime({ offset: true }).optional(),
+var canonicalCheckoutQuerySchema = z7.object({
+  limit: z7.number().int().min(1).max(100).default(20),
+  cursor: z7.string().min(1).max(512).optional(),
+  status: z7.array(z7.enum(["open", "placed", "abandoned"])).optional(),
+  createdAtFrom: isoDatetimeSchema({ offset: true }).optional(),
+  createdAtTo: isoDatetimeSchema({ offset: true }).optional(),
   clientReferenceId: commerceResourceIdSchema.optional()
 }).strict();
 var checkoutListItemVariants = publicCheckoutVariants.map(
@@ -3144,17 +3172,17 @@ var checkoutListItemVariants = publicCheckoutVariants.map(
     attributes: true
   }).extend({ clientReferenceId: commerceResourceIdSchema.nullable() })
 );
-var checkoutListItemSchema = z6.union(checkoutListItemVariants);
-var canonicalCheckoutQueryResultSchema = z6.object({
-  data: z6.array(checkoutListItemSchema),
-  hasMore: z6.boolean(),
-  nextCursor: z6.string().min(1).max(512).nullable()
+var checkoutListItemSchema = z7.union(checkoutListItemVariants);
+var canonicalCheckoutQueryResultSchema = z7.object({
+  data: z7.array(checkoutListItemSchema),
+  hasMore: z7.boolean(),
+  nextCursor: z7.string().min(1).max(512).nullable()
 }).strict();
 var CreateServerCheckoutParamsSchema = createServerCheckoutParamsSchema;
 var CanonicalCheckoutQuerySchema = canonicalCheckoutQuerySchema;
 
 // ../../internal/contracts/src/ecommerce/index.ts
-var transactionStatusSchema = z7.enum([
+var transactionStatusSchema = z8.enum([
   "pending",
   "paid",
   "success",
@@ -3163,7 +3191,7 @@ var transactionStatusSchema = z7.enum([
   "canceled",
   "refunded"
 ]);
-var transactionKindSchema = z7.enum([
+var transactionKindSchema = z8.enum([
   "authorization",
   "sale",
   "capture",
@@ -3184,14 +3212,14 @@ var RETURN_REASON_CODES = [
   "unknown",
   "other"
 ];
-var returnReasonSchema = z7.enum(RETURN_REASON_CODES);
+var returnReasonSchema = z8.enum(RETURN_REASON_CODES);
 var RETURN_REJECTION_REASON_CODES = [
   "window_expired",
   "used_or_damaged",
   "non_returnable",
   "other"
 ];
-var returnRejectionReasonCodeSchema = z7.enum(
+var returnRejectionReasonCodeSchema = z8.enum(
   RETURN_REJECTION_REASON_CODES
 );
 var RETURN_CANCELLATION_REASON_CODES = [
@@ -3200,30 +3228,30 @@ var RETURN_CANCELLATION_REASON_CODES = [
   "merchant_decision",
   "other"
 ];
-var returnCancellationReasonCodeSchema = z7.enum(
+var returnCancellationReasonCodeSchema = z8.enum(
   RETURN_CANCELLATION_REASON_CODES
 );
-var restockActionSchema = z7.enum(["return_to_stock", "discard"]);
-var returnRefundMoneySchema = z7.number().int("amount must be an integer minor-unit value").safe("amount must be a safe integer").nonnegative("amount must be non-negative");
-var positiveReturnRefundMoneySchema = z7.number().int("amount must be an integer minor-unit value").safe("amount must be a safe integer").positive("amount must be positive");
+var restockActionSchema = z8.enum(["return_to_stock", "discard"]);
+var returnRefundMoneySchema = z8.number().int("amount must be an integer minor-unit value").safe("amount must be a safe integer").nonnegative("amount must be non-negative");
+var positiveReturnRefundMoneySchema = z8.number().int("amount must be an integer minor-unit value").safe("amount must be a safe integer").positive("amount must be positive");
 function trimmedReturnRefundScalarString(maxScalars, emptyMessage, maximumMessage) {
-  return z7.string().trim().min(1, emptyMessage).refine((value) => Array.from(value).length <= maxScalars, maximumMessage);
+  return z8.string().trim().min(1, emptyMessage).refine((value) => Array.from(value).length <= maxScalars, maximumMessage);
 }
-var returnWithRefundItemSchema = z7.object({
-  orderItem: z7.union([z7.string().trim().min(1), z7.number().int().safe().positive()]).transform(String),
-  quantity: z7.number().int("quantity must be an integer").safe("quantity must be a safe integer").positive("quantity must be a positive integer"),
+var returnWithRefundItemSchema = z8.object({
+  orderItem: z8.union([z8.string().trim().min(1), z8.number().int().safe().positive()]).transform(String),
+  quantity: z8.number().int("quantity must be an integer").safe("quantity must be a safe integer").positive("quantity must be a positive integer"),
   restockAction: restockActionSchema.default("return_to_stock"),
   restockingFee: returnRefundMoneySchema.optional().describe("Restocking fee charged for this line (ADR 0005 \xA7Gap 1)")
 }).strict();
-var returnWithRefundSchema = z7.object({
-  orderNumber: z7.string().trim().min(1, "orderNumber is required").describe("Order number (required)"),
+var returnWithRefundSchema = z8.object({
+  orderNumber: z8.string().trim().min(1, "orderNumber is required").describe("Order number (required)"),
   reason: returnReasonSchema.optional().describe("Return reason (optional)"),
   reasonDetail: trimmedReturnRefundScalarString(
     2e3,
     "reasonDetail must not be empty",
     "reasonDetail must be 2000 Unicode code points or fewer"
   ).optional().describe("Detailed reason text (optional)"),
-  returnItems: z7.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
+  returnItems: z8.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
   refundAmount: positiveReturnRefundMoneySchema.describe(
     "Refund amount (required, min 1)"
   ),
@@ -3238,37 +3266,37 @@ var returnWithRefundSchema = z7.object({
   ).optional().describe(
     "Operator audit note required when overriding policy suggestion"
   ),
-  pgPaymentId: z7.string().trim().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
-  paymentKey: z7.string().trim().min(1).optional().describe("Provider payment key for verified refund"),
+  pgPaymentId: z8.string().trim().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
+  paymentKey: z8.string().trim().min(1).optional().describe("Provider payment key for verified refund"),
   refundReceiptUrl: trimmedReturnRefundScalarString(
     2048,
     "refundReceiptUrl must not be empty",
     "refundReceiptUrl must be 2048 Unicode code points or fewer"
   ).optional().describe("Refund receipt URL (optional)")
 }).strict();
-var createReturnSchema = z7.object({
-  orderNumber: z7.string().min(1, "orderNumber is required").describe("Order number (required)"),
+var createReturnSchema = z8.object({
+  orderNumber: z8.string().min(1, "orderNumber is required").describe("Order number (required)"),
   reason: returnReasonSchema.optional().describe("Return reason (optional)"),
-  reasonDetail: z7.string().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Detailed reason text (optional)"),
-  returnItems: z7.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
+  reasonDetail: z8.string().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Detailed reason text (optional)"),
+  returnItems: z8.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
   refundAmount: returnRefundMoneySchema.describe(
     "Line refund amount before initial shipping refund (required, min 0)"
   ),
   returnShippingFee: returnRefundMoneySchema.optional().describe("Return shipping fee charged to the customer"),
   initialShippingRefundAmount: returnRefundMoneySchema.optional().describe("Initial order shipping amount refunded to the customer"),
-  initialShippingRefundOverrideNote: z7.string().min(1).max(
+  initialShippingRefundOverrideNote: z8.string().min(1).max(
     2e3,
     "initialShippingRefundOverrideNote must be 2000 characters or fewer"
   ).optional().describe(
     "Operator audit note required when overriding policy suggestion"
   )
 }).strict();
-var updateReturnSchema = z7.object({
-  returnId: z7.union([z7.string(), z7.number()]).transform(String),
+var updateReturnSchema = z8.object({
+  returnId: z8.union([z8.string(), z8.number()]).transform(String),
   // Only non-financial transitions are accepted here. `completed` is included
   // so the server can return the canonical `server_derived` error instead of
   // a generic validation failure.
-  status: z7.enum([
+  status: z8.enum([
     "processing",
     "approved",
     "rejected",
@@ -3277,7 +3305,7 @@ var updateReturnSchema = z7.object({
   ]),
   reasonCode: returnRejectionReasonCodeSchema.optional(),
   cancellationReasonCode: returnCancellationReasonCodeSchema.optional(),
-  cancellationReasonDetail: z7.string().trim().min(1).max(2e3).optional()
+  cancellationReasonDetail: z8.string().trim().min(1).max(2e3).optional()
 }).strict();
 var CANCEL_REASON_CODES = [
   "customer",
@@ -3287,152 +3315,152 @@ var CANCEL_REASON_CODES = [
   "staff",
   "other"
 ];
-var cancelReasonCodeSchema = z7.enum(CANCEL_REASON_CODES);
+var cancelReasonCodeSchema = z8.enum(CANCEL_REASON_CODES);
 var FORCE_RESOLUTION_REASON_CODES = [
   "staff_error",
   "wrong_fulfillment",
   "other"
 ];
-var forceResolutionReasonCodeSchema = z7.enum(
+var forceResolutionReasonCodeSchema = z8.enum(
   FORCE_RESOLUTION_REASON_CODES
 );
-var idempotencyKeySchema = z7.string().trim().min(1, "idempotencyKey is required").max(255, "idempotencyKey must be 255 characters or fewer").regex(
+var idempotencyKeySchema = z8.string().trim().min(1, "idempotencyKey is required").max(255, "idempotencyKey must be 255 characters or fewer").regex(
   /^[\x21-\x7E]+$/,
   "idempotencyKey must contain only printable header-safe characters"
 );
-var cancelOrderSchema = z7.object({
-  orderNumber: z7.string().min(1, "orderNumber is required").describe("Order number to cancel"),
+var cancelOrderSchema = z8.object({
+  orderNumber: z8.string().min(1, "orderNumber is required").describe("Order number to cancel"),
   reasonCode: cancelReasonCodeSchema.default("other").describe("Operator-selected cancel reason code"),
-  reasonDetail: z7.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
+  reasonDetail: z8.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
 }).strict();
 var cancelOrderResponseBaseSchema = {
-  orderId: z7.string().min(1)
+  orderId: z8.string().min(1)
 };
 var unpaidLocalCancelCommittedResponseFields = {
-  refundedAmount: z7.literal(0),
-  providerRefunded: z7.literal(false)
+  refundedAmount: z8.literal(0),
+  providerRefunded: z8.literal(false)
 };
 var paidLocalCancelCommittedResponseFields = {
-  transactionId: z7.string().min(1),
-  refundedAmount: z7.literal(0),
-  providerRefunded: z7.literal(false),
-  refundPending: z7.literal(true)
+  transactionId: z8.string().min(1),
+  refundedAmount: z8.literal(0),
+  providerRefunded: z8.literal(false),
+  refundPending: z8.literal(true)
 };
 var alreadyCanceledResponseFields = {
-  refundedAmount: z7.number().int().nonnegative(),
-  providerRefunded: z7.literal(false)
+  refundedAmount: z8.number().int().nonnegative(),
+  providerRefunded: z8.literal(false)
 };
 var alreadyCanceledRefundPendingResponseFields = {
-  transactionId: z7.string().min(1),
-  refundedAmount: z7.number().int().nonnegative(),
-  providerRefunded: z7.literal(false),
-  refundPending: z7.literal(true)
+  transactionId: z8.string().min(1),
+  refundedAmount: z8.number().int().nonnegative(),
+  providerRefunded: z8.literal(false),
+  refundPending: z8.literal(true)
 };
-var cancelOrderResponseSchema = z7.union([
-  z7.object({
+var cancelOrderResponseSchema = z8.union([
+  z8.object({
     ...cancelOrderResponseBaseSchema,
     ...paidLocalCancelCommittedResponseFields,
-    status: z7.literal("canceled"),
-    cancelCommitted: z7.literal(true)
+    status: z8.literal("canceled"),
+    cancelCommitted: z8.literal(true)
   }).strict(),
-  z7.object({
+  z8.object({
     ...cancelOrderResponseBaseSchema,
     ...unpaidLocalCancelCommittedResponseFields,
-    status: z7.literal("canceled"),
-    cancelCommitted: z7.literal(true)
+    status: z8.literal("canceled"),
+    cancelCommitted: z8.literal(true)
   }).strict(),
-  z7.object({
+  z8.object({
     ...cancelOrderResponseBaseSchema,
     ...alreadyCanceledResponseFields,
-    status: z7.literal("canceled"),
-    cancelCommitted: z7.literal(false),
-    alreadyCanceled: z7.literal(true)
+    status: z8.literal("canceled"),
+    cancelCommitted: z8.literal(false),
+    alreadyCanceled: z8.literal(true)
   }).strict(),
-  z7.object({
+  z8.object({
     ...cancelOrderResponseBaseSchema,
     ...alreadyCanceledRefundPendingResponseFields,
-    status: z7.literal("canceled"),
-    cancelCommitted: z7.literal(false),
-    alreadyCanceled: z7.literal(true)
+    status: z8.literal("canceled"),
+    cancelCommitted: z8.literal(false),
+    alreadyCanceled: z8.literal(true)
   }).strict()
 ]);
-var resolveCancelRefundOutcomeSchema = z7.enum(["succeeded", "failed"]);
-var resolveCancelRefundSchema = z7.object({
-  orderNumber: z7.string().min(1, "orderNumber is required").describe("Order number whose pending cancel refund is being resolved"),
+var resolveCancelRefundOutcomeSchema = z8.enum(["succeeded", "failed"]);
+var resolveCancelRefundSchema = z8.object({
+  orderNumber: z8.string().min(1, "orderNumber is required").describe("Order number whose pending cancel refund is being resolved"),
   idempotencyKey: idempotencyKeySchema.describe(
     "Stable key for this PG refund result report"
   ),
   outcome: resolveCancelRefundOutcomeSchema.describe(
     "PG refund result reported by the storefront or BFF"
   ),
-  refundedAmount: z7.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
-  pgProvider: z7.string().trim().min(1, "pgProvider is required").regex(
+  refundedAmount: z8.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
+  pgProvider: z8.string().trim().min(1, "pgProvider is required").regex(
     /^[a-z0-9][a-z0-9_-]*$/,
     "pgProvider must be a lowercase provider slug"
   ),
-  pgRefundId: z7.string().trim().min(1).optional()
+  pgRefundId: z8.string().trim().min(1).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.outcome === "succeeded" && value.refundedAmount <= 0) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       path: ["refundedAmount"],
       message: "refundedAmount must be positive when outcome is succeeded"
     });
   }
   if (value.outcome === "succeeded" && !value.pgRefundId) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       path: ["pgRefundId"],
       message: "pgRefundId is required when outcome is succeeded"
     });
   }
   if (value.outcome === "failed" && value.refundedAmount !== 0) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       path: ["refundedAmount"],
       message: "refundedAmount must be 0 when outcome is failed"
     });
   }
 });
-var resolveCancelRefundResponseSchema = z7.union([
-  z7.object({
-    orderId: z7.string().min(1),
-    transactionId: z7.string().min(1),
-    refundTransactionId: z7.string().min(1),
-    refundedAmount: z7.number().int().positive(),
-    refundStatus: z7.literal("succeeded"),
-    transactionStatus: z7.enum(["paid", "refunded"])
+var resolveCancelRefundResponseSchema = z8.union([
+  z8.object({
+    orderId: z8.string().min(1),
+    transactionId: z8.string().min(1),
+    refundTransactionId: z8.string().min(1),
+    refundedAmount: z8.number().int().positive(),
+    refundStatus: z8.literal("succeeded"),
+    transactionStatus: z8.enum(["paid", "refunded"])
   }).strict(),
-  z7.object({
-    orderId: z7.string().min(1),
-    transactionId: z7.string().min(1),
-    refundTransactionId: z7.string().min(1),
-    refundedAmount: z7.literal(0),
-    refundStatus: z7.literal("failed"),
-    transactionStatus: z7.literal("paid")
+  z8.object({
+    orderId: z8.string().min(1),
+    transactionId: z8.string().min(1),
+    refundTransactionId: z8.string().min(1),
+    refundedAmount: z8.literal(0),
+    refundStatus: z8.literal("failed"),
+    transactionStatus: z8.literal("paid")
   }).strict()
 ]);
 
 // src/commands/order.ts
-import { z as z8 } from "zod";
-var idSchema = z8.union([z8.string().min(1), z8.number()]).transform(String);
-var orderStatusSchema = z8.enum(["confirmed"]);
-var fulfillmentStatusSchema = z8.enum(["shipped", "delivered", "failed"]);
-var updateFulfillmentSchema = z8.object({
+import { z as z9 } from "zod";
+var idSchema = z9.union([z9.string().min(1), z9.number()]).transform(String);
+var orderStatusSchema = z9.enum(["confirmed"]);
+var fulfillmentStatusSchema = z9.enum(["shipped", "delivered", "failed"]);
+var updateFulfillmentSchema = z9.object({
   fulfillmentId: idSchema,
   status: fulfillmentStatusSchema.optional(),
-  carrier: z8.string().min(1).optional(),
-  trackingNumber: z8.string().min(1).optional()
+  carrier: z9.string().min(1).optional(),
+  trackingNumber: z9.string().min(1).optional()
 }).refine(
   (value) => value.status !== void 0 || value.carrier !== void 0 || value.trackingNumber !== void 0,
   {
     message: "status, carrier, or trackingNumber is required"
   }
 );
-var fulfillmentItemsSchema = z8.array(
-  z8.object({
+var fulfillmentItemsSchema = z9.array(
+  z9.object({
     orderItem: idSchema,
-    quantity: z8.number().int().positive("quantity must be a positive integer")
+    quantity: z9.number().int().positive("quantity must be a positive integer")
   }).strict()
 ).min(1, "At least one fulfillment item is required").max(100, "Maximum 100 items per fulfillment");
 function registerOrderCommands(program, getClient, getFormat) {
@@ -3566,8 +3594,8 @@ function registerOrderCommands(program, getClient, getFormat) {
 }
 
 // src/commands/return.ts
-import { z as z9 } from "zod";
-var returnStatusSchema = z9.enum([
+import { z as z10 } from "zod";
+var returnStatusSchema = z10.enum([
   "processing",
   "approved",
   "rejected",