@01.software/cli 0.15.0 → 0.16.0

package/dist/index.js

@@ -900,6 +900,9 @@ var tenantFeatureProgressResponseSchema = z.object({
     planBlocked: z.array(z.string()),
     closureAdded: z.array(z.string())
   }).strict(),
+  config: z.object({
+    fulfillmentMode: z.enum(["shipping", "none"])
+  }).strict(),
   summary: z.object({
     complete: z.number().int().nonnegative(),
     total: z.number().int().nonnegative(),
@@ -951,7 +954,7 @@ var collectionSchemaResponseSchema = z.object({
 }).strict();
 
 // ../contracts/src/ecommerce/index.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../contracts/src/ecommerce/product-upsert.ts
 import { z as z2 } from "zod";
@@ -977,6 +980,10 @@ var productFieldShape = {
   publishedAt: z2.string().optional().nullable(),
   categories: z2.array(IdSchema).optional(),
   tags: z2.array(IdSchema).optional(),
+  seo: z2.object({
+    title: z2.string().optional().nullable(),
+    description: z2.string().optional().nullable()
+  }).optional().nullable(),
   metadata: z2.unknown().optional()
 };
 var PRODUCT_UPSERT_PRODUCT_FIELDS = Object.keys(
@@ -1102,44 +1109,86 @@ var ProductUpsertSchema = ProductUpsertObjectSchema.superRefine(
   }
 );
 
+// ../contracts/src/ecommerce/checkout.ts
+import { z as z3 } from "zod";
+var providerSlugSchema = z3.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "pgProvider must be lowercase slug");
+var CheckoutShippingAddressSchema = z3.object({
+  recipientName: z3.string().min(1),
+  phone: z3.string().min(1),
+  postalCode: z3.string().min(1),
+  address: z3.string().min(1),
+  detailAddress: z3.string().min(1),
+  deliveryMessage: z3.string().optional()
+});
+var CheckoutCustomerSnapshotSchema = z3.object({
+  name: z3.string().optional(),
+  email: z3.string().email("Invalid email format"),
+  phone: z3.string().optional()
+});
+var CheckoutRequestSchema = z3.object({
+  cartId: z3.union([z3.string(), z3.number()]).transform(String),
+  cartToken: z3.string().min(1).optional(),
+  pgPaymentId: z3.string().min(1).optional(),
+  pgProvider: providerSlugSchema.optional(),
+  orderNumber: z3.string().min(1, "orderNumber is required"),
+  customerSnapshot: CheckoutCustomerSnapshotSchema,
+  shippingAddress: CheckoutShippingAddressSchema.optional(),
+  discountCode: z3.string().optional()
+}).superRefine((data, ctx) => {
+  if (data.pgPaymentId && !data.pgProvider) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["pgProvider"],
+      message: "pgProvider is required when pgPaymentId is provided"
+    });
+  }
+  if (data.pgProvider && !data.pgPaymentId) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["pgPaymentId"],
+      message: "pgPaymentId is required when pgProvider is provided"
+    });
+  }
+});
+
 // ../contracts/src/ecommerce/index.ts
