@rebuy/rebuy 3.55.0 → 3.56.1

package/dist/index.cjs

@@ -93,6 +93,8 @@ __export(src_exports, {
   CABVariantLabels: () => CABVariantLabels,
   CABVariantsSection: () => CABVariantsSection,
   CABVisibility: () => CABVisibility,
+  CLIENT_LEDGER_MAX_EVENTS: () => CLIENT_LEDGER_MAX_EVENTS,
+  CLIENT_LEDGER_TYPES: () => CLIENT_LEDGER_TYPES,
   COMBINED_ENDPOINTS: () => COMBINED_ENDPOINTS,
   CabActiveExperiment: () => CabActiveExperiment,
   CabShopConfig: () => CabShopConfig,
@@ -103,6 +105,8 @@ __export(src_exports, {
   ClassificationAttemptProgressSchema: () => ClassificationAttemptProgressSchema,
   ClassificationProgressSchema: () => ClassificationProgressSchema,
   ClassificationResultProgressSchema: () => ClassificationResultProgressSchema,
+  ClientLedgerEventSchema: () => ClientLedgerEventSchema,
+  ClientLedgerRequestSchema: () => ClientLedgerRequestSchema,
   ContentBlock: () => ContentBlock,
   ContentBlockV1: () => ContentBlockV1,
   ContentOperator: () => ContentOperator,
@@ -205,6 +209,7 @@ __export(src_exports, {
   PostPurchaseOptions: () => PostPurchaseOptions,
   PostPurchaseOrderAttributes: () => PostPurchaseOrderAttributes,
   PostPurchaseOrderIdSchema: () => PostPurchaseOrderIdSchema,
+  PostPurchaseOrderPendingSchema: () => PostPurchaseOrderPendingSchema,
   PostPurchaseOriginalVariants: () => PostPurchaseOriginalVariants,
   PostPurchasePlanAdjustment: () => PostPurchasePlanAdjustment,
   PostPurchasePlanCatalog: () => PostPurchasePlanCatalog,
@@ -2798,7 +2803,9 @@ var PostPurchaseSubscriptionTerms = import_zod21.z.object({
   intervalLabel: import_zod21.z.string().min(1),
   name: import_zod21.z.string().min(1),
   recurringShippingPrice: import_zod21.z.number().nonnegative(),
-  shippingOption: import_zod21.z.object({ presentmentTitle: import_zod21.z.string(), title: import_zod21.z.string() })
+  shippingOption: import_zod21.z.object({ presentmentTitle: import_zod21.z.string(), title: import_zod21.z.string() }),
+  /** A switch to subscription (STS): the one subscription that charges no initial shipping (L122). */
+  sts: import_zod21.z.literal(true).optional()
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -4542,6 +4549,7 @@ var CABRootSection = CABLayoutSection.extend({
 });
 
 // src/schema/postPurchaseProductView.ts
+var StsMarker = import_zod69.z.literal(true).optional();
 var PostPurchaseProductView = import_zod69.z.union([
   import_zod69.z.object({
     changeset: PostPurchaseProductChangeset.optional(),
@@ -4557,6 +4565,7 @@ var PostPurchaseProductView = import_zod69.z.union([
     }),
     purchaseOptions: PostPurchaseOptions.optional(),
     sections: CABRootSection,
+    sts: StsMarker,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
   import_zod69.z.object({
@@ -4569,6 +4578,7 @@ var PostPurchaseProductView = import_zod69.z.union([
     purchaseOptions: PostPurchaseOptions.optional(),
     /** A choice-level unavailable product keeps its card (values resolve blank); configuration failures send null. */
     sections: CABRootSection.nullable(),
+    sts: StsMarker,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
@@ -4716,102 +4726,129 @@ var HealthResultResponseSchema = import_zod74.z.object({
   successful: import_zod74.z.literal(true)
 });
 
-// src/schema/postPurchaseLifecycle.ts
+// src/schema/postPurchaseLedger.ts
 var import_zod75 = require("zod");
-var Presentation = import_zod75.z.strictObject({
+var CLIENT_LEDGER_MAX_EVENTS = 16;
+var CLIENT_LEDGER_TYPES = [
+  "decision.verdict",
+  "error.flow",
+  "error.schema",
+  "offer.decline",
+  "render.gate",
+  "shouldRender.selectedFlow"
+];
+var ClientLedgerPayloadValueSchema = import_zod75.z.union([import_zod75.z.string().max(256), import_zod75.z.number().finite(), import_zod75.z.boolean()]);
+var ClientLedgerEventSchema = import_zod75.z.strictObject({
+  /** The client's diagnostic id for one Shopify context; `(instance, seq)` names a row. */
+  instance: import_zod75.z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
+  payload: import_zod75.z.record(import_zod75.z.string().regex(/^[A-Za-z][A-Za-z0-9_.()]{0,63}$/), ClientLedgerPayloadValueSchema).refine((payload) => Object.keys(payload).length <= 24, "At most 24 payload members"),
+  phase: import_zod75.z.enum(["render", "shouldRender"]),
+  /** `-1` is the dev-store runtime probe's row (cab-post-purchase `dev-store/runtimeProbe.ts`). */
+  seq: import_zod75.z.number().int().min(-1).max(1e5),
+  /** The client's clock when it observed the row, as the legacy client rows carry it. */
+  ts: import_zod75.z.iso.datetime(),
+  type: import_zod75.z.enum(CLIENT_LEDGER_TYPES)
+});
+var ClientLedgerRequestSchema = import_zod75.z.object({
+  events: import_zod75.z.array(ClientLedgerEventSchema).min(1).max(CLIENT_LEDGER_MAX_EVENTS)
+});
+
+// src/schema/postPurchaseLifecycle.ts
+var import_zod76 = require("zod");
+var Presentation = import_zod76.z.strictObject({
   member: PostPurchaseMemberIdentity,
   selectedProductId: PostPurchaseMemberIdentity.shape.productId.optional(),
   variant: PostPurchaseVariantSelector
 });
 var LifecycleObservationRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
-  eventType: import_zod75.z.enum(["OFFER_VIEWED", "OFFER_TIMER_EXPIRED"]),
+  eventType: import_zod76.z.enum(["OFFER_VIEWED", "OFFER_TIMER_EXPIRED"]),
   presentation: Presentation.nullable(),
   progressRevision: PostPurchaseProgressSchema.shape.revision,
-  requestId: import_zod75.z.uuid()
+  requestId: import_zod76.z.uuid()
 }).strict().refine(
   ({ eventType, presentation }) => eventType !== "OFFER_VIEWED" || presentation !== null,
   "Viewed observations require a presented product"
 );
-var LifecycleObservationResponseSchema = import_zod75.z.object({
-  data: import_zod75.z.strictObject({
+var LifecycleObservationResponseSchema = import_zod76.z.object({
+  data: import_zod76.z.strictObject({
     requestId: LifecycleObservationRequestSchema.shape.requestId,
-    status: import_zod75.z.union([AcceptedEventOutcomeSchema, import_zod75.z.literal("unavailable")])
+    status: import_zod76.z.union([AcceptedEventOutcomeSchema, import_zod76.z.literal("unavailable")])
   }),
-  successful: import_zod75.z.literal(true)
+  successful: import_zod76.z.literal(true)
 });
 
 // src/schema/postPurchaseOffer.ts
-var import_zod76 = require("zod");
+var import_zod77 = require("zod");
 var OfferPreparationRequestSchema = DecideRequestSchema.strict();
-var OfferPreparationResponseSchema = import_zod76.z.object({
-  data: import_zod76.z.object({ attemptedSkips: PostPurchaseSkipTraceSchema.optional(), progress: PostPurchaseProgressSchema }),
-  successful: import_zod76.z.literal(true)
+var OfferPreparationResponseSchema = import_zod77.z.object({
+  data: import_zod77.z.object({ attemptedSkips: PostPurchaseSkipTraceSchema.optional(), progress: PostPurchaseProgressSchema }),
+  successful: import_zod77.z.literal(true)
 });
 
 // src/schema/postPurchaseOfferEligibility.ts
-var import_zod77 = require("zod");
+var import_zod78 = require("zod");
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod77.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod77.z.object({
+var PostPurchaseOfferSkipReason = import_zod78.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod78.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod77.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: import_zod78.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
-var PostPurchaseStsOptions = import_zod77.z.object({ sts: import_zod77.z.boolean().optional() }).strict();
-var PostPurchaseStsContext = import_zod77.z.object({
-  originalLineItems: import_zod77.z.array(
+var PostPurchaseStsOptions = import_zod78.z.object({ sts: import_zod78.z.boolean().optional() }).strict();
+var PostPurchaseStsContext = import_zod78.z.object({
+  originalLineItems: import_zod78.z.array(
     selection2.pick({ productId: true, quantity: true, sellingPlanId: true, variantId: true })
   )
 });
-var PostPurchaseOfferEligibility = import_zod77.z.discriminatedUnion("status", [
-  import_zod77.z.object({
-    members: import_zod77.z.array(
-      import_zod77.z.object({ productId: selection2.shape.productId, productIndex: import_zod77.z.number().int().nonnegative() })
+var PostPurchaseOfferEligibility = import_zod78.z.discriminatedUnion("status", [
+  import_zod78.z.object({
+    members: import_zod78.z.array(
+      import_zod78.z.object({ productId: selection2.shape.productId, productIndex: import_zod78.z.number().int().nonnegative() })
     ),
     /** Present only with STS on: each member switches one original one-time line to subscription. */
-    mode: import_zod77.z.literal("sts").optional(),
-    status: import_zod77.z.literal("retain")
+    mode: import_zod78.z.literal("sts").optional(),
+    status: import_zod78.z.literal("retain")
   }),
-  import_zod77.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod77.z.literal("skip") }),
-  import_zod77.z.object({ reason: import_zod77.z.literal("eligible-sts").optional(), status: import_zod77.z.literal("unavailable") })
+  import_zod78.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod78.z.literal("skip") }),
+  import_zod78.z.object({ reason: import_zod78.z.literal("eligible-sts").optional(), status: import_zod78.z.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts
-var import_zod78 = require("zod");
+var import_zod79 = require("zod");
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = import_zod78.z.strictObject({
+var PostPurchaseOfferPresentation = import_zod79.z.strictObject({
   labels: language2.pick({ declineAll: true, declineThisOffer: true }),
   layout: PostPurchaseSettings.shape.offersLayout,
   sections: CABRootSection.nullable(),
   showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
 });
 var OfferPresentationRequestSchema = DecideRequestSchema.strict();
-var OfferPresentationResponseSchema = import_zod78.z.object({
-  data: import_zod78.z.strictObject({
+var OfferPresentationResponseSchema = import_zod79.z.object({
+  data: import_zod79.z.strictObject({
     presentation: PostPurchaseOfferPresentation.nullable(),
     progress: PostPurchaseProgressSchema.nullable(),
     serverNow: PostPurchaseTimestampSchema
   }),
-  successful: import_zod78.z.literal(true)
+  successful: import_zod79.z.literal(true)
 });
 
 // src/schema/postPurchaseOrderDecision.ts
-var import_zod79 = require("zod");
-var OrderDecisionSchema = import_zod79.z.discriminatedUnion("owner", [
-  import_zod79.z.object({ owner: import_zod79.z.literal("session"), sessionId: PostPurchaseSessionIdSchema }),
-  import_zod79.z.object({ owner: import_zod79.z.literal("release"), sessionId: import_zod79.z.null() })
+var import_zod80 = require("zod");
+var OrderDecisionSchema = import_zod80.z.discriminatedUnion("owner", [
+  import_zod80.z.object({ owner: import_zod80.z.literal("session"), sessionId: PostPurchaseSessionIdSchema }),
+  import_zod80.z.object({ owner: import_zod80.z.literal("release"), sessionId: import_zod80.z.null() })
 ]);
 
 // src/schema/postPurchasePolicy.ts
-var import_zod80 = require("zod");
-var HoldSettingSchema = import_zod80.z.discriminatedUnion("enabled", [
-  import_zod80.z.object({ durationMinutes: import_zod80.z.number().int().min(1).max(60), enabled: import_zod80.z.literal(true) }),
-  import_zod80.z.object({ durationMinutes: import_zod80.z.null(), enabled: import_zod80.z.literal(false) })
+var import_zod81 = require("zod");
+var HoldSettingSchema = import_zod81.z.discriminatedUnion("enabled", [
+  import_zod81.z.object({ durationMinutes: import_zod81.z.number().int().min(1).max(60), enabled: import_zod81.z.literal(true) }),
+  import_zod81.z.object({ durationMinutes: import_zod81.z.null(), enabled: import_zod81.z.literal(false) })
 ]);
-var TimingSettingsSchema = import_zod80.z.object({ flowHold: HoldSettingSchema, shopHold: HoldSettingSchema });
+var TimingSettingsSchema = import_zod81.z.object({ flowHold: HoldSettingSchema, shopHold: HoldSettingSchema });
 var SessionPolicySchema = TimingSettingsSchema.extend({
-  durationMinutes: import_zod80.z.number().int().min(1).max(60).nullable(),
-  source: import_zod80.z.enum(["shop", "flow", "native"])
+  durationMinutes: import_zod81.z.number().int().min(1).max(60).nullable(),
+  source: import_zod81.z.enum(["shop", "flow", "native"])
 }).refine(
   (policy) => {
     const expectedSource = policy.shopHold.enabled ? "shop" : policy.flowHold.enabled ? "flow" : "native";
@@ -4825,8 +4862,8 @@ var SessionPolicySchema = TimingSettingsSchema.extend({
 );
 
 // src/schema/postPurchasePreparationOptions.ts
-var import_zod81 = require("zod");
-var PostPurchasePreparationOptions = import_zod81.z.object({
+var import_zod82 = require("zod");
+var PostPurchasePreparationOptions = import_zod82.z.object({
   choice: PostPurchaseChoice.optional(),
   member: PostPurchaseMemberSelector.strict().optional(),
   quantity: PreparedPostPurchaseProduct.shape.selection.shape.quantity.optional(),
@@ -4838,8 +4875,8 @@ var PostPurchasePreparationOptions = import_zod81.z.object({
 );
 
 // src/schema/postPurchaseProductSettings.ts
-var import_zod82 = require("zod");
-var amount = import_zod82.z.union([import_zod82.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
+var import_zod83 = require("zod");
+var amount = import_zod83.z.union([import_zod83.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
 var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   discountedFrom: true,
   language: true,
@@ -4851,30 +4888,30 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscriptionIsDefault: true,
   upgradeToSubscription: true
 }).extend({
-  advance: import_zod82.z.unknown().default({}),
-  blocks: import_zod82.z.array(import_zod82.z.unknown()).optional(),
+  advance: import_zod83.z.unknown().default({}),
+  blocks: import_zod83.z.array(import_zod83.z.unknown()).optional(),
   discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
-  integrations: import_zod82.z.unknown().default({}),
+  integrations: import_zod83.z.unknown().default({}),
   shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
-  styles: import_zod82.z.unknown().default({}),
+  styles: import_zod83.z.unknown().default({}),
   subImages: PostPurchaseSettings.shape.subImages.catch(null),
-  subscription: import_zod82.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
+  subscription: import_zod83.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
 // src/schema/postPurchaseRecovery.ts
-var import_zod83 = require("zod");
-var RecoveredFollowupsSchema = import_zod83.z.strictObject({
-  acceptedEvent: import_zod83.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]).nullable(),
-  acceptedMetafield: import_zod83.z.union([AcceptedMetafieldOutcomeSchema, import_zod83.z.literal("attempted")]).nullable()
+var import_zod84 = require("zod");
+var RecoveredFollowupsSchema = import_zod84.z.strictObject({
+  acceptedEvent: import_zod84.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]).nullable(),
+  acceptedMetafield: import_zod84.z.union([AcceptedMetafieldOutcomeSchema, import_zod84.z.literal("attempted")]).nullable()
 });
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
-var PurchaseRecoveryResponseSchema = import_zod83.z.object({
-  data: import_zod83.z.object({
+var PurchaseRecoveryResponseSchema = import_zod84.z.object({
+  data: import_zod84.z.object({
     /**
      * Strict, so a client pinned before a new optional field rejects a reply that carries it rather than
      * stripping it. Release the client before rebuy-api starts emitting a field added here.
      */
-    operation: import_zod83.z.object({
+    operation: import_zod84.z.object({
       /** Absent from a rebuy-api that predates it. */
       followups: RecoveredFollowupsSchema.optional(),
       observation: RecordedPurchaseObservationSchema.nullable(),
@@ -4897,41 +4934,41 @@ var PurchaseRecoveryResponseSchema = import_zod83.z.object({
     ).nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
-  successful: import_zod83.z.literal(true)
+  successful: import_zod84.z.literal(true)
 });
 
 // src/schema/postPurchaseReleaseClaim.ts
-var import_zod84 = require("zod");
+var import_zod85 = require("zod");
 var ReleaseClaimRequestSchema = ReleaseAuthorityRequestSchema;
-var ReleaseClaimResponseSchema = import_zod84.z.object({
-  data: import_zod84.z.discriminatedUnion("status", [
-    import_zod84.z.object({ status: import_zod84.z.literal("release-permitted") }),
+var ReleaseClaimResponseSchema = import_zod85.z.object({
+  data: import_zod85.z.discriminatedUnion("status", [
+    import_zod85.z.object({ status: import_zod85.z.literal("release-permitted") }),
     PendingReleaseAuthoritySchema,
     ReadyReleaseAuthoritySchema
   ]),
-  successful: import_zod84.z.literal(true)
+  successful: import_zod85.z.literal(true)
 });
 
 // src/schema/postPurchaseSelection.ts
-var import_zod85 = require("zod");
+var import_zod86 = require("zod");
 var SelectionClaimsSchema = DecideRequestSchema.extend({
   appId: PostPurchaseAppIdSchema,
   entry: DecisionEntrySchema,
-  iss: import_zod85.z.literal("rebuy-api"),
-  purpose: import_zod85.z.literal("post-purchase-selection")
+  iss: import_zod86.z.literal("rebuy-api"),
+  purpose: import_zod86.z.literal("post-purchase-selection")
 });
 var SessionStartRequestSchema = DecideRequestSchema.extend({
-  selectionToken: import_zod85.z.string().min(1).max(8192).optional()
+  selectionToken: import_zod86.z.string().min(1).max(8192).optional()
 }).strict();
 
 // src/schema/postPurchaseSession.ts
-var import_zod86 = require("zod");
+var import_zod87 = require("zod");
 var SessionIdentitySchema = DecideRequestSchema.extend({ appId: PostPurchaseAppIdSchema });
-var SessionOrderTimingSchema = import_zod86.z.object({
+var SessionOrderTimingSchema = import_zod87.z.object({
   nativeDeadline: PostPurchaseTimestampSchema,
   orderCreatedAt: PostPurchaseTimestampSchema,
   orderId: PostPurchaseOrderIdSchema,
-  timingSource: import_zod86.z.literal("shopify-order-created-at")
+  timingSource: import_zod87.z.literal("shopify-order-created-at")
 });
 var ReadySessionTimingSchema = SessionOrderTimingSchema.extend({
   deadline: PostPurchaseTimestampSchema,
@@ -4948,33 +4985,39 @@ var ReadySessionTimingSchema = SessionOrderTimingSchema.extend({
   message: "deadline must not exceed nativeDeadline",
   path: ["deadline"]
 });
-var SessionStartResponseSchema = import_zod86.z.object({
-  data: import_zod86.z.object({
-    phase: import_zod86.z.literal("render"),
+var SessionStartResponseSchema = import_zod87.z.object({
+  data: import_zod87.z.object({
+    phase: import_zod87.z.literal("render"),
     serverNow: PostPurchaseTimestampSchema,
     session: ReadySessionTimingSchema,
-    workflowPhase: import_zod86.z.literal("start")
+    workflowPhase: import_zod87.z.literal("start")
   }),
-  successful: import_zod86.z.literal(true)
+  successful: import_zod87.z.literal(true)
+});
+var PostPurchaseOrderPendingSchema = import_zod87.z.object({
+  errors: import_zod87.z.array(import_zod87.z.object({ message: import_zod87.z.string() })),
+  message: import_zod87.z.string(),
+  reason: import_zod87.z.literal("order-pending"),
+  successful: import_zod87.z.literal(false)
 });
 
 // src/schema/postPurchaseShadow.ts
-var import_zod87 = require("zod");
-var PostPurchaseShadowSelectionSchema = import_zod87.z.discriminatedUnion("verdict", [
-  import_zod87.z.object({ entry: DecisionEntrySchema, verdict: import_zod87.z.literal("render") }),
-  import_zod87.z.object({ verdict: import_zod87.z.literal("skip") })
+var import_zod88 = require("zod");
+var PostPurchaseShadowSelectionSchema = import_zod88.z.discriminatedUnion("verdict", [
+  import_zod88.z.object({ entry: DecisionEntrySchema, verdict: import_zod88.z.literal("render") }),
+  import_zod88.z.object({ verdict: import_zod88.z.literal("skip") })
 ]);
-var PostPurchaseShadowReportFields = import_zod87.z.object({
-  differences: import_zod87.z.array(import_zod87.z.enum(["verdict", "entry", "targeting", "incomplete-capture", "unsupported-configuration"])).refine((differences) => new Set(differences).size === differences.length, {
+var PostPurchaseShadowReportFields = import_zod88.z.object({
+  differences: import_zod88.z.array(import_zod88.z.enum(["verdict", "entry", "targeting", "incomplete-capture", "unsupported-configuration"])).refine((differences) => new Set(differences).size === differences.length, {
     message: "differences must not contain duplicate entries"
   }),
   legacySelection: PostPurchaseShadowSelectionSchema,
-  phase: import_zod87.z.literal("shouldRender"),
-  sampleId: import_zod87.z.string(),
+  phase: import_zod88.z.literal("shouldRender"),
+  sampleId: import_zod88.z.string(),
   serverSelection: PostPurchaseShadowSelectionSchema.optional(),
-  status: import_zod87.z.enum(["match", "diverged", "incomplete"]),
-  targetingFlowIds: import_zod87.z.array(import_zod87.z.number().int().positive()),
-  workflowPhase: import_zod87.z.literal("decide")
+  status: import_zod88.z.enum(["match", "diverged", "incomplete"]),
+  targetingFlowIds: import_zod88.z.array(import_zod88.z.number().int().positive()),
+  workflowPhase: import_zod88.z.literal("decide")
 });
 var PostPurchaseShadowReportSchema = PostPurchaseShadowReportFields.refine(
   (report) => report.status !== "match" || report.differences.length === 0,
@@ -4988,13 +5031,14 @@ var PostPurchaseShadowReportSchema = PostPurchaseShadowReportFields.refine(
 });
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod88 = require("zod");
+var import_zod89 = require("zod");
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod88.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod89.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
-    ({ discount, shipping, subscription }) => (discount.type !== "none" || discount.amount === 0) && shipping.amount === subscription.initialShippingPrice && shipping.amount === subscription.recurringShippingPrice && (shipping.type !== "free" || shipping.amount === 0)
+    ({ discount, shipping, subscription }) => (discount.type !== "none" || discount.amount === 0) && // A switch to subscription charges no initial shipping (L122); any other subscription charges it.
+    subscription.initialShippingPrice === (subscription.sts ? 0 : shipping.amount) && shipping.amount === subscription.recurringShippingPrice && (shipping.type !== "free" || shipping.amount === 0)
   )
 });
 var readPostPurchaseSubscription = (prepared) => {
@@ -5003,93 +5047,93 @@ var readPostPurchaseSubscription = (prepared) => {
 };
 
 // src/schema/postPurchaseVariantDefault.ts
-var import_zod89 = require("zod");
+var import_zod90 = require("zod");
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: import_zod89.z.string().nullable(),
-  inventoryPolicy: import_zod89.z.string(),
-  inventoryQuantity: import_zod89.z.number()
+  inventoryManagement: import_zod90.z.string().nullable(),
+  inventoryPolicy: import_zod90.z.string(),
+  inventoryQuantity: import_zod90.z.number()
 });
-var options = import_zod89.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod89.z.object({
+var options = import_zod90.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod90.z.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: import_zod89.z.array(variant)
+  variants: import_zod90.z.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = import_zod89.z.record(import_zod89.z.string(), import_zod89.z.array(import_zod89.z.string())).default({});
-var PostPurchaseOriginalVariants = import_zod89.z.array(
-  import_zod89.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = import_zod90.z.record(import_zod90.z.string(), import_zod90.z.array(import_zod90.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod90.z.array(
+  import_zod90.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = import_zod89.z.array(
-  import_zod89.z.object({ id: PostPurchaseProductId, options, variants: import_zod89.z.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = import_zod90.z.array(
+  import_zod90.z.object({ id: PostPurchaseProductId, options, variants: import_zod90.z.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-var import_zod90 = require("zod");
-var PostPurchaseVariantDefaultContext = import_zod90.z.object({
-  enrichedLineItems: import_zod90.z.unknown().optional(),
+var import_zod91 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod91.z.object({
+  enrichedLineItems: import_zod91.z.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
 // src/schema/shopConfig.ts
-var import_zod91 = require("zod");
-var ShopConfig = import_zod91.z.object({
-  activeExperiments: import_zod91.z.array(
-    import_zod91.z.object({
-      data: import_zod91.z.array(
-        import_zod91.z.object({
-          aliasName: import_zod91.z.string(),
-          cssInput: import_zod91.z.string().nullish(),
-          elementId: import_zod91.z.coerce.number(),
-          id: import_zod91.z.coerce.number(),
-          javascriptInput: import_zod91.z.string().nullish(),
-          traffic: import_zod91.z.coerce.number()
+var import_zod92 = require("zod");
+var ShopConfig = import_zod92.z.object({
+  activeExperiments: import_zod92.z.array(
+    import_zod92.z.object({
+      data: import_zod92.z.array(
+        import_zod92.z.object({
+          aliasName: import_zod92.z.string(),
+          cssInput: import_zod92.z.string().nullish(),
+          elementId: import_zod92.z.coerce.number(),
+          id: import_zod92.z.coerce.number(),
+          javascriptInput: import_zod92.z.string().nullish(),
+          traffic: import_zod92.z.coerce.number()
         })
       ),
-      id: import_zod91.z.coerce.number(),
-      name: import_zod91.z.string(),
-      pageTarget: import_zod91.z.string().nullable(),
-      pageTargetUrl: import_zod91.z.string().nullable(),
-      placeholderId: import_zod91.z.coerce.number().nullable(),
-      type: import_zod91.z.string()
+      id: import_zod92.z.coerce.number(),
+      name: import_zod92.z.string(),
+      pageTarget: import_zod92.z.string().nullable(),
+      pageTargetUrl: import_zod92.z.string().nullable(),
+      placeholderId: import_zod92.z.coerce.number().nullable(),
+      type: import_zod92.z.string()
     })
   ),
-  activePackages: import_zod91.z.array(
-    import_zod91.z.object({
-      cancelledAt: import_zod91.z.string().nullable(),
-      id: import_zod91.z.number(),
-      installedAt: import_zod91.z.string().nullable(),
-      isActive: import_zod91.z.boolean(),
-      isBillable: import_zod91.z.boolean(),
-      packageId: import_zod91.z.number(),
-      packageName: import_zod91.z.string(),
-      shortName: import_zod91.z.string(),
-      trialDays: import_zod91.z.number(),
-      uninstalledAt: import_zod91.z.string().nullable()
+  activePackages: import_zod92.z.array(
+    import_zod92.z.object({
+      cancelledAt: import_zod92.z.string().nullable(),
+      id: import_zod92.z.number(),
+      installedAt: import_zod92.z.string().nullable(),
+      isActive: import_zod92.z.boolean(),
+      isBillable: import_zod92.z.boolean(),
+      packageId: import_zod92.z.number(),
+      packageName: import_zod92.z.string(),
+      shortName: import_zod92.z.string(),
+      trialDays: import_zod92.z.number(),
+      uninstalledAt: import_zod92.z.string().nullable()
     })
   ),
-  apiKey: import_zod91.z.string(),
-  billingVersion: import_zod91.z.string().nullable(),
-  cacheKey: import_zod91.z.coerce.number(),
-  carousel: import_zod91.z.enum(["flickity", "splide"]),
-  currency: import_zod91.z.string(),
-  currencySymbol: import_zod91.z.string(),
-  domain: import_zod91.z.string(),
-  enabledJquery: import_zod91.z.boolean(),
-  enabledPresentmentCurrencies: import_zod91.z.array(import_zod91.z.string()),
-  hasSmartCollectionsEnabled: import_zod91.z.boolean(),
-  hasSmartSearchEnabled: import_zod91.z.boolean(),
-  id: import_zod91.z.coerce.number(),
-  integrations: import_zod91.z.record(
-    import_zod91.z.enum([
+  apiKey: import_zod92.z.string(),
+  billingVersion: import_zod92.z.string().nullable(),
+  cacheKey: import_zod92.z.coerce.number(),
+  carousel: import_zod92.z.enum(["flickity", "splide"]),
+  currency: import_zod92.z.string(),
+  currencySymbol: import_zod92.z.string(),
+  domain: import_zod92.z.string(),
+  enabledJquery: import_zod92.z.boolean(),
+  enabledPresentmentCurrencies: import_zod92.z.array(import_zod92.z.string()),
+  hasSmartCollectionsEnabled: import_zod92.z.boolean(),
+  hasSmartSearchEnabled: import_zod92.z.boolean(),
+  id: import_zod92.z.coerce.number(),
+  integrations: import_zod92.z.record(
+    import_zod92.z.enum([
       "attentive",
       "judgeme",
       "junip",
@@ -5102,170 +5146,170 @@ var ShopConfig = import_zod91.z.object({
       "stamped",
       "yotpo"
     ]),
-    import_zod91.z.union([import_zod91.z.boolean(), import_zod91.z.unknown()])
+    import_zod92.z.union([import_zod92.z.boolean(), import_zod92.z.unknown()])
   ),
-  markets: import_zod91.z.object({
-    enabled: import_zod91.z.boolean()
+  markets: import_zod92.z.object({
+    enabled: import_zod92.z.boolean()
   }),
-  monetize: import_zod91.z.object({
-    publisherKey: import_zod91.z.string().nullable()
+  monetize: import_zod92.z.object({
+    publisherKey: import_zod92.z.string().nullable()
   }).nullish(),
-  moneyFormat: import_zod91.z.string(),
-  myshopifyDomain: import_zod91.z.string(),
-  primaryLocale: import_zod91.z.string(),
-  productGroupsEnabled: import_zod91.z.enum(["no", "yes"]).transform((value) => value === "yes"),
-  rechargeCustomDomain: import_zod91.z.string().nullable(),
-  sellingPlansEnabled: import_zod91.z.boolean(),
-  shopId: import_zod91.z.number(),
-  shopifySellingPlansEnabled: import_zod91.z.boolean(),
-  shopName: import_zod91.z.string(),
-  storefrontAccessToken: import_zod91.z.string().nullable(),
-  useRebuyIcons: import_zod91.z.boolean()
+  moneyFormat: import_zod92.z.string(),
+  myshopifyDomain: import_zod92.z.string(),
+  primaryLocale: import_zod92.z.string(),
+  productGroupsEnabled: import_zod92.z.enum(["no", "yes"]).transform((value) => value === "yes"),
+  rechargeCustomDomain: import_zod92.z.string().nullable(),
+  sellingPlansEnabled: import_zod92.z.boolean(),
+  shopId: import_zod92.z.number(),
+  shopifySellingPlansEnabled: import_zod92.z.boolean(),
+  shopName: import_zod92.z.string(),
+  storefrontAccessToken: import_zod92.z.string().nullable(),
+  useRebuyIcons: import_zod92.z.boolean()
 });
 
 // src/schema/userConfig.ts
-var import_zod92 = require("zod");
-var UserConfig = import_zod92.z.object({
+var import_zod93 = require("zod");
+var UserConfig = import_zod93.z.object({
   shop: ShopConfig,
   /**
    * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
    * which resolves the apiKey for every offers/monetize/analytics/gift request.
    */
   smartCart: SmartCartConfig.nullish().catch(void 0),
-  smartFlows: import_zod92.z.array(import_zod92.z.unknown())
+  smartFlows: import_zod93.z.array(import_zod93.z.unknown())
 });
 
 // src/schema/widgetData.ts
-var import_zod101 = require("zod");
+var import_zod102 = require("zod");
 
 // src/schema/widgets/abTestingPlaceholder.ts
-var import_zod93 = require("zod");
-var ABTestingPlaceholder = import_zod93.z.looseObject({
-  type: import_zod93.z.literal("placeholder")
+var import_zod94 = require("zod");
+var ABTestingPlaceholder = import_zod94.z.looseObject({
+  type: import_zod94.z.literal("placeholder")
 });
 
 // src/schema/widgets/checkoutExtension.ts
-var import_zod94 = require("zod");
-var CheckoutExtension = import_zod94.z.looseObject({
-  type: import_zod94.z.literal(WidgetType.shopify_checkout_extension).default(WidgetType.shopify_checkout_extension)
+var import_zod95 = require("zod");
+var CheckoutExtension = import_zod95.z.looseObject({
+  type: import_zod95.z.literal(WidgetType.shopify_checkout_extension).default(WidgetType.shopify_checkout_extension)
 });
 
 // src/schema/widgets/contentBlock.ts
-var import_zod95 = require("zod");
-var ContentBlockV1 = import_zod95.z.object({
-  blockSpacing: import_zod95.z.enum(spacings).optional(),
-  imageBlocks: import_zod95.z.union([
-    import_zod95.z.array(
-      import_zod95.z.object({
-        altText: import_zod95.z.string().nullable(),
-        description: import_zod95.z.string().nullable(),
-        id: import_zod95.z.uuid(),
-        imagePlacement: import_zod95.z.enum(["top", "right", "bottom", "left"]),
-        imageSize: import_zod95.z.number(),
-        imageUrl: import_zod95.z.url(),
-        textAlignment: import_zod95.z.enum(["left", "center", "right"]),
+var import_zod96 = require("zod");
+var ContentBlockV1 = import_zod96.z.object({
+  blockSpacing: import_zod96.z.enum(spacings).optional(),
+  imageBlocks: import_zod96.z.union([
+    import_zod96.z.array(
+      import_zod96.z.object({
+        altText: import_zod96.z.string().nullable(),
+        description: import_zod96.z.string().nullable(),
+        id: import_zod96.z.uuid(),
+        imagePlacement: import_zod96.z.enum(["top", "right", "bottom", "left"]),
+        imageSize: import_zod96.z.number(),
+        imageUrl: import_zod96.z.url(),
+        textAlignment: import_zod96.z.enum(["left", "center", "right"]),
         /** Inline scale only: an image caption can never be a block-level heading. */
-        textSize: import_zod95.z.enum(inlineTextSizeNames)
+        textSize: import_zod96.z.enum(inlineTextSizeNames)
       })
     ),
-    import_zod95.z.strictObject({}).transform(() => [])
+    import_zod96.z.strictObject({}).transform(() => [])
   ]).optional(),
-  imageLayout: import_zod95.z.enum(["row", "column"]).optional(),
-  language: import_zod95.z.object({
-    description: import_zod95.z.string(),
-    superTitle: import_zod95.z.string(),
-    title: import_zod95.z.string()
+  imageLayout: import_zod96.z.enum(["row", "column"]).optional(),
+  language: import_zod96.z.object({
+    description: import_zod96.z.string(),
+    superTitle: import_zod96.z.string(),
+    title: import_zod96.z.string()
   }),
-  previewMode: import_zod95.z.boolean(),
-  type: import_zod95.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block),
-  version: import_zod95.z.literal(1)
+  previewMode: import_zod96.z.boolean(),
+  type: import_zod96.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block),
+  version: import_zod96.z.literal(1)
 });
-var ContentBlock = import_zod95.z.discriminatedUnion("version", [
+var ContentBlock = import_zod96.z.discriminatedUnion("version", [
   ContentBlockV1,
   CABRootSection.extend({
-    type: import_zod95.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block)
+    type: import_zod96.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block)
   })
 ]);
 
 // src/schema/widgets/giftWithPurchase.ts
-var import_zod96 = require("zod");
-var GiftWithPurchase = import_zod96.z.looseObject({
-  type: import_zod96.z.literal(WidgetType.gift_with_purchase).default(WidgetType.gift_with_purchase)
+var import_zod97 = require("zod");
+var GiftWithPurchase = import_zod97.z.looseObject({
+  type: import_zod97.z.literal(WidgetType.gift_with_purchase).default(WidgetType.gift_with_purchase)
 });
 
 // src/schema/widgets/lineItemEditor.ts
-var import_zod97 = require("zod");
-var LineItemEditorSwitchLanguageV1 = import_zod97.z.object({
-  downgradeToOneTimeLabel: import_zod97.z.string().optional(),
+var import_zod98 = require("zod");
+var LineItemEditorSwitchLanguageV1 = import_zod98.z.object({
+  downgradeToOneTimeLabel: import_zod98.z.string().optional(),
   /** Frequency-option template (`{{frequency}}`/`{{interval}}`) for the plan select. */
-  subscriptionOptionLabel: import_zod97.z.string().optional(),
-  upgradeToSubscriptionLabel: import_zod97.z.string().optional(),
-  upgradeToSubscriptionWithoutDiscountLabel: import_zod97.z.string().optional()
+  subscriptionOptionLabel: import_zod98.z.string().optional(),
+  upgradeToSubscriptionLabel: import_zod98.z.string().optional(),
+  upgradeToSubscriptionWithoutDiscountLabel: import_zod98.z.string().optional()
 });
-var LineItemEditorV1 = import_zod97.z.object({
+var LineItemEditorV1 = import_zod98.z.object({
   /** Legacy `getStyles` button style; the converter carries a valid kind, defaulting to `plain`. */
-  button: import_zod97.z.object({ kind: import_zod97.z.enum(["plain", "primary", "secondary"]).optional() }).optional(),
-  previewMode: import_zod97.z.boolean().optional(),
-  switchToSubscription: import_zod97.z.object({
-    disableDowngrade: import_zod97.z.boolean().optional(),
+  button: import_zod98.z.object({ kind: import_zod98.z.enum(["plain", "primary", "secondary"]).optional() }).optional(),
+  previewMode: import_zod98.z.boolean().optional(),
+  switchToSubscription: import_zod98.z.object({
+    disableDowngrade: import_zod98.z.boolean().optional(),
     language: LineItemEditorSwitchLanguageV1.optional()
   }).optional(),
-  switchToSubscriptionEnabled: import_zod97.z.boolean().optional(),
-  tracking: import_zod97.z.object({
-    enableAttribution: import_zod97.z.boolean().optional(),
-    enableSource: import_zod97.z.boolean().optional(),
-    enableWidget: import_zod97.z.boolean().optional()
+  switchToSubscriptionEnabled: import_zod98.z.boolean().optional(),
+  tracking: import_zod98.z.object({
+    enableAttribution: import_zod98.z.boolean().optional(),
+    enableSource: import_zod98.z.boolean().optional(),
+    enableWidget: import_zod98.z.boolean().optional()
   }).optional(),
-  type: import_zod97.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor),
-  version: import_zod97.z.literal(1)
+  type: import_zod98.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor),
+  version: import_zod98.z.literal(1)
 });
-var LineItemEditor = import_zod97.z.discriminatedUnion("version", [
+var LineItemEditor = import_zod98.z.discriminatedUnion("version", [
   LineItemEditorV1,
   CABRootSection.extend({
-    type: import_zod97.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor)
+    type: import_zod98.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor)
   })
 ]);
 
 // src/schema/widgets/progressBar.ts
-var import_zod98 = require("zod");
-var ProgressBar = import_zod98.z.looseObject({
-  type: import_zod98.z.literal(WidgetType.ui_extension_progress_bar).default(WidgetType.ui_extension_progress_bar)
+var import_zod99 = require("zod");
+var ProgressBar = import_zod99.z.looseObject({
+  type: import_zod99.z.literal(WidgetType.ui_extension_progress_bar).default(WidgetType.ui_extension_progress_bar)
 });
 
 // src/schema/widgets/rebuyButton.ts
-var import_zod99 = require("zod");
-var RebuyButtonV1 = import_zod99.z.looseObject({
-  type: import_zod99.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button),
-  version: import_zod99.z.literal(1)
+var import_zod100 = require("zod");
+var RebuyButtonV1 = import_zod100.z.looseObject({
+  type: import_zod100.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button),
+  version: import_zod100.z.literal(1)
 });
-var RebuyButton = import_zod99.z.discriminatedUnion("version", [
+var RebuyButton = import_zod100.z.discriminatedUnion("version", [
   RebuyButtonV1,
   CABRootSection.extend({
-    type: import_zod99.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button)
+    type: import_zod100.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button)
   })
 ]);
 
 // src/schema/widgets/rebuyMonetize.ts
-var import_zod100 = require("zod");
-var RebuyMonetize = import_zod100.z.looseObject({
-  type: import_zod100.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad)
+var import_zod101 = require("zod");
+var RebuyMonetize = import_zod101.z.looseObject({
+  type: import_zod101.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad)
 });
-var RebuyMonetizeV1 = import_zod100.z.object({
-  name: import_zod100.z.string().nullable().optional(),
-  previewMode: import_zod100.z.boolean().optional(),
+var RebuyMonetizeV1 = import_zod101.z.object({
+  name: import_zod101.z.string().nullable().optional(),
+  previewMode: import_zod101.z.boolean().optional(),
   /** Privacy Policy footer href → the marker section's `privacyPolicyUrl`. */
-  privacyPolicyUrl: import_zod100.z.string().nullable().optional(),
+  privacyPolicyUrl: import_zod101.z.string().nullable().optional(),
   /** Ads-taxonomy sub-vertical id — one of the admin Monetize editor's two configurables. */
-  subVertical: import_zod100.z.string().nullable().optional(),
-  tracking: import_zod100.z.object({
-    enableAttribution: import_zod100.z.boolean().optional(),
-    enableSource: import_zod100.z.boolean().optional(),
-    enableWidget: import_zod100.z.boolean().optional()
+  subVertical: import_zod101.z.string().nullable().optional(),
+  tracking: import_zod101.z.object({
+    enableAttribution: import_zod101.z.boolean().optional(),
+    enableSource: import_zod101.z.boolean().optional(),
+    enableWidget: import_zod101.z.boolean().optional()
   }).optional(),
-  type: import_zod100.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad),
-  version: import_zod100.z.literal(1),
+  type: import_zod101.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad),
+  version: import_zod101.z.literal(1),
   /** Ads-taxonomy vertical id — one of the admin Monetize editor's two configurables. */
-  vertical: import_zod100.z.string().nullable().optional()
+  vertical: import_zod101.z.string().nullable().optional()
 });
 
 // src/schema/widgetData.ts
@@ -5279,7 +5323,7 @@ var extensionWidgetTypes = [
   WidgetType.ui_extension_line_item_editor,
   WidgetType.ui_extension_progress_bar
 ];
-var WidgetData = import_zod101.z.discriminatedUnion("type", [
+var WidgetData = import_zod102.z.discriminatedUnion("type", [
   ABTestingPlaceholder,
   CheckoutExtension,
   ContentBlock,
@@ -5639,36 +5683,36 @@ var SWITCH_LABELS = {
 };
 
 // src/schema/widgets/post-purchase-offer/postPurchaseOffer.ts
-var import_zod103 = require("zod");
+var import_zod104 = require("zod");
 
 // src/schema/widgets/post-purchase-offer/postPurchaseWidget.ts
-var import_zod102 = require("zod");
-var PostPurchaseWidgetLinkedFlow = import_zod102.z.object({
-  id: import_zod102.z.number(),
-  name: import_zod102.z.string()
-});
-var PostPurchaseWidget = import_zod102.z.object({
-  classification: import_zod102.z.literal("post_purchase_offer_page").default("post_purchase_offer_page"),
-  createdAtTime: import_zod102.z.iso.datetime({ offset: true }).optional(),
-  customEndpointName: import_zod102.z.string().nullish(),
-  id: import_zod102.z.number().default(0),
-  lastViewed: import_zod102.z.iso.datetime({ offset: true }).nullish(),
-  linkedCustomEndpointId: import_zod102.z.number().nullish(),
-  linkedFlows: import_zod102.z.array(PostPurchaseWidgetLinkedFlow).optional(),
-  name: import_zod102.z.string().default(""),
-  owner: import_zod102.z.number().nullish(),
+var import_zod103 = require("zod");
+var PostPurchaseWidgetLinkedFlow = import_zod103.z.object({
+  id: import_zod103.z.number(),
+  name: import_zod103.z.string()
+});
+var PostPurchaseWidget = import_zod103.z.object({
+  classification: import_zod103.z.literal("post_purchase_offer_page").default("post_purchase_offer_page"),
+  createdAtTime: import_zod103.z.iso.datetime({ offset: true }).optional(),
+  customEndpointName: import_zod103.z.string().nullish(),
+  id: import_zod103.z.number().default(0),
+  lastViewed: import_zod103.z.iso.datetime({ offset: true }).nullish(),
+  linkedCustomEndpointId: import_zod103.z.number().nullish(),
+  linkedFlows: import_zod103.z.array(PostPurchaseWidgetLinkedFlow).optional(),
+  name: import_zod103.z.string().default(""),
+  owner: import_zod103.z.number().nullish(),
   settings: PostPurchaseSettings
 });
 
 // src/schema/widgets/post-purchase-offer/postPurchaseOffer.ts
-var PostPurchaseOffer = import_zod103.z.discriminatedUnion("successful", [
-  import_zod103.z.strictObject({
-    errors: import_zod103.z.array(import_zod103.z.object({ message: import_zod103.z.string() })),
-    message: import_zod103.z.string(),
-    successful: import_zod103.z.literal(false)
+var PostPurchaseOffer = import_zod104.z.discriminatedUnion("successful", [
+  import_zod104.z.strictObject({
+    errors: import_zod104.z.array(import_zod104.z.object({ message: import_zod104.z.string() })),
+    message: import_zod104.z.string(),
+    successful: import_zod104.z.literal(false)
   }),
-  import_zod103.z.strictObject({
-    successful: import_zod103.z.literal(true),
+  import_zod104.z.strictObject({
+    successful: import_zod104.z.literal(true),
     widget: PostPurchaseWidget
   })
 ]);