@rebuy/rebuy 3.52.0 → 3.53.0

package/dist/index.cjs

@@ -235,6 +235,8 @@ __export(src_exports, {
   PostPurchaseShadowSelectionSchema: () => PostPurchaseShadowSelectionSchema,
   PostPurchaseSkipReasonSchema: () => PostPurchaseSkipReasonSchema,
   PostPurchaseSkipTraceSchema: () => PostPurchaseSkipTraceSchema,
+  PostPurchaseStsContext: () => PostPurchaseStsContext,
+  PostPurchaseStsOptions: () => PostPurchaseStsOptions,
   PostPurchaseSubscriptionDisplay: () => PostPurchaseSubscriptionDisplay,
   PostPurchaseSubscriptionTerms: () => PostPurchaseSubscriptionTerms,
   PostPurchaseTimestampSchema: () => PostPurchaseTimestampSchema,
@@ -326,6 +328,11 @@ __export(src_exports, {
   SmartCartTierExclusion: () => SmartCartTierExclusion,
   SmartCartTierProduct: () => SmartCartTierProduct,
   Spacing: () => Spacing,
+  StsCompensationProgressSchema: () => StsCompensationProgressSchema,
+  StsProgressSchema: () => StsProgressSchema,
+  StsRefundProgressSchema: () => StsRefundProgressSchema,
+  StsReviewProgressSchema: () => StsReviewProgressSchema,
+  StsReviewReasonSchema: () => StsReviewReasonSchema,
   TextAlignment: () => TextAlignment,
   TextBlock: () => TextBlock,
   TextColorName: () => TextColorName,
@@ -336,11 +343,6 @@ __export(src_exports, {
   TiptapParagraph: () => TiptapParagraph,
   TiptapText: () => TiptapText,
   UI_LABELS: () => UI_LABELS,
-  UpgradeCompensationProgressSchema: () => UpgradeCompensationProgressSchema,
-  UpgradeProgressSchema: () => UpgradeProgressSchema,
-  UpgradeRefundProgressSchema: () => UpgradeRefundProgressSchema,
-  UpgradeReviewProgressSchema: () => UpgradeReviewProgressSchema,
-  UpgradeReviewReasonSchema: () => UpgradeReviewReasonSchema,
   UserConfig: () => UserConfig,
   VariableEffect: () => VariableEffect,
   VariableType: () => VariableType,
@@ -1784,9 +1786,9 @@ var import_zod18 = require("zod");
 var import_zod9 = require("zod");
 var PostPurchaseProductGallery = import_zod9.z.object({
   /**
-   * The product had more than one image before `images` was capped at the sub-image limit, so a
-   * renderer shows the thumbnail row even when the cap leaves one image (legacy checks the count
-   * before slicing). Older replies omit it; fall back to `images.length > 1`.
+   * Show the thumbnail row: the product had more than one image before `images` was capped at the
+   * sub-image limit, and that limit allows at least one thumbnail. It stays true when the cap leaves one
+   * image (legacy checks the count before slicing). Older replies omit it; fall back to `images.length > 1`.
    */
   hasMultiple: import_zod9.z.boolean().optional(),
   images: import_zod9.z.array(
@@ -2914,7 +2916,7 @@ var PostPurchaseProductChangeset = import_zod23.z.object({
 });
 
 // src/schema/postPurchaseAdmission.ts
-var PurchaseAdmissionModeSchema = import_zod24.z.enum(["purchase", "upgrade"]);
+var PurchaseAdmissionModeSchema = import_zod24.z.enum(["purchase", "sts"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
 var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = import_zod24.z.object({
@@ -2936,8 +2938,8 @@ var PurchaseExpectedSchema = import_zod24.z.object({
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
   "Captured member requires progress"
 ).refine(
-  ({ mode, selection: { sellingPlanId } }) => mode !== "upgrade" || sellingPlanId !== void 0,
-  "An upgrade selects a subscription"
+  ({ mode, selection: { sellingPlanId } }) => mode !== "sts" || sellingPlanId !== void 0,
+  "An STS selects a subscription"
 ).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection3 }) => {
   const [change, shipping] = changeset.changes;
   if (selection3.sellingPlanId === void 0)
@@ -2953,7 +2955,7 @@ var PurchaseReceiptSchema = import_zod24.z.object({
   changesetToken: import_zod24.z.string().min(1),
   mode: PurchaseAdmissionModeSchema.optional(),
   operationId: import_zod24.z.uuid(),
-  /** The server-bound one-time line an upgrade refunds; its quantity is the order's, not the selection's. */
+  /** The server-bound one-time line an STS refunds; its quantity is the order's, not the selection's. */
   originalLine: import_zod24.z.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
   requiresSubscriptionConsent: import_zod24.z.boolean(),
   selection
@@ -2961,8 +2963,8 @@ var PurchaseReceiptSchema = import_zod24.z.object({
   ({ requiresSubscriptionConsent, selection: selection3 }) => requiresSubscriptionConsent === (selection3.sellingPlanId !== void 0),
   "Receipt consent must match its selected plan"
 ).refine(
-  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "upgrade" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
-  "An upgrade Receipt binds the original line of its subscribed variant, and only an upgrade does"
+  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "sts" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
+  "An STS Receipt binds the original line of its subscribed variant, and only an STS does"
 );
 var PurchaseResponseSchema = import_zod24.z.object({ data: PurchaseReceiptSchema, successful: import_zod24.z.literal(true) });
 
@@ -3288,24 +3290,24 @@ var PurchaseObservationResponseSchema = import_zod41.z.object({
   successful: import_zod41.z.literal(true)
 });
 
-// src/schema/postPurchaseUpgrade.ts
+// src/schema/postPurchaseSts.ts
 var import_zod42 = require("zod");
 var AttemptSchema2 = import_zod42.z.strictObject({ attemptedAt: PostPurchaseTimestampSchema, status: import_zod42.z.literal("attempted") });
 var FinishedSchema = AttemptSchema2.extend({ finishedAt: PostPurchaseTimestampSchema });
-var UpgradeRefundProgressSchema = import_zod42.z.union([
+var StsRefundProgressSchema = import_zod42.z.union([
   AttemptSchema2,
   FinishedSchema.extend({ refundId: import_zod42.z.string().min(1), status: import_zod42.z.literal("refunded") }),
   FinishedSchema.extend({ status: import_zod42.z.enum(["failed", "unknown"]) })
 ]);
-var UpgradeCompensationProgressSchema = import_zod42.z.union([
+var StsCompensationProgressSchema = import_zod42.z.union([
   AttemptSchema2,
   FinishedSchema.extend({ status: import_zod42.z.enum(["removed", "failed", "unknown"]) })
 ]);
-var UpgradeReviewReasonSchema = import_zod42.z.enum(["refund-unknown", "compensation-failed", "compensation-unknown"]);
-var UpgradeReviewProgressSchema = import_zod42.z.strictObject({
+var StsReviewReasonSchema = import_zod42.z.enum(["refund-unknown", "compensation-failed", "compensation-unknown"]);
+var StsReviewProgressSchema = import_zod42.z.strictObject({
   markedAt: PostPurchaseTimestampSchema,
   marker: AcceptedMetafieldResultSchema.shape.status,
-  reason: UpgradeReviewReasonSchema
+  reason: StsReviewReasonSchema
 });
 var reviewReason = (refund, compensation) => {
   if (refund?.status === "unknown") return "refund-unknown";
@@ -3313,11 +3315,11 @@ var reviewReason = (refund, compensation) => {
     return `compensation-${compensation.status}`;
   return null;
 };
-var UpgradeProgressSchema = import_zod42.z.strictObject({
-  compensation: UpgradeCompensationProgressSchema.nullable(),
+var StsProgressSchema = import_zod42.z.strictObject({
+  compensation: StsCompensationProgressSchema.nullable(),
   operationId: PurchaseReceiptSchema.shape.operationId,
-  refund: UpgradeRefundProgressSchema.nullable(),
-  review: UpgradeReviewProgressSchema.nullable()
+  refund: StsRefundProgressSchema.nullable(),
+  review: StsReviewProgressSchema.nullable()
 }).refine(
   ({ compensation, refund }) => compensation === null || refund?.status === "failed",
   "Compensation follows a known refund failure only"
@@ -3340,11 +3342,11 @@ var AcceptedFollowupsResponseSchema = import_zod43.z.object({
     acceptedMetafield: AcceptedMetafieldResultSchema,
     health: RequiredHealthSchema,
     purchase: PurchaseObservationResponseSchema.shape.data,
-    /** Present only for an upgrade admission, and always for the same operation as `purchase`. */
-    upgrade: UpgradeProgressSchema.optional()
-  }).refine(({ purchase, upgrade }) => !upgrade || upgrade.operationId === purchase.operationId, {
-    message: "Upgrade progress belongs to its operation",
-    path: ["upgrade", "operationId"]
+    /** Present only for an STS admission, and always for the same operation as `purchase`. */
+    sts: StsProgressSchema.optional()
+  }).refine(({ purchase, sts }) => !sts || sts.operationId === purchase.operationId, {
+    message: "STS progress belongs to its operation",
+    path: ["sts", "operationId"]
   }),
   successful: import_zod43.z.literal(true)
 });
@@ -4755,15 +4757,23 @@ var PostPurchaseOfferEligibilityContext = import_zod77.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
   originalLineItems: import_zod77.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(
+    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() })
     ),
+    /** 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")
   }),
   import_zod77.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod77.z.literal("skip") }),
-  import_zod77.z.object({ reason: import_zod77.z.literal("eligible-upgrade").optional(), status: import_zod77.z.literal("unavailable") })
+  import_zod77.z.object({ reason: import_zod77.z.literal("eligible-sts").optional(), status: import_zod77.z.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts
@@ -4871,10 +4881,10 @@ var PurchaseRecoveryResponseSchema = import_zod83.z.object({
       operationId: PurchaseReceiptSchema.shape.operationId,
       /** The total the buyer affirmed at admission; absent for an operation admitted without one. */
       reportedCalculation: EventCalculationSchema.optional(),
-      upgrade: UpgradeProgressSchema.optional()
-    }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
-      message: "Upgrade progress belongs to its operation",
-      path: ["upgrade", "operationId"]
+      sts: StsProgressSchema.optional()
+    }).strict().refine(({ operationId, sts }) => !sts || sts.operationId === operationId, {
+      message: "STS progress belongs to its operation",
+      path: ["sts", "operationId"]
     }).refine(
       ({ followups, operationId }) => !followups?.acceptedEvent || followups.acceptedEvent.operationId === operationId,
       { message: "Follow-up progress belongs to its operation", path: ["followups", "acceptedEvent"] }

package/dist/index.mjs

@@ -1312,9 +1312,9 @@ import { z as z18 } from "zod";
 import { z as z9 } from "zod";
 var PostPurchaseProductGallery = z9.object({
   /**
-   * The product had more than one image before `images` was capped at the sub-image limit, so a
-   * renderer shows the thumbnail row even when the cap leaves one image (legacy checks the count
-   * before slicing). Older replies omit it; fall back to `images.length > 1`.
+   * Show the thumbnail row: the product had more than one image before `images` was capped at the
+   * sub-image limit, and that limit allows at least one thumbnail. It stays true when the cap leaves one
+   * image (legacy checks the count before slicing). Older replies omit it; fall back to `images.length > 1`.
    */
   hasMultiple: z9.boolean().optional(),
   images: z9.array(
@@ -2442,7 +2442,7 @@ var PostPurchaseProductChangeset = z23.object({
 });
 
 // src/schema/postPurchaseAdmission.ts
-var PurchaseAdmissionModeSchema = z24.enum(["purchase", "upgrade"]);
+var PurchaseAdmissionModeSchema = z24.enum(["purchase", "sts"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
 var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = z24.object({
@@ -2464,8 +2464,8 @@ var PurchaseExpectedSchema = z24.object({
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
   "Captured member requires progress"
 ).refine(
-  ({ mode, selection: { sellingPlanId } }) => mode !== "upgrade" || sellingPlanId !== void 0,
-  "An upgrade selects a subscription"
+  ({ mode, selection: { sellingPlanId } }) => mode !== "sts" || sellingPlanId !== void 0,
+  "An STS selects a subscription"
 ).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection3 }) => {
   const [change, shipping] = changeset.changes;
   if (selection3.sellingPlanId === void 0)
@@ -2481,7 +2481,7 @@ var PurchaseReceiptSchema = z24.object({
   changesetToken: z24.string().min(1),
   mode: PurchaseAdmissionModeSchema.optional(),
   operationId: z24.uuid(),
-  /** The server-bound one-time line an upgrade refunds; its quantity is the order's, not the selection's. */
+  /** The server-bound one-time line an STS refunds; its quantity is the order's, not the selection's. */
   originalLine: z24.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
   requiresSubscriptionConsent: z24.boolean(),
   selection
@@ -2489,8 +2489,8 @@ var PurchaseReceiptSchema = z24.object({
   ({ requiresSubscriptionConsent, selection: selection3 }) => requiresSubscriptionConsent === (selection3.sellingPlanId !== void 0),
   "Receipt consent must match its selected plan"
 ).refine(
-  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "upgrade" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
-  "An upgrade Receipt binds the original line of its subscribed variant, and only an upgrade does"
+  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "sts" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
+  "An STS Receipt binds the original line of its subscribed variant, and only an STS does"
 );
 var PurchaseResponseSchema = z24.object({ data: PurchaseReceiptSchema, successful: z24.literal(true) });
 
@@ -2816,24 +2816,24 @@ var PurchaseObservationResponseSchema = z41.object({
   successful: z41.literal(true)
 });
 
-// src/schema/postPurchaseUpgrade.ts
+// src/schema/postPurchaseSts.ts
 import { z as z42 } from "zod";
 var AttemptSchema2 = z42.strictObject({ attemptedAt: PostPurchaseTimestampSchema, status: z42.literal("attempted") });
 var FinishedSchema = AttemptSchema2.extend({ finishedAt: PostPurchaseTimestampSchema });
-var UpgradeRefundProgressSchema = z42.union([
+var StsRefundProgressSchema = z42.union([
   AttemptSchema2,
   FinishedSchema.extend({ refundId: z42.string().min(1), status: z42.literal("refunded") }),
   FinishedSchema.extend({ status: z42.enum(["failed", "unknown"]) })
 ]);
-var UpgradeCompensationProgressSchema = z42.union([
+var StsCompensationProgressSchema = z42.union([
   AttemptSchema2,
   FinishedSchema.extend({ status: z42.enum(["removed", "failed", "unknown"]) })
 ]);
-var UpgradeReviewReasonSchema = z42.enum(["refund-unknown", "compensation-failed", "compensation-unknown"]);
-var UpgradeReviewProgressSchema = z42.strictObject({
+var StsReviewReasonSchema = z42.enum(["refund-unknown", "compensation-failed", "compensation-unknown"]);
+var StsReviewProgressSchema = z42.strictObject({
   markedAt: PostPurchaseTimestampSchema,
   marker: AcceptedMetafieldResultSchema.shape.status,
-  reason: UpgradeReviewReasonSchema
+  reason: StsReviewReasonSchema
 });
 var reviewReason = (refund, compensation) => {
   if (refund?.status === "unknown") return "refund-unknown";
@@ -2841,11 +2841,11 @@ var reviewReason = (refund, compensation) => {
     return `compensation-${compensation.status}`;
   return null;
 };
-var UpgradeProgressSchema = z42.strictObject({
-  compensation: UpgradeCompensationProgressSchema.nullable(),
+var StsProgressSchema = z42.strictObject({
+  compensation: StsCompensationProgressSchema.nullable(),
   operationId: PurchaseReceiptSchema.shape.operationId,
-  refund: UpgradeRefundProgressSchema.nullable(),
-  review: UpgradeReviewProgressSchema.nullable()
+  refund: StsRefundProgressSchema.nullable(),
+  review: StsReviewProgressSchema.nullable()
 }).refine(
   ({ compensation, refund }) => compensation === null || refund?.status === "failed",
   "Compensation follows a known refund failure only"
@@ -2868,11 +2868,11 @@ var AcceptedFollowupsResponseSchema = z43.object({
     acceptedMetafield: AcceptedMetafieldResultSchema,
     health: RequiredHealthSchema,
     purchase: PurchaseObservationResponseSchema.shape.data,
-    /** Present only for an upgrade admission, and always for the same operation as `purchase`. */
-    upgrade: UpgradeProgressSchema.optional()
-  }).refine(({ purchase, upgrade }) => !upgrade || upgrade.operationId === purchase.operationId, {
-    message: "Upgrade progress belongs to its operation",
-    path: ["upgrade", "operationId"]
+    /** Present only for an STS admission, and always for the same operation as `purchase`. */
+    sts: StsProgressSchema.optional()
+  }).refine(({ purchase, sts }) => !sts || sts.operationId === purchase.operationId, {
+    message: "STS progress belongs to its operation",
+    path: ["sts", "operationId"]
   }),
   successful: z43.literal(true)
 });
@@ -4283,15 +4283,23 @@ var PostPurchaseOfferEligibilityContext = z77.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
   originalLineItems: z77.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
+var PostPurchaseStsOptions = z77.object({ sts: z77.boolean().optional() }).strict();
+var PostPurchaseStsContext = z77.object({
+  originalLineItems: z77.array(
+    selection2.pick({ productId: true, quantity: true, sellingPlanId: true, variantId: true })
+  )
+});
 var PostPurchaseOfferEligibility = z77.discriminatedUnion("status", [
   z77.object({
     members: z77.array(
       z77.object({ productId: selection2.shape.productId, productIndex: z77.number().int().nonnegative() })
     ),
+    /** Present only with STS on: each member switches one original one-time line to subscription. */
+    mode: z77.literal("sts").optional(),
     status: z77.literal("retain")
   }),
   z77.object({ reason: PostPurchaseOfferSkipReason, status: z77.literal("skip") }),
-  z77.object({ reason: z77.literal("eligible-upgrade").optional(), status: z77.literal("unavailable") })
+  z77.object({ reason: z77.literal("eligible-sts").optional(), status: z77.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts
@@ -4399,10 +4407,10 @@ var PurchaseRecoveryResponseSchema = z83.object({
       operationId: PurchaseReceiptSchema.shape.operationId,
       /** The total the buyer affirmed at admission; absent for an operation admitted without one. */
       reportedCalculation: EventCalculationSchema.optional(),
-      upgrade: UpgradeProgressSchema.optional()
-    }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
-      message: "Upgrade progress belongs to its operation",
-      path: ["upgrade", "operationId"]
+      sts: StsProgressSchema.optional()
+    }).strict().refine(({ operationId, sts }) => !sts || sts.operationId === operationId, {
+      message: "STS progress belongs to its operation",
+      path: ["sts", "operationId"]
     }).refine(
       ({ followups, operationId }) => !followups?.acceptedEvent || followups.acceptedEvent.operationId === operationId,
       { message: "Follow-up progress belongs to its operation", path: ["followups", "acceptedEvent"] }
@@ -6752,6 +6760,8 @@ export {
   PostPurchaseShadowSelectionSchema,
   PostPurchaseSkipReasonSchema,
   PostPurchaseSkipTraceSchema,
+  PostPurchaseStsContext,
+  PostPurchaseStsOptions,
   PostPurchaseSubscriptionDisplay,
   PostPurchaseSubscriptionTerms,
   PostPurchaseTimestampSchema,
@@ -6843,6 +6853,11 @@ export {
   SmartCartTierExclusion,
   SmartCartTierProduct,
   Spacing,
+  StsCompensationProgressSchema,
+  StsProgressSchema,
+  StsRefundProgressSchema,
+  StsReviewProgressSchema,
+  StsReviewReasonSchema,
   TextAlignment,
   TextBlock,
   TextColorName,
@@ -6853,11 +6868,6 @@ export {
   TiptapParagraph,
   TiptapText,
   UI_LABELS,
-  UpgradeCompensationProgressSchema,
-  UpgradeProgressSchema,
-  UpgradeRefundProgressSchema,
-  UpgradeReviewProgressSchema,
-  UpgradeReviewReasonSchema,
   UserConfig,
   VariableEffect,
   VariableType,

package/dist/schema/index.d.ts

@@ -56,7 +56,7 @@ export * from './postPurchaseSubscription';
 export * from './postPurchaseSubscriptionDisplay';
 export { PreparedPostPurchaseSubscription } from './postPurchaseSubscriptionProduct';
 export * from './postPurchaseTransition';
-export * from './postPurchaseUpgrade';
+export * from './postPurchaseSts';
 export * from './postPurchaseVariantCatalog';
 export * from './postPurchaseVariantDefault';
 export * from './postPurchaseVariantDefaultContext';

package/dist/schema/postPurchaseAdmission.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 /**
- * Absent means `purchase`, so every pre-upgrade wire is unchanged. `upgrade` adds the selected subscription and
+ * Absent means `purchase`, so every pre-STS wire is unchanged. `sts` adds the selected subscription and
  * refunds the buyer's original one-time line of the same variant; the server binds that line, never the client.
  */
 export declare const PurchaseAdmissionModeSchema: z.ZodEnum<{
     purchase: "purchase";
-    upgrade: "upgrade";
+    sts: "sts";
 }>;
 /** The buyer's SDK-calculated total for the affirmed terms (`calculateChangeset`), never proof of payment. */
 export declare const EventCalculationSchema: z.ZodObject<{
@@ -67,7 +67,7 @@ export declare const PurchaseExpectedSchema: z.ZodObject<{
     }, z.core.$strict>>;
     mode: z.ZodOptional<z.ZodEnum<{
         purchase: "purchase";
-        upgrade: "upgrade";
+        sts: "sts";
     }>>;
     progressRevision: z.ZodOptional<z.ZodNumber>;
     reportedCalculation: z.ZodOptional<z.ZodObject<{
@@ -139,7 +139,7 @@ export declare const PurchaseRequestSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mode: z.ZodOptional<z.ZodEnum<{
             purchase: "purchase";
-            upgrade: "upgrade";
+            sts: "sts";
         }>>;
         progressRevision: z.ZodOptional<z.ZodNumber>;
         reportedCalculation: z.ZodOptional<z.ZodObject<{
@@ -160,7 +160,7 @@ export declare const PurchaseReceiptSchema: z.ZodObject<{
     changesetToken: z.ZodString;
     mode: z.ZodOptional<z.ZodEnum<{
         purchase: "purchase";
-        upgrade: "upgrade";
+        sts: "sts";
     }>>;
     operationId: z.ZodUUID;
     originalLine: z.ZodOptional<z.ZodObject<{
@@ -181,7 +181,7 @@ export declare const PurchaseResponseSchema: z.ZodObject<{
         changesetToken: z.ZodString;
         mode: z.ZodOptional<z.ZodEnum<{
             purchase: "purchase";
-            upgrade: "upgrade";
+            sts: "sts";
         }>>;
         operationId: z.ZodUUID;
         originalLine: z.ZodOptional<z.ZodObject<{

package/dist/schema/postPurchaseFollowups.d.ts

@@ -125,7 +125,7 @@ export declare const AcceptedFollowupsResponseSchema: z.ZodObject<{
             recordedAt: z.ZodNumber;
             operationId: z.ZodUUID;
         }, z.core.$strict>;
-        upgrade: z.ZodOptional<z.ZodObject<{
+        sts: z.ZodOptional<z.ZodObject<{
             compensation: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
                 attemptedAt: z.ZodNumber;
                 status: z.ZodLiteral<"attempted">;

package/dist/schema/postPurchaseOfferEligibility.d.ts

@@ -12,12 +12,35 @@ export declare const PostPurchaseOfferEligibilityContext: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PostPurchaseOfferEligibilityContext = z.infer<typeof PostPurchaseOfferEligibilityContext>;
+/**
+ * The switch-to-subscription (STS; merchant setting `upgradeToSubscription`) opt-in. Absent or `false`, an
+ * STS-enabled Offer is still `eligible-sts`/`unavailable` and every other output is unchanged, so a release can
+ * ship with STS off.
+ */
+export declare const PostPurchaseStsOptions: z.ZodObject<{
+    sts: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type PostPurchaseStsOptions = z.infer<typeof PostPurchaseStsOptions>;
+/**
+ * The buyer's original lines with their quantities. Passing it opts a preparation into STS; it changes only an
+ * STS-enabled Offer, whose members each switch one original one-time line to subscription.
+ */
+export declare const PostPurchaseStsContext: z.ZodObject<{
+    originalLineItems: z.ZodArray<z.ZodObject<{
+        productId: z.ZodNumber;
+        sellingPlanId: z.ZodOptional<z.ZodNumber>;
+        quantity: z.ZodNumber;
+        variantId: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PostPurchaseStsContext = z.infer<typeof PostPurchaseStsContext>;
 /** Retained catalog membership does not certify presentation or purchase preparation. */
 export declare const PostPurchaseOfferEligibility: z.ZodDiscriminatedUnion<[z.ZodObject<{
     members: z.ZodArray<z.ZodObject<{
         productId: z.ZodNumber;
         productIndex: z.ZodNumber;
     }, z.core.$strip>>;
+    mode: z.ZodOptional<z.ZodLiteral<"sts">>;
     status: z.ZodLiteral<"retain">;
 }, z.core.$strip>, z.ZodObject<{
     reason: z.ZodEnum<{
@@ -26,7 +49,7 @@ export declare const PostPurchaseOfferEligibility: z.ZodDiscriminatedUnion<[z.Zo
     }>;
     status: z.ZodLiteral<"skip">;
 }, z.core.$strip>, z.ZodObject<{
-    reason: z.ZodOptional<z.ZodLiteral<"eligible-upgrade">>;
+    reason: z.ZodOptional<z.ZodLiteral<"eligible-sts">>;
     status: z.ZodLiteral<"unavailable">;
 }, z.core.$strip>], "status">;
 export type PostPurchaseOfferEligibility = z.infer<typeof PostPurchaseOfferEligibility>;

package/dist/schema/postPurchaseRecovery.d.ts

@@ -108,7 +108,7 @@ export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
                 currencyCode: z.ZodString;
                 totalMinor: z.ZodNumber;
             }, z.core.$strict>>;
-            upgrade: z.ZodOptional<z.ZodObject<{
+            sts: z.ZodOptional<z.ZodObject<{
                 compensation: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
                     attemptedAt: z.ZodNumber;
                     status: z.ZodLiteral<"attempted">;

package/dist/schema/{postPurchaseUpgrade.d.ts → postPurchaseSts.d.ts}

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 /**
- * apiv2 `refund-product` for the upgrade's original one-time line. `failed` is a known refusal (nothing was
+ * apiv2 `refund-product` for the STS's original one-time line. `failed` is a known refusal (nothing was
  * refunded); `unknown` is a lost or ambiguous answer, which is never retried and never compensated blindly.
  */
-export declare const UpgradeRefundProgressSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const StsRefundProgressSchema: z.ZodUnion<readonly [z.ZodObject<{
     attemptedAt: z.ZodNumber;
     status: z.ZodLiteral<"attempted">;
 }, z.core.$strict>, z.ZodObject<{
@@ -20,7 +20,7 @@ export declare const UpgradeRefundProgressSchema: z.ZodUnion<readonly [z.ZodObje
     }>;
 }, z.core.$strict>]>;
 /** apiv2 `remove-subscription-product`: the rollback that runs only after a known refund failure. */
-export declare const UpgradeCompensationProgressSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const StsCompensationProgressSchema: z.ZodUnion<readonly [z.ZodObject<{
     attemptedAt: z.ZodNumber;
     status: z.ZodLiteral<"attempted">;
 }, z.core.$strict>, z.ZodObject<{
@@ -33,16 +33,16 @@ export declare const UpgradeCompensationProgressSchema: z.ZodUnion<readonly [z.Z
     }>;
 }, z.core.$strict>]>;
 /**
- * Why the upgrade is left for a person; `marker` is the `subscription_rollback_failed` metafield write. A
+ * Why the STS is left for a person; `marker` is the `subscription_rollback_failed` metafield write. A
  * `marker` of `unavailable` means the marker could not be written, NOT that no review is needed: the review
  * stands whatever the marker status.
  */
-export declare const UpgradeReviewReasonSchema: z.ZodEnum<{
+export declare const StsReviewReasonSchema: z.ZodEnum<{
     "refund-unknown": "refund-unknown";
     "compensation-failed": "compensation-failed";
     "compensation-unknown": "compensation-unknown";
 }>;
-export declare const UpgradeReviewProgressSchema: z.ZodObject<{
+export declare const StsReviewProgressSchema: z.ZodObject<{
     markedAt: z.ZodNumber;
     marker: z.ZodUnion<readonly [z.ZodEnum<{
         unknown: "unknown";
@@ -59,11 +59,11 @@ export declare const UpgradeReviewProgressSchema: z.ZodObject<{
     }>;
 }, z.core.$strict>;
 /**
- * The refund-compensation saga of one admitted upgrade, `null` steps not yet started. Compensation follows a
+ * The refund-compensation saga of one admitted STS, `null` steps not yet started. Compensation follows a
  * known refund failure only, and a review is recorded exactly when the outcome is unresolved (an unknown
- * refund, or a failed or unknown rollback), so a compensated or unresolved upgrade never reads as upgraded.
+ * refund, or a failed or unknown rollback), so a compensated or unresolved STS never reads as switched.
  */
-export declare const UpgradeProgressSchema: z.ZodObject<{
+export declare const StsProgressSchema: z.ZodObject<{
     compensation: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
         attemptedAt: z.ZodNumber;
         status: z.ZodLiteral<"attempted">;
@@ -110,8 +110,8 @@ export declare const UpgradeProgressSchema: z.ZodObject<{
         }>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type UpgradeCompensationProgress = z.infer<typeof UpgradeCompensationProgressSchema>;
-export type UpgradeProgress = z.infer<typeof UpgradeProgressSchema>;
-export type UpgradeRefundProgress = z.infer<typeof UpgradeRefundProgressSchema>;
-export type UpgradeReviewProgress = z.infer<typeof UpgradeReviewProgressSchema>;
-export type UpgradeReviewReason = z.infer<typeof UpgradeReviewReasonSchema>;
+export type StsCompensationProgress = z.infer<typeof StsCompensationProgressSchema>;
+export type StsProgress = z.infer<typeof StsProgressSchema>;
+export type StsRefundProgress = z.infer<typeof StsRefundProgressSchema>;
+export type StsReviewProgress = z.infer<typeof StsReviewProgressSchema>;
+export type StsReviewReason = z.infer<typeof StsReviewReasonSchema>;