-var transactionStatusSchema = z3.enum([
+var transactionStatusSchema = z4.enum([
   "pending",
   "paid",
   "failed",
   "canceled",
   "refunded"
 ]);
-var financialStatusSchema = z3.enum([
+var financialStatusSchema = z4.enum([
   "pending",
   "paid",
   "canceled",
   "partially_refunded",
   "refunded"
 ]);
-var orderDisplayFinancialStatusSchema = z3.enum([
+var orderDisplayFinancialStatusSchema = z4.enum([
   "pending",
   "paid",
   "partially_refunded",
   "refunded",
   "voided"
 ]);
-var confirmationStatusSchema = z3.enum(["unconfirmed", "confirmed"]);
-var fulfillmentOrderStatusSchema = z3.enum([
+var confirmationStatusSchema = z4.enum(["unconfirmed", "confirmed"]);
+var fulfillmentOrderStatusSchema = z4.enum([
   "open",
   "in_progress",
   "on_hold",
   "canceled",
   "closed"
 ]);
-var shipmentStatusSchema = z3.enum([
+var shipmentStatusSchema = z4.enum([
   "pending",
   "shipped",
   "delivered",
   "canceled",
   "failed"
 ]);
-var orderDisplayFulfillmentStatusSchema = z3.enum([
+var orderDisplayFulfillmentStatusSchema = z4.enum([
   "unfulfilled",
   "in_progress",
   "on_hold",
@@ -1148,13 +1197,13 @@ var orderDisplayFulfillmentStatusSchema = z3.enum([
   "fulfilled",
   "canceled"
 ]);
-var orderReturnStatusSchema = z3.enum([
+var orderReturnStatusSchema = z4.enum([
   "no_return",
   "return_requested",
   "in_progress",
   "returned"
 ]);
-var orderStatusSchema = z3.enum([
+var orderStatusSchema = z4.enum([
   "pending",
   "paid",
   "canceled",
@@ -1167,81 +1216,97 @@ var orderStatusSchema = z3.enum([
   "return_processing",
   "returned"
 ]);
-var entityIdSchema = z3.union([z3.string().min(1), z3.number()]).transform(String);
-var createOrderItemSchema = z3.object({
+var entityIdSchema = z4.union([z4.string().min(1), z4.number()]).transform(String);
+var createOrderItemSchema = z4.object({
   // `product` and `option` are storefront-optional: the create-order
   // endpoint derives the product from the variant's parent and snapshots
   // option selection from the variant.
   product: entityIdSchema.optional(),
   variant: entityIdSchema,
   option: entityIdSchema.optional(),
-  quantity: z3.number().int().positive("quantity must be a positive integer"),
-  unitPrice: z3.number().optional(),
-  totalPrice: z3.number().optional()
+  quantity: z4.number().int().positive("quantity must be a positive integer"),
+  unitPrice: z4.number().optional(),
+  totalPrice: z4.number().optional()
 }).strict();
-var createOrderSchema = z3.object({
-  pgPaymentId: z3.string().min(1).optional(),
-  orderNumber: z3.string().min(1, "orderNumber is required"),
+var providerSlugSchema2 = z4.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "pgProvider must be lowercase slug");
+var createOrderSchema = z4.object({
+  pgPaymentId: z4.string().min(1).optional(),
+  pgProvider: providerSlugSchema2.optional(),
+  orderNumber: z4.string().min(1, "orderNumber is required"),
   customer: entityIdSchema.optional(),
-  customerSnapshot: z3.object({
-    name: z3.string().optional(),
-    email: z3.string().email("Invalid email format"),
-    phone: z3.string().optional()
+  customerSnapshot: z4.object({
+    name: z4.string().optional(),
+    email: z4.string().email("Invalid email format"),
+    phone: z4.string().optional()
   }).strict(),
-  shippingAddress: z3.object({
-    postalCode: z3.string().optional(),
-    address: z3.string().optional(),
-    detailAddress: z3.string().optional(),
-    deliveryMessage: z3.string().optional(),
-    recipientName: z3.string().optional(),
-    phone: z3.string().optional()
+  shippingAddress: z4.object({
+    postalCode: z4.string().optional(),
+    address: z4.string().optional(),
+    detailAddress: z4.string().optional(),
+    deliveryMessage: z4.string().optional(),
+    recipientName: z4.string().optional(),
+    phone: z4.string().optional()
   }).strict().optional(),
-  orderItems: z3.array(createOrderItemSchema).min(1, "At least one order item is required").max(100, "Maximum 100 items per order"),
-  totalAmount: z3.number().nonnegative("totalAmount must be non-negative"),
-  shippingAmount: z3.number().min(0).optional(),
-  discountCode: z3.string().optional()
-}).strict();
-var updateTransactionSchema = z3.object({
-  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("PG payment ID (required)"),
+  orderItems: z4.array(createOrderItemSchema).min(1, "At least one order item is required").max(100, "Maximum 100 items per order"),
+  totalAmount: z4.number().nonnegative("totalAmount must be non-negative"),
+  shippingAmount: z4.number().min(0).optional(),
+  discountCode: z4.string().optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.pgPaymentId && !data.pgProvider) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      path: ["pgProvider"],
+      message: "pgProvider is required when pgPaymentId is provided"
+    });
+  }
+  if (data.pgProvider && !data.pgPaymentId) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      path: ["pgPaymentId"],
+      message: "pgPaymentId is required when pgProvider is provided"
+    });
+  }
+});
+var updateTransactionSchema = z4.object({
+  pgPaymentId: z4.string().min(1, "pgPaymentId is required").describe("PG payment ID (required)"),
   status: transactionStatusSchema.describe(
     "New transaction status (required)"
   ),
-  paymentMethod: z3.string().optional().describe("Payment method (optional)"),
-  receiptUrl: z3.string().optional().describe("Receipt URL (optional)"),
-  paymentKey: z3.string().min(1).optional().describe("Provider payment key for verified paid confirmation"),
-  amount: z3.number().int().positive().optional().describe("Provider-confirmed amount for verified paid confirmation")
+  paymentMethod: z4.string().optional().describe("Payment method (optional)"),
+  receiptUrl: z4.string().optional().describe("Receipt URL (optional)"),
+  paymentKey: z4.string().min(1).optional().describe("Provider payment key for verified paid confirmation"),
+  amount: z4.number().int().positive().optional().describe("Provider-confirmed amount for verified paid confirmation")
 }).strict();
-var providerSlugSchema = z3.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "pgProvider must be lowercase slug");
-var confirmPaymentSchema = z3.object({
-  orderNumber: z3.string().min(1).optional(),
-  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("Provider payment identifier stored on the transaction"),
-  pgProvider: providerSlugSchema.describe(
+var confirmPaymentSchema = z4.object({
+  orderNumber: z4.string().min(1).optional(),
+  pgPaymentId: z4.string().min(1, "pgPaymentId is required").describe("Provider payment identifier stored on the transaction"),
+  pgProvider: providerSlugSchema2.describe(
     "Payment provider slug, e.g. toss, portone, stripe"
   ),
-  pgOrderId: z3.string().min(1).optional(),
-  amount: z3.number().int().nonnegative("amount must be non-negative").describe("Provider-confirmed amount in minor units"),
-  currency: z3.string().min(1).optional(),
-  paymentMethod: z3.string().optional(),
-  receiptUrl: z3.string().url().optional(),
-  approvedAt: z3.string().optional(),
-  providerStatus: z3.string().optional(),
-  providerEventId: z3.string().min(1).optional(),
-  confirmationSource: z3.enum([
+  pgOrderId: z4.string().min(1).optional(),
+  amount: z4.number().int().nonnegative("amount must be non-negative").describe("Provider-confirmed amount in minor units"),
+  currency: z4.string().min(1).optional(),
+  paymentMethod: z4.string().optional(),
+  receiptUrl: z4.string().url().optional(),
+  approvedAt: z4.string().optional(),
+  providerStatus: z4.string().optional(),
+  providerEventId: z4.string().min(1).optional(),
+  confirmationSource: z4.enum([
     "provider_webhook",
     "provider_lookup",
     "provider_api_confirm",
     "manual_server"
   ]).optional(),
-  paymentKey: z3.string().min(1).optional().describe(
+  paymentKey: z4.string().min(1).optional().describe(
     "Optional provider payment key from the client confirm handshake; stored for BFF/provider refund workflows (also accepted as metadata.tossPaymentKey). Local cancel does not read this field."
   ),
-  metadata: z3.record(z3.string(), z3.unknown()).optional()
+  metadata: z4.record(z4.string(), z4.unknown()).optional()
 }).strict();
-var confirmPaymentResponseSchema = z3.object({
-  orderId: z3.string().min(1),
-  transactionId: z3.string().min(1),
-  status: z3.literal("paid"),
-  alreadyConfirmed: z3.boolean().optional()
+var confirmPaymentResponseSchema = z4.object({
+  orderId: z4.string().min(1),
+  transactionId: z4.string().min(1),
+  status: z4.literal("paid"),
+  alreadyConfirmed: z4.boolean().optional()
 }).strict();
 var RETURN_REASON_CODES = [
   "change_of_mind",
@@ -1250,42 +1315,51 @@ var RETURN_REASON_CODES = [
   "damaged",
   "other"
 ];
-var returnReasonSchema = z3.enum(RETURN_REASON_CODES);
-var restockActionSchema = z3.enum(["return_to_stock", "discard"]);
-var returnWithRefundItemSchema = z3.object({
-  orderItem: z3.union([z3.string().min(1), z3.number()]).transform(String),
-  quantity: z3.number().int().positive("quantity must be a positive integer"),
+var returnReasonSchema = z4.enum(RETURN_REASON_CODES);
+var RETURN_REJECTION_REASON_CODES = [
+  "window_expired",
+  "used_or_damaged",
+  "non_returnable",
+  "other"
+];
+var returnRejectionReasonCodeSchema = z4.enum(
+  RETURN_REJECTION_REASON_CODES
+);
+var restockActionSchema = z4.enum(["return_to_stock", "discard"]);
+var returnWithRefundItemSchema = z4.object({
+  orderItem: z4.union([z4.string().min(1), z4.number()]).transform(String),
+  quantity: z4.number().int().positive("quantity must be a positive integer"),
   restockAction: restockActionSchema.default("return_to_stock"),
-  restockingFee: z3.number().min(0, "restockingFee must be non-negative").optional().describe("Restocking fee charged for this line (ADR 0005 \xA7Gap 1)")
+  restockingFee: z4.number().min(0, "restockingFee must be non-negative").optional().describe("Restocking fee charged for this line (ADR 0005 \xA7Gap 1)")
 }).strict();
-var returnWithRefundSchema = z3.object({
-  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number (required)"),
+var returnWithRefundSchema = z4.object({
+  orderNumber: z4.string().min(1, "orderNumber is required").describe("Order number (required)"),
   reason: returnReasonSchema.optional().describe("Return reason (optional)"),
-  reasonDetail: z3.string().optional().describe("Detailed reason text (optional)"),
-  returnItems: z3.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: z3.number().min(0, "refundAmount must be non-negative").describe("Refund amount (required, min 0)"),
-  returnShippingFee: z3.number().min(0, "returnShippingFee must be non-negative").optional().describe(
+  reasonDetail: z4.string().optional().describe("Detailed reason text (optional)"),
+  returnItems: z4.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: z4.number().min(0, "refundAmount must be non-negative").describe("Refund amount (required, min 0)"),
+  returnShippingFee: z4.number().min(0, "returnShippingFee must be non-negative").optional().describe(
     "Return shipping fee charged to the customer (ADR 0005 \xA7Gap 1)"
   ),
-  initialShippingRefundAmount: z3.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
-  initialShippingRefundOverrideNote: z3.string().min(1).optional().describe(
+  initialShippingRefundAmount: z4.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
+  initialShippingRefundOverrideNote: z4.string().min(1).optional().describe(
     "Operator audit note required when overriding policy suggestion"
   ),
-  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
-  paymentKey: z3.string().min(1).optional().describe("Provider payment key for verified refund"),
-  refundReceiptUrl: z3.string().optional().describe("Refund receipt URL (optional)")
+  pgPaymentId: z4.string().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
+  paymentKey: z4.string().min(1).optional().describe("Provider payment key for verified refund"),
+  refundReceiptUrl: z4.string().optional().describe("Refund receipt URL (optional)")
 }).strict();
-var createReturnSchema = z3.object({
-  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number (required)"),
+var createReturnSchema = z4.object({
+  orderNumber: z4.string().min(1, "orderNumber is required").describe("Order number (required)"),
   reason: returnReasonSchema.optional().describe("Return reason (optional)"),
-  reasonDetail: z3.string().optional().describe("Detailed reason text (optional)"),
-  returnItems: z3.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: z3.number().min(0, "refundAmount must be non-negative").describe(
+  reasonDetail: z4.string().optional().describe("Detailed reason text (optional)"),
+  returnItems: z4.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: z4.number().min(0, "refundAmount must be non-negative").describe(
     "Line refund amount before initial shipping refund (required, min 0)"
   ),
-  returnShippingFee: z3.number().min(0, "returnShippingFee must be non-negative").optional().describe("Return shipping fee charged to the customer"),
-  initialShippingRefundAmount: z3.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
-  initialShippingRefundOverrideNote: z3.string().min(1).optional().describe(
+  returnShippingFee: z4.number().min(0, "returnShippingFee must be non-negative").optional().describe("Return shipping fee charged to the customer"),
+  initialShippingRefundAmount: z4.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
+  initialShippingRefundOverrideNote: z4.string().min(1).optional().describe(
     "Operator audit note required when overriding policy suggestion"
   )
 }).strict();
@@ -1297,54 +1371,54 @@ var CANCEL_REASON_CODES = [
   "staff",
   "other"
 ];
-var cancelReasonCodeSchema = z3.enum(CANCEL_REASON_CODES);
+var cancelReasonCodeSchema = z4.enum(CANCEL_REASON_CODES);
 var FORCE_RESOLUTION_REASON_CODES = [
   "staff_error",
   "wrong_fulfillment",
   "other"
 ];
-var forceResolutionReasonCodeSchema = z3.enum(
+var forceResolutionReasonCodeSchema = z4.enum(
   FORCE_RESOLUTION_REASON_CODES
 );
-var idempotencyKeySchema = z3.string().trim().min(1, "idempotencyKey is required").max(255, "idempotencyKey must be 255 characters or fewer").regex(
+var idempotencyKeySchema = z4.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 = z3.object({
-  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number to cancel"),
+var cancelOrderSchema = z4.object({
+  orderNumber: z4.string().min(1, "orderNumber is required").describe("Order number to cancel"),
   reasonCode: cancelReasonCodeSchema.default("other").describe("Operator-selected cancel reason code"),
-  reasonDetail: z3.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
+  reasonDetail: z4.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
 }).strict();
 var cancelOrderResponseBaseSchema = {
-  orderId: z3.string().min(1)
+  orderId: z4.string().min(1)
 };
 var unpaidLocalCancelCommittedResponseFields = {
-  refundedAmount: z3.literal(0),
-  providerRefunded: z3.literal(false)
+  refundedAmount: z4.literal(0),
+  providerRefunded: z4.literal(false)
 };
 var paidLocalCancelCommittedResponseFields = {
-  transactionId: z3.string().min(1),
-  refundedAmount: z3.literal(0),
-  providerRefunded: z3.literal(false),
-  refundPending: z3.literal(true)
+  transactionId: z4.string().min(1),
+  refundedAmount: z4.literal(0),
+  providerRefunded: z4.literal(false),
+  refundPending: z4.literal(true)
 };
 var legacyProviderRefundResponseFields = {
-  transactionId: z3.string().min(1),
-  refundedAmount: z3.number().int().positive(),
-  refundSeq: z3.number().int().positive(),
-  providerRefunded: z3.literal(true)
+  transactionId: z4.string().min(1),
+  refundedAmount: z4.number().int().positive(),
+  refundSeq: z4.number().int().positive(),
+  providerRefunded: z4.literal(true)
 };
 var alreadyCanceledResponseFields = {
-  refundedAmount: z3.number().int().nonnegative(),
-  providerRefunded: z3.literal(false)
+  refundedAmount: z4.number().int().nonnegative(),
+  providerRefunded: z4.literal(false)
 };
 var alreadyCanceledRefundPendingResponseFields = {
-  transactionId: z3.string().min(1),
-  refundedAmount: z3.number().int().nonnegative(),
-  providerRefunded: z3.literal(false),
-  refundPending: z3.literal(true)
+  transactionId: z4.string().min(1),
+  refundedAmount: z4.number().int().nonnegative(),
+  providerRefunded: z4.literal(false),
+  refundPending: z4.literal(true)
 };
-var cancelOrderReconciliationStatusSchema = z3.enum([
+var cancelOrderReconciliationStatusSchema = z4.enum([
   "paid",
   "preparing",
   "shipped",
@@ -1355,132 +1429,133 @@ var cancelOrderReconciliationStatusSchema = z3.enum([
   "returned",
   "refunded"
 ]);
-var cancelOrderResponseSchema = z3.union([
-  z3.object({
+var cancelOrderResponseSchema = z4.union([
+  z4.object({
     ...cancelOrderResponseBaseSchema,
     ...paidLocalCancelCommittedResponseFields,
-    status: z3.literal("canceled"),
-    cancelCommitted: z3.literal(true)
+    status: z4.literal("canceled"),
+    cancelCommitted: z4.literal(true)
   }).strict(),
-  z3.object({
+  z4.object({
     ...cancelOrderResponseBaseSchema,
     ...unpaidLocalCancelCommittedResponseFields,
-    status: z3.literal("canceled"),
-    cancelCommitted: z3.literal(true)
+    status: z4.literal("canceled"),
+    cancelCommitted: z4.literal(true)
   }).strict(),
-  z3.object({
+  z4.object({
     ...cancelOrderResponseBaseSchema,
     ...alreadyCanceledResponseFields,
-    status: z3.literal("canceled"),
-    cancelCommitted: z3.literal(false),
-    alreadyCanceled: z3.literal(true)
+    status: z4.literal("canceled"),
+    cancelCommitted: z4.literal(false),
+    alreadyCanceled: z4.literal(true)
   }).strict(),
-  z3.object({
+  z4.object({
     ...cancelOrderResponseBaseSchema,
     ...alreadyCanceledRefundPendingResponseFields,
-    status: z3.literal("canceled"),
-    cancelCommitted: z3.literal(false),
-    alreadyCanceled: z3.literal(true)
+    status: z4.literal("canceled"),
+    cancelCommitted: z4.literal(false),
+    alreadyCanceled: z4.literal(true)
   }).strict(),
-  z3.object({
+  z4.object({
     ...cancelOrderResponseBaseSchema,
     ...legacyProviderRefundResponseFields,
     status: cancelOrderReconciliationStatusSchema,
-    cancelCommitted: z3.literal(false),
-    reconciliationRequired: z3.literal(true)
+    cancelCommitted: z4.literal(false),
+    reconciliationRequired: z4.literal(true)
   }).strict()
 ]);
-var resolveCancelRefundOutcomeSchema = z3.enum(["succeeded", "failed"]);
-var resolveCancelRefundSchema = z3.object({
-  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number whose pending cancel refund is being resolved"),
+var resolveCancelRefundOutcomeSchema = z4.enum(["succeeded", "failed"]);
+var resolveCancelRefundSchema = z4.object({
+  orderNumber: z4.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: z3.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
-  pgProvider: z3.string().trim().min(1, "pgProvider is required").regex(
+  refundedAmount: z4.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
+  pgProvider: z4.string().trim().min(1, "pgProvider is required").regex(
     /^[a-z0-9][a-z0-9_-]*$/,
     "pgProvider must be a lowercase provider slug"
   ),
-  pgRefundId: z3.string().trim().min(1).optional()
+  pgRefundId: z4.string().trim().min(1).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.outcome === "succeeded" && value.refundedAmount <= 0) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["refundedAmount"],
       message: "refundedAmount must be positive when outcome is succeeded"
     });
   }
   if (value.outcome === "succeeded" && !value.pgRefundId) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["pgRefundId"],
       message: "pgRefundId is required when outcome is succeeded"
     });
   }
   if (value.outcome === "failed" && value.refundedAmount !== 0) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["refundedAmount"],
       message: "refundedAmount must be 0 when outcome is failed"
     });
   }
 });
-var resolveCancelRefundResponseSchema = z3.union([
-  z3.object({
-    orderId: z3.string().min(1),
-    transactionId: z3.string().min(1),
-    refundTransactionId: z3.string().min(1),
-    refundedAmount: z3.number().int().positive(),
-    refundStatus: z3.literal("succeeded"),
-    transactionStatus: z3.literal("refunded")
+var resolveCancelRefundResponseSchema = z4.union([
+  z4.object({
+    orderId: z4.string().min(1),
+    transactionId: z4.string().min(1),
+    refundTransactionId: z4.string().min(1),
+    refundedAmount: z4.number().int().positive(),
+    refundStatus: z4.literal("succeeded"),
+    transactionStatus: z4.literal("refunded")
   }).strict(),
-  z3.object({
-    orderId: z3.string().min(1),
-    transactionId: z3.string().min(1),
-    refundTransactionId: z3.string().min(1),
-    refundedAmount: z3.literal(0),
-    refundStatus: z3.literal("failed"),
-    transactionStatus: z3.literal("paid")
+  z4.object({
+    orderId: z4.string().min(1),
+    transactionId: z4.string().min(1),
+    refundTransactionId: z4.string().min(1),
+    refundedAmount: z4.literal(0),
+    refundStatus: z4.literal("failed"),
+    transactionStatus: z4.literal("paid")
   }).strict()
 ]);
 
 // src/commands/order.ts
-import { z as z4 } from "zod";
-var idSchema = z4.union([z4.string().min(1), z4.number()]).transform(String);
-var customerSnapshotSchema = z4.object({
-  email: z4.string().email("Invalid email format"),
-  name: z4.string().optional(),
-  phone: z4.string().optional()
+import { z as z5 } from "zod";
+var idSchema = z5.union([z5.string().min(1), z5.number()]).transform(String);
+var customerSnapshotSchema = z5.object({
+  email: z5.string().email("Invalid email format"),
+  name: z5.string().optional(),
+  phone: z5.string().optional()
 }).strict();
-var orderStatusSchema2 = z4.enum(["confirmed"]);
-var fulfillmentStatusSchema = z4.enum(["shipped", "delivered", "failed"]);
-var updateFulfillmentSchema = z4.object({
+var orderStatusSchema2 = z5.enum(["confirmed"]);
+var fulfillmentStatusSchema = z5.enum(["shipped", "delivered", "failed"]);
+var updateFulfillmentSchema = z5.object({
   fulfillmentId: idSchema,
   status: fulfillmentStatusSchema.optional(),
-  carrier: z4.string().min(1).optional(),
-  trackingNumber: z4.string().min(1).optional()
+  carrier: z5.string().min(1).optional(),
+  trackingNumber: z5.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 = z4.array(
-  z4.object({
+var fulfillmentItemsSchema = z5.array(
+  z5.object({
     orderItem: idSchema,
-    quantity: z4.number().int().positive("quantity must be a positive integer")
+    quantity: z5.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(program2, getClient2, getFormat2) {
   const order = program2.command("order").description("Order management");
-  order.command("create").description("Create a new order").option("--payment-id <id>", "Payment ID").requiredOption("--order-number <num>", "Order number").requiredOption("--email <email>", "Customer email").option("--customer <id>", "Customer ID").option("--name <name>", "Customer name").option("--phone <phone>", "Customer phone").requiredOption("--shipping-address <json>", "Shipping address (JSON)").requiredOption("--products <json>", "Order products array (JSON)").requiredOption("--total-amount <n>", "Total amount", parseFloat).option("--shipping-amount <n>", "Shipping amount", parseFloat).option("--discount-code <code>", "Discount code").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+  order.command("create").description("Create a new order").option("--payment-id <id>", "Payment ID").option("--provider <slug>", "Payment provider slug").requiredOption("--order-number <num>", "Order number").requiredOption("--email <email>", "Customer email").option("--customer <id>", "Customer ID").option("--name <name>", "Customer name").option("--phone <phone>", "Customer phone").requiredOption("--shipping-address <json>", "Shipping address (JSON)").requiredOption("--products <json>", "Order products array (JSON)").requiredOption("--total-amount <n>", "Total amount", parseFloat).option("--shipping-amount <n>", "Shipping amount", parseFloat).option("--discount-code <code>", "Discount code").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
     try {
-      const data = parseWithSchema(
+      const parsed = parseWithSchema(
         {
-          pgPaymentId: opts.paymentId,
+          ...opts.paymentId ? { pgPaymentId: opts.paymentId } : {},
+          ...opts.provider ? { pgProvider: opts.provider } : {},
           orderNumber: opts.orderNumber,
           customerSnapshot: {
             email: opts.email,
@@ -1500,6 +1575,8 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
         "order",
         createOrderSchema
       );
+      const { pgPaymentId, pgProvider, ...orderData } = parsed;
+      const data = pgPaymentId ? { ...orderData, pgPaymentId, pgProvider } : orderData;
       if (opts.dryRun) {
         printResult(
           { dryRun: true, valid: true, action: "order create", data },
@@ -1576,19 +1653,26 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
-  order.command("checkout").description("Convert a cart to an order").requiredOption("--cart-id <id>", "Cart ID").option("--payment-id <id>", "Payment ID (optional for free orders)").requiredOption("--order-number <num>", "Order number").requiredOption("--customer <json>", "Customer snapshot (JSON)").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+  order.command("checkout").description("Convert a cart to an order").requiredOption("--cart-id <id>", "Cart ID").option("--payment-id <id>", "Payment ID (optional for free orders)").option("--provider <slug>", "Payment provider slug").requiredOption("--order-number <num>", "Order number").requiredOption("--customer <json>", "Customer snapshot (JSON)").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
     try {
       const customerSnapshot = parseWithSchema(
         parseJson(opts.customer, "customer"),
         "customer",
         customerSnapshotSchema
       );
-      const data = {
-        cartId: opts.cartId,
-        pgPaymentId: opts.paymentId,
-        orderNumber: opts.orderNumber,
-        customerSnapshot
-      };
+      const parsed = parseWithSchema(
+        {
+          cartId: opts.cartId,
+          ...opts.paymentId ? { pgPaymentId: opts.paymentId } : {},
+          ...opts.provider ? { pgProvider: opts.provider } : {},
+          orderNumber: opts.orderNumber,
+          customerSnapshot
+        },
+        "checkout",
+        CheckoutRequestSchema
+      );
+      const { pgPaymentId, pgProvider, ...checkoutData } = parsed;
+      const data = pgPaymentId ? { ...checkoutData, pgPaymentId, pgProvider } : checkoutData;
       if (opts.dryRun) {
         printResult(
           { dryRun: true, valid: true, action: "order checkout", data },
@@ -1597,10 +1681,7 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
         return;
       }
       const client = getClient2();
-      const result = await client.commerce.orders.checkout({
-        ...data,
-        customerSnapshot
-      });
+      const result = await client.commerce.orders.checkout(data);
       printResult(result, getFormat2());
     } catch (e) {
       exitWithError(e);
@@ -1689,8 +1770,8 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
 }
 
 // src/commands/return.ts
-import { z as z5 } from "zod";
-var returnStatusSchema = z5.enum([
+import { z as z6 } from "zod";
+var returnStatusSchema = z6.enum([
   "processing",
   "approved",
   "rejected",
@@ -1982,14 +2063,14 @@ function registerStockCommands(program2, getClient2, getFormat2) {
 }
 
 // src/commands/transaction.ts
-import { z as z6 } from "zod";
-var transactionAmountSchema = z6.object({
-  amount: z6.string().regex(/^[1-9]\d*$/, "amount must be a positive integer").transform(Number)
+import { z as z7 } from "zod";
+var transactionAmountSchema = z7.object({
+  amount: z7.string().regex(/^[1-9]\d*$/, "amount must be a positive integer").transform(Number)
 });
-var confirmPaymentAmountSchema = z6.object({
-  amount: z6.string().regex(/^(0|[1-9]\d*)$/, "amount must be a non-negative integer").transform(Number)
+var confirmPaymentAmountSchema = z7.object({
+  amount: z7.string().regex(/^(0|[1-9]\d*)$/, "amount must be a non-negative integer").transform(Number)
 });
-var idempotencyKeyOptionSchema = z6.object({
+var idempotencyKeyOptionSchema = z7.object({
   idempotencyKey: idempotencyKeySchema
 });
 function parseTransactionAmount(value) {