@rebuy/rebuy 3.34.0 → 3.36.0

package/dist/schema/postPurchaseQuantity.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/** One member's buyer choice plus an optional explicit quantity. */
+export declare const PostPurchaseQuantityChoice: z.ZodObject<{
+    choice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"one-time">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"subscription">;
+        sellingPlanId: z.ZodNumber;
+    }, z.core.$strict>], "mode">>;
+    productId: z.ZodNumber;
+    variantId: z.ZodOptional<z.ZodNumber>;
+    quantity: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type PostPurchaseQuantityChoice = z.infer<typeof PostPurchaseQuantityChoice>;
+/**
+ * Today's picker bounds plus the trusted initial quantity. A minimum of 0, which the settings schema accepts and
+ * maps unreadable values to, floors at 1: nothing can be bought at 0, and legacy still rendered that picker, so
+ * it must not refuse the Offer.
+ */
+export declare const PostPurchaseQuantityPolicy: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    initialQuantity: z.ZodNumber;
+    maxValue: z.ZodNumber;
+    minValue: z.ZodUnion<[z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<number, 0>>, z.ZodNumber]>;
+}, z.core.$strip>;
+export type PostPurchaseQuantityPolicy = z.infer<typeof PostPurchaseQuantityPolicy>;

package/dist/schema/postPurchaseSubscriptionProduct.d.ts

@@ -2,6 +2,43 @@ import { z } from 'zod';
 import { PreparedPostPurchaseProduct } from './postPurchaseProduct';
 export declare const PreparedPostPurchaseSubscription: z.ZodObject<{
     display: z.ZodObject<{
+        descriptionDocument: z.ZodOptional<z.ZodObject<{
+            attrs: z.ZodDefault<z.ZodObject<{
+                blockSpacing: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"none" | "base" | "extraTight" | "tight" | "loose" | "extraLoose" | undefined, string>>>;
+            }, z.core.$strip>>;
+            content: z.ZodDefault<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+                attrs: z.ZodDefault<z.ZodObject<{
+                    textAlign: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"start" | "center" | "end" | undefined, string>>>;
+                }, z.core.$strip>>;
+                content: z.ZodDefault<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+                    marks: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"bold">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"italic">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        attrs: z.ZodObject<{
+                            class: z.ZodNullable<z.ZodString>;
+                            href: z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"#">, z.ZodString, z.ZodString]>;
+                            rel: z.ZodDefault<z.ZodString>;
+                            target: z.ZodDefault<z.ZodString>;
+                        }, z.core.$strip>;
+                        type: z.ZodLiteral<"link">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"strike">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        attrs: z.ZodObject<{
+                            color: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"success" | "warning" | "critical" | "base" | "decorative" | "subdued" | "accent" | undefined, string>>>>;
+                            fontSize: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"small" | "base" | "large" | "medium" | "extraSmall" | "extraLarge" | "heading" | undefined, string>>>>;
+                        }, z.core.$strip>;
+                        type: z.ZodLiteral<"textStyle">;
+                    }, z.core.$strip>], "type">>, z.ZodPipe<z.ZodObject<{}, z.core.$strict>, z.ZodTransform<never[], Record<string, never>>>]>>;
+                    text: z.ZodDefault<z.ZodString>;
+                    type: z.ZodDefault<z.ZodLiteral<"text">>;
+                }, z.core.$strip>>, z.ZodPipe<z.ZodObject<{}, z.core.$strict>, z.ZodTransform<never[], Record<string, never>>>]>>;
+                type: z.ZodDefault<z.ZodLiteral<"paragraph">>;
+            }, z.core.$strip>>, z.ZodPipe<z.ZodObject<{}, z.core.$strict>, z.ZodTransform<never[], Record<string, never>>>]>>;
+            type: z.ZodDefault<z.ZodLiteral<"doc">>;
+        }, z.core.$strip>>;
         discountedFrom: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             price: "price";
             compare_at_price: "compare_at_price";
@@ -18,18 +55,6 @@ export declare const PreparedPostPurchaseSubscription: z.ZodObject<{
         language: z.ZodObject<{
             description: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>]>>;
             descriptionEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            descriptionRte: z.ZodOptional<z.ZodObject<{
-                content: z.ZodArray<z.ZodUnknown>;
-                type: z.ZodString;
-            }, z.core.$strip>>;
-            descriptionSpacing: z.ZodOptional<z.ZodEnum<{
-                default: "default";
-                none: "none";
-                tight: "tight";
-                loose: "loose";
-                xtight: "xtight";
-                xloose: "xloose";
-            }>>;
         }, z.core.$strip>;
         primaryImage: z.ZodObject<{
             description: z.ZodString;
@@ -131,11 +156,6 @@ export declare const readPostPurchaseSubscription: (prepared: z.infer<typeof Pre
         language: {
             description: string;
             descriptionEnabled: boolean;
-            descriptionRte?: {
-                content: unknown[];
-                type: string;
-            } | undefined;
-            descriptionSpacing?: "default" | "none" | "tight" | "loose" | "xtight" | "xloose" | undefined;
         };
         primaryImage: {
             description: string;
@@ -151,6 +171,43 @@ export declare const readPostPurchaseSubscription: (prepared: z.infer<typeof Pre
         };
         responseDescription: string;
         shouldShowSavingText: boolean;
+        descriptionDocument?: {
+            attrs: {
+                blockSpacing?: "none" | "base" | "extraTight" | "tight" | "loose" | "extraLoose" | undefined;
+            };
+            content: never[] | {
+                attrs: {
+                    textAlign?: "start" | "center" | "end" | undefined;
+                };
+                content: never[] | {
+                    text: string;
+                    type: "text";
+                    marks?: never[] | ({
+                        type: "bold";
+                    } | {
+                        type: "italic";
+                    } | {
+                        attrs: {
+                            class: string | null;
+                            href: string;
+                            rel: string;
+                            target: string;
+                        };
+                        type: "link";
+                    } | {
+                        type: "strike";
+                    } | {
+                        attrs: {
+                            color: "success" | "warning" | "critical" | "base" | "decorative" | "subdued" | "accent";
+                            fontSize: "small" | "base" | "large" | "medium" | "extraSmall" | "extraLarge" | "heading";
+                        };
+                        type: "textStyle";
+                    })[] | undefined;
+                }[];
+                type: "paragraph";
+            }[];
+            type: "doc";
+        } | undefined;
         gallery?: {
             images: {
                 description: string;

package/dist/schema/postPurchaseVariantDefault.d.ts

@@ -34,3 +34,20 @@ export declare const PostPurchaseVariantDefaultSettings: z.ZodObject<{
     hideOutOfStockVariants: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;
 export declare const PostPurchaseOrderAttributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+export declare const PostPurchaseOriginalVariants: z.ZodArray<z.ZodObject<{
+    productId: z.ZodNumber;
+    variantId: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const PostPurchaseAttributeProducts: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    options: z.ZodArray<z.ZodObject<{
+        values: z.ZodArray<z.ZodString>;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    variants: z.ZodArray<z.ZodObject<{
+        option2: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        option3: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        option1: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;

package/dist/schema/postPurchaseVariantDefaultContext.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** Server-owned original-order facts; enrichment is parsed only when matching consumes it. */
+export declare const PostPurchaseVariantDefaultContext: z.ZodObject<{
+    enrichedLineItems: z.ZodOptional<z.ZodUnknown>;
+    originalVariants: z.ZodArray<z.ZodObject<{
+        productId: z.ZodNumber;
+        variantId: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PostPurchaseVariantDefaultContext = z.infer<typeof PostPurchaseVariantDefaultContext>;

package/dist/server/__fixtures__/postPurchaseGroup.d.ts

@@ -0,0 +1,78 @@
+/** Synthetic group wire grounded in legacy schemas/consumers; not a captured upstream response. */
+export declare const groupSettings: {
+    quantity_inputs: {
+        default_quantity: number;
+        enabled: boolean;
+    };
+    blocks: {
+        type: string;
+    }[];
+    discount: {
+        amount: string;
+        type: string;
+    };
+    endpoint: string;
+    integrations: {};
+    key: string;
+    language: {};
+    product_limit: number;
+    product_options: {};
+    product_type: string;
+    shipping: {
+        amount: string;
+        title: string;
+        type: string;
+    };
+};
+export declare const groupResponse: () => {
+    data: {
+        metadata: {
+            product_quantity: number;
+        };
+        options: {
+            id: number;
+            name: string;
+            position: number;
+            values: string[];
+        }[];
+        product_group_variants: ({
+            description: string;
+            id: number;
+            image: null;
+            options: {
+                id: number;
+                name: string;
+                position: number;
+                values: string[];
+            }[];
+            title: string;
+        } | null)[];
+        variants: ({
+            inventory_quantity: number;
+            option1: string;
+            compare_at_price: string;
+            id: number;
+            inventory_management: string;
+            inventory_policy: string;
+            price: string;
+            product_id: number;
+            title: string;
+        } | {
+            id: number;
+            product_id: number;
+            title: string;
+            compare_at_price: string;
+            inventory_management: string;
+            inventory_policy: string;
+            inventory_quantity: number;
+            price: string;
+        })[];
+        description: string;
+        id: number;
+        image: {
+            src: string;
+        };
+        title: string;
+    }[];
+    metadata: {};
+};

package/dist/server/classifyPostPurchaseOffer.d.ts

@@ -0,0 +1,3 @@
+import { type z } from 'zod';
+import { type PostPurchaseOfferEligibility, PostPurchaseOfferEligibilityContext } from '../schema/postPurchaseOfferEligibility';
+export declare const classifyPostPurchaseOffer: (settings: unknown, response: unknown, context: z.input<typeof PostPurchaseOfferEligibilityContext>) => PostPurchaseOfferEligibility;

package/dist/server/createPostPurchaseOrderAttributes.d.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+import { PostPurchaseAttributeProducts, PostPurchaseOriginalVariants } from '../schema/postPurchaseVariantDefault';
+/**
+ * `{ optionName: values }` from the original line items joined to the enrichment by product id, in original
+ * line order. Two legacy `createAttributeMap` defects are fixed: an append now tests the value at the position
+ * being pushed rather than `option1` for every position (L103), and a position the product does not declare is
+ * skipped rather than throwing (L104).
+ */
+export declare const createPostPurchaseOrderAttributes: (original: z.input<typeof PostPurchaseOriginalVariants>, enriched: z.input<typeof PostPurchaseAttributeProducts>) => Record<string, string[]>;