npm - @tinkerlandai/indiana-sdk - Versions diffs - 0.9.2 → 0.10.1 - Mend

@tinkerlandai/indiana-sdk 0.9.2 → 0.10.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

package/CHANGELOG.md +21 -0
package/README.md +50 -5
package/README.zh-CN.md +30 -5
package/dist/{ai-usage-DMNKvCiq.d.ts → ai-usage-Cn7dhvFw.d.ts} +5 -5
package/dist/{api--Zf0gxfj.d.ts → api-DC44FaTV.d.ts} +6346 -749
package/dist/chunk-2Y4G5364.js +6 -0
package/dist/chunk-6ZZUNGNE.js +1 -0
package/dist/chunk-ABNSU3ZG.js +4 -0
package/dist/chunk-ACF2FBUB.js +1 -0
package/dist/{chunk-65TBYVCS.js → chunk-AHXYGGAA.js} +1 -1
package/dist/chunk-BOCKPUCM.js +2 -0
package/dist/chunk-CCPNMQHZ.js +1 -0
package/dist/chunk-CLXORAOK.js +1 -0
package/dist/chunk-EDQCH2QS.js +1 -0
package/dist/chunk-IWWKVNEX.js +1 -0
package/dist/chunk-QUWPPZHH.js +1 -0
package/dist/chunk-SBPTOOYB.js +1 -0
package/dist/chunk-WYZI3TNB.js +1 -0
package/dist/chunk-X6BCUINI.js +173 -0
package/dist/chunk-Y46ALAKP.js +1 -0
package/dist/{configuration-sync-E98CqVwh.d.ts → configuration-sync-CXe9Zcng.d.ts} +74 -21
package/dist/content-ZRWZ26PF.js +1 -0
package/dist/coupon-fA1QujHt.d.ts +184 -0
package/dist/{customer-page-9B97Qdt_.d.ts → customer-page-km5f1PJZ.d.ts} +86 -182
package/dist/{funnel-local-client-BjPwXlQb.d.ts → funnel-local-client-BQsdOjQ7.d.ts} +19985 -2451
package/dist/funnel-node-evaluation-P5B4fPfJ.d.ts +2054 -0
package/dist/funnel-resource-client-Zof1WLgA.d.ts +14525 -0
package/dist/funnel-runtime-host-N7TX3LWI.js +1 -0
package/dist/index.d.ts +13905 -13996
package/dist/index.js +1 -1
package/dist/native-shell.js +1 -1
package/dist/openrouter.d.ts +3 -3
package/dist/openrouter.js +1 -1
package/dist/page.d.ts +4 -4
package/dist/page.js +1 -1
package/dist/paywall-DR65VN2G.js +1 -0
package/dist/popup.d.ts +7 -5
package/dist/popup.js +1 -1
package/dist/react-native.d.ts +36432 -174
package/dist/react-native.js +1 -1
package/dist/{screen-BITZ11jn.d.ts → screen-D81zCpfi.d.ts} +159 -6
package/dist/{screen-renderer-A6VYE2QL.js → screen-renderer-ZSAR7LPS.js} +1 -1
package/dist/server.d.ts +2924 -500
package/dist/server.js +1 -1
package/dist/visual-dom-OFB7BFFB.js +1 -0
package/dist/visual.d.ts +2 -2
package/dist/visual.js +1 -1
package/package.json +1 -1
package/dist/chunk-5O667MKA.js +0 -1
package/dist/chunk-67A7I6MB.js +0 -1
package/dist/chunk-CCQHYQ4P.js +0 -1
package/dist/chunk-CPLLMISZ.js +0 -1
package/dist/chunk-G23YNWWI.js +0 -1
package/dist/chunk-L7LKE3MG.js +0 -173
package/dist/chunk-NH2PTTNK.js +0 -2
package/dist/chunk-PK5HYUHD.js +0 -1
package/dist/chunk-SEW4YVR7.js +0 -1
package/dist/chunk-UYSOTMY3.js +0 -1
package/dist/chunk-WSVH6IQA.js +0 -1
package/dist/chunk-YZSQDZXW.js +0 -4
package/dist/content-3LOJVYQO.js +0 -1
package/dist/errors-0TSUIbUi.d.ts +0 -115
package/dist/funnel-runtime-host-NYHKQT6T.js +0 -1
package/dist/paywall-ISCYOGPZ.js +0 -1

package/dist/funnel-node-evaluation-P5B4fPfJ.d.ts ADDED Viewed

@@ -0,0 +1,2054 @@
+import { z } from 'zod';
+import { E as EvaluationContext, J as JsonValue } from './growth-rules-B4YYy64R.js';
+declare const merchantBridgeCommandSchema: z.ZodEnum<{
+    "session.create": "session.create";
+    "catalog.read": "catalog.read";
+    "customer.commerce.read": "customer.commerce.read";
+    "presentation.resolve": "presentation.resolve";
+    "presentation.report": "presentation.report";
+    "purchase.execute": "purchase.execute";
+    "operation.read": "operation.read";
+    "subscription.change": "subscription.change";
+    "refund.execute": "refund.execute";
+    "bridge.ping": "bridge.ping";
+    "bridge.describe": "bridge.describe";
+}>;
+type MerchantBridgeCommand = z.infer<typeof merchantBridgeCommandSchema>;
+declare const merchantBridgeManifestSchema: z.ZodObject<{
+    bridgeVersion: z.ZodLiteral<3>;
+    projectId: z.ZodUUID;
+    environmentId: z.ZodUUID;
+    environment: z.ZodEnum<{
+        sandbox: "sandbox";
+        live: "live";
+    }>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        session: "session";
+        catalog: "catalog";
+        customer_commerce: "customer_commerce";
+        presentation: "presentation";
+        presentation_events: "presentation_events";
+        purchases: "purchases";
+        operation_status: "operation_status";
+        billing_records: "billing_records";
+        subscription_changes: "subscription_changes";
+        refunds: "refunds";
+    }>>;
+    catalog: z.ZodEnum<{
+        none: "none";
+        endpoint: "endpoint";
+        static: "static";
+    }>;
+    billingEvents: z.ZodArray<z.ZodEnum<{
+        "purchase.completed": "purchase.completed";
+        "purchase.closed": "purchase.closed";
+        "subscription.observed": "subscription.observed";
+        "invoice.paid": "invoice.paid";
+        "subscription.change.completed": "subscription.change.completed";
+        "refund.updated": "refund.updated";
+    }>>;
+    profiles: z.ZodArray<z.ZodEnum<{
+        "purchase.subscription": "purchase.subscription";
+        "purchase.one_time": "purchase.one_time";
+        "purchase.prepaid": "purchase.prepaid";
+        "purchase.trial": "purchase.trial";
+        "purchase.seats": "purchase.seats";
+        "purchase.tiered": "purchase.tiered";
+        "tax.automatic": "tax.automatic";
+        "discount.percent.once": "discount.percent.once";
+        "discount.percent.repeating": "discount.percent.repeating";
+        "discount.percent.forever": "discount.percent.forever";
+        "discount.amount.once": "discount.amount.once";
+        "discount.amount.repeating": "discount.amount.repeating";
+        "discount.amount.forever": "discount.amount.forever";
+        "subscription.cancel.immediate": "subscription.cancel.immediate";
+        "subscription.cancel.renewal": "subscription.cancel.renewal";
+        "subscription.resume": "subscription.resume";
+        "subscription.plan.immediate": "subscription.plan.immediate";
+        "subscription.plan.renewal": "subscription.plan.renewal";
+        "subscription.seats": "subscription.seats";
+        "subscription.quantity": "subscription.quantity";
+        "subscription.billing_cycle": "subscription.billing_cycle";
+        "subscription.proration": "subscription.proration";
+        "refund.full": "refund.full";
+        "refund.partial": "refund.partial";
+        "refund.revoke": "refund.revoke";
+    }>>;
+}, z.core.$strict>;
+type MerchantBridgeManifest = z.infer<typeof merchantBridgeManifestSchema>;
+declare const merchantBridgeOperationInputSchema: z.ZodObject<{
+    operationId: z.ZodUUID;
+    customerId: z.ZodUUID;
+}, z.core.$strict>;
+declare const merchantBridgeOperationAuthoritySchema: z.ZodObject<{
+    scope: z.ZodObject<{
+        projectId: z.ZodUUID;
+        environmentId: z.ZodUUID;
+        environment: z.ZodEnum<{
+            sandbox: "sandbox";
+            live: "live";
+        }>;
+    }, z.core.$strict>;
+    operationId: z.ZodUUID;
+    customerId: z.ZodUUID;
+    confirmedAt: z.ZodNullable<z.ZodISODateTime>;
+    initialExecutionAllowed: z.ZodBoolean;
+    instruction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"purchase">;
+        mode: z.ZodEnum<{
+            payment: "payment";
+            subscription: "subscription";
+        }>;
+        lineItems: z.ZodArray<z.ZodObject<{
+            priceId: z.ZodUUID;
+            productVersionId: z.ZodUUID;
+            productId: z.ZodString;
+            quantity: z.ZodNumber;
+            unitAmountMinor: z.ZodNumber;
+            totalMinor: z.ZodNumber;
+            interval: z.ZodEnum<{
+                week: "week";
+                month: "month";
+                year: "year";
+                one_off: "one_off";
+            }>;
+            intervalCount: z.ZodNumber;
+            kind: z.ZodEnum<{
+                prepaid: "prepaid";
+                fixed: "fixed";
+                seat: "seat";
+            }>;
+            tiers: z.ZodNullable<z.ZodObject<{
+                mode: z.ZodEnum<{
+                    graduated: "graduated";
+                    volume: "volume";
+                }>;
+                tiers: z.ZodArray<z.ZodObject<{
+                    upTo: z.ZodNullable<z.ZodNumber>;
+                    unitAmountMinor: z.ZodNumber;
+                    flatAmountMinor: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        catalogAmountMinor: z.ZodNumber;
+        discount: z.ZodNullable<z.ZodObject<{
+            grantId: z.ZodUUID;
+            couponId: z.ZodUUID;
+            amountMinor: z.ZodNumber;
+            terms: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"percent">;
+                percentOff: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"amount">;
+                amountOffMinor: z.ZodNumber;
+                currency: z.ZodString;
+            }, z.core.$strict>], "type">;
+            duration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"once">;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"forever">;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"repeating">;
+                months: z.ZodNumber;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>>;
+        trialPeriodDays: z.ZodNullable<z.ZodNumber>;
+        automaticTax: z.ZodBoolean;
+        provider: z.ZodLiteral<"merchant">;
+        executor: z.ZodLiteral<"merchant">;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        connectionRevision: z.ZodNumber;
+        currency: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subscription_change">;
+        subscriptionId: z.ZodUUID;
+        merchantSubscriptionId: z.ZodString;
+        membershipId: z.ZodUUID;
+        subscriptionAction: z.ZodEnum<{
+            update: "update";
+            cancel: "cancel";
+            schedule: "schedule";
+            release: "release";
+        }>;
+        supersedesOperationId: z.ZodNullable<z.ZodUUID>;
+        change: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"cancel">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"uncancel">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"plan">;
+            productVersionId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"seats">;
+            licenseKey: z.ZodString;
+            quantity: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"quantity">;
+            internal_feature_id: z.ZodUUID;
+            quantity: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"billing_cycle">;
+            billingCycleAnchor: z.ZodUnion<readonly [z.ZodLiteral<"now">, z.ZodNumber]>;
+        }, z.core.$strict>], "type">;
+        timing: z.ZodEnum<{
+            immediate: "immediate";
+            renewal: "renewal";
+        }>;
+        effectiveAt: z.ZodISODateTime;
+        creditMinor: z.ZodNumber;
+        debitMinor: z.ZodNumber;
+        totalMinor: z.ZodNumber;
+        discountMinor: z.ZodNumber;
+        taxMinor: z.ZodNumber;
+        proration: z.ZodEnum<{
+            none: "none";
+            create_prorations: "create_prorations";
+            always_invoice: "always_invoice";
+        }>;
+        lineItems: z.ZodArray<z.ZodObject<{
+            priceId: z.ZodUUID;
+            productVersionId: z.ZodUUID;
+            productId: z.ZodString;
+            unitAmountMinor: z.ZodNumber;
+            totalMinor: z.ZodNumber;
+            interval: z.ZodEnum<{
+                week: "week";
+                month: "month";
+                year: "year";
+                one_off: "one_off";
+            }>;
+            intervalCount: z.ZodNumber;
+            kind: z.ZodEnum<{
+                prepaid: "prepaid";
+                fixed: "fixed";
+                seat: "seat";
+            }>;
+            tiers: z.ZodNullable<z.ZodObject<{
+                mode: z.ZodEnum<{
+                    graduated: "graduated";
+                    volume: "volume";
+                }>;
+                tiers: z.ZodArray<z.ZodObject<{
+                    upTo: z.ZodNullable<z.ZodNumber>;
+                    unitAmountMinor: z.ZodNumber;
+                    flatAmountMinor: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            quantity: z.ZodNumber;
+        }, z.core.$strict>>;
+        removePriceIds: z.ZodArray<z.ZodUUID>;
+        provider: z.ZodLiteral<"merchant">;
+        executor: z.ZodLiteral<"merchant">;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        connectionRevision: z.ZodNumber;
+        currency: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refund">;
+        invoiceId: z.ZodUUID;
+        merchantInvoiceId: z.ZodString;
+        amountMinor: z.ZodNumber;
+        mode: z.ZodEnum<{
+            full: "full";
+            partial: "partial";
+        }>;
+        entitlementAction: z.ZodEnum<{
+            retain: "retain";
+            revoke: "revoke";
+        }>;
+        cancelSubscriptions: z.ZodArray<z.ZodString>;
+        provider: z.ZodLiteral<"merchant">;
+        executor: z.ZodLiteral<"merchant">;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        connectionRevision: z.ZodNumber;
+        currency: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>;
+declare const merchantBridgeCommandInputs: {
+    readonly "bridge.ping": z.ZodObject<{
+        challenge: z.ZodUUID;
+    }, z.core.$strict>;
+    readonly "bridge.describe": z.ZodObject<{}, z.core.$strict>;
+    readonly "session.create": z.ZodObject<{}, z.core.$strict>;
+    readonly "catalog.read": z.ZodObject<{}, z.core.$strict>;
+    readonly "customer.commerce.read": z.ZodObject<{}, z.core.$strict>;
+    readonly "presentation.resolve": z.ZodObject<{}, z.core.$strict>;
+    readonly "presentation.report": z.ZodObject<{
+        decisionId: z.ZodUUID;
+        eventId: z.ZodUUID;
+    }, z.core.$strict>;
+    readonly "purchase.execute": z.ZodObject<{
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+    }, z.core.$strict>;
+    readonly "operation.read": z.ZodObject<{
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+    }, z.core.$strict>;
+    readonly "subscription.change": z.ZodObject<{
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+    }, z.core.$strict>;
+    readonly "refund.execute": z.ZodObject<{
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+    }, z.core.$strict>;
+};
+declare const merchantBridgeCommandOutputs: {
+    readonly "bridge.ping": z.ZodObject<{
+        challenge: z.ZodUUID;
+    }, z.core.$strict>;
+    readonly "bridge.describe": z.ZodObject<{
+        bridgeVersion: z.ZodLiteral<3>;
+        projectId: z.ZodUUID;
+        environmentId: z.ZodUUID;
+        environment: z.ZodEnum<{
+            sandbox: "sandbox";
+            live: "live";
+        }>;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            session: "session";
+            catalog: "catalog";
+            customer_commerce: "customer_commerce";
+            presentation: "presentation";
+            presentation_events: "presentation_events";
+            purchases: "purchases";
+            operation_status: "operation_status";
+            billing_records: "billing_records";
+            subscription_changes: "subscription_changes";
+            refunds: "refunds";
+        }>>;
+        catalog: z.ZodEnum<{
+            none: "none";
+            endpoint: "endpoint";
+            static: "static";
+        }>;
+        billingEvents: z.ZodArray<z.ZodEnum<{
+            "purchase.completed": "purchase.completed";
+            "purchase.closed": "purchase.closed";
+            "subscription.observed": "subscription.observed";
+            "invoice.paid": "invoice.paid";
+            "subscription.change.completed": "subscription.change.completed";
+            "refund.updated": "refund.updated";
+        }>>;
+        profiles: z.ZodArray<z.ZodEnum<{
+            "purchase.subscription": "purchase.subscription";
+            "purchase.one_time": "purchase.one_time";
+            "purchase.prepaid": "purchase.prepaid";
+            "purchase.trial": "purchase.trial";
+            "purchase.seats": "purchase.seats";
+            "purchase.tiered": "purchase.tiered";
+            "tax.automatic": "tax.automatic";
+            "discount.percent.once": "discount.percent.once";
+            "discount.percent.repeating": "discount.percent.repeating";
+            "discount.percent.forever": "discount.percent.forever";
+            "discount.amount.once": "discount.amount.once";
+            "discount.amount.repeating": "discount.amount.repeating";
+            "discount.amount.forever": "discount.amount.forever";
+            "subscription.cancel.immediate": "subscription.cancel.immediate";
+            "subscription.cancel.renewal": "subscription.cancel.renewal";
+            "subscription.resume": "subscription.resume";
+            "subscription.plan.immediate": "subscription.plan.immediate";
+            "subscription.plan.renewal": "subscription.plan.renewal";
+            "subscription.seats": "subscription.seats";
+            "subscription.quantity": "subscription.quantity";
+            "subscription.billing_cycle": "subscription.billing_cycle";
+            "subscription.proration": "subscription.proration";
+            "refund.full": "refund.full";
+            "refund.partial": "refund.partial";
+            "refund.revoke": "refund.revoke";
+        }>>;
+    }, z.core.$strict>;
+    readonly "session.create": z.ZodObject<{
+        nativeUserId: z.ZodString;
+        session: z.ZodObject<{
+            customerId: z.ZodUUID;
+            sessionId: z.ZodUUID;
+            accessToken: z.ZodString;
+            refreshToken: z.ZodString;
+            expiresAt: z.ZodISODateTime;
+            refreshExpiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly "catalog.read": z.ZodObject<{
+        revision: z.ZodString;
+        updatedAt: z.ZodISODateTime;
+        provider: z.ZodLiteral<"merchant">;
+        items: z.ZodArray<z.ZodObject<{
+            merchantProductId: z.ZodString;
+            productVersionId: z.ZodUUID;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                subscription: "subscription";
+                credit_pack: "credit_pack";
+            }>;
+            merchantPriceId: z.ZodString;
+            currency: z.ZodString;
+            amountMinor: z.ZodNumber;
+            interval: z.ZodEnum<{
+                month: "month";
+                year: "year";
+                one_time: "one_time";
+            }>;
+            intervalCount: z.ZodLiteral<1>;
+            includedCredits: z.ZodString;
+            creditReset: z.ZodEnum<{
+                month: "month";
+                none: "none";
+            }>;
+            creditPolicyId: z.ZodString;
+            available: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly "customer.commerce.read": z.ZodObject<{
+        customerId: z.ZodUUID;
+        revision: z.ZodString;
+        observedAt: z.ZodISODateTime;
+        subscriptions: z.ZodArray<z.ZodObject<{
+            merchantSubscriptionId: z.ZodString;
+            merchantProductId: z.ZodString;
+            productVersionId: z.ZodNullable<z.ZodUUID>;
+            status: z.ZodEnum<{
+                active: "active";
+                expired: "expired";
+                trialing: "trialing";
+                past_due: "past_due";
+                cancelled: "cancelled";
+            }>;
+            currentPeriodStartsAt: z.ZodNullable<z.ZodISODateTime>;
+            currentPeriodEndsAt: z.ZodNullable<z.ZodISODateTime>;
+            cancelAtPeriodEnd: z.ZodBoolean;
+            scheduledChange: z.ZodNullable<z.ZodObject<{
+                effectiveAt: z.ZodISODateTime;
+                merchantProductId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        purchaseHistory: z.ZodObject<{
+            complete: z.ZodBoolean;
+            hasPaidPurchase: z.ZodBoolean;
+            lastPaidAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        balances: z.ZodArray<z.ZodObject<{
+            bucketId: z.ZodString;
+            key: z.ZodString;
+            available: z.ZodString;
+            expiresAt: z.ZodNullable<z.ZodISODateTime>;
+            nextResetAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly "presentation.resolve": z.ZodObject<{
+        nativeUserId: z.ZodString;
+        presentation: z.ZodNullable<z.ZodObject<{
+            customerId: z.ZodUUID;
+            decisionId: z.ZodUUID;
+            offeringVersionId: z.ZodUUID;
+            paywallVersionId: z.ZodUUID;
+            variant: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly "presentation.report": z.ZodObject<{
+        queued: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly "purchase.execute": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"purchase">;
+        merchantOrderId: z.ZodNullable<z.ZodString>;
+        paymentStatus: z.ZodEnum<{
+            unknown: "unknown";
+            not_started: "not_started";
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+            not_required: "not_required";
+            expired: "expired";
+        }>;
+        checkoutUrl: z.ZodNullable<z.ZodURL>;
+        checkoutExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subscription_change">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            scheduled: "scheduled";
+        }>;
+        merchantSubscriptionId: z.ZodString;
+        scheduledFor: z.ZodNullable<z.ZodISODateTime>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refund">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        merchantRefundId: z.ZodNullable<z.ZodString>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>], "type">;
+    readonly "operation.read": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        lookup: z.ZodLiteral<"found">;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"purchase">;
+            merchantOrderId: z.ZodNullable<z.ZodString>;
+            paymentStatus: z.ZodEnum<{
+                unknown: "unknown";
+                not_started: "not_started";
+                pending: "pending";
+                failed: "failed";
+                succeeded: "succeeded";
+                not_required: "not_required";
+                expired: "expired";
+            }>;
+            checkoutUrl: z.ZodNullable<z.ZodURL>;
+            checkoutExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+            operationId: z.ZodUUID;
+            customerId: z.ZodUUID;
+            merchantExecutionId: z.ZodString;
+            fulfillmentStatus: z.ZodEnum<{
+                not_started: "not_started";
+                pending: "pending";
+                applied: "applied";
+                failed: "failed";
+                not_applicable: "not_applicable";
+            }>;
+            recordingStatus: z.ZodEnum<{
+                pending: "pending";
+                failed: "failed";
+                not_ready: "not_ready";
+                accepted: "accepted";
+            }>;
+            updatedAt: z.ZodISODateTime;
+            problem: z.ZodNullable<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    payment: "payment";
+                    execution: "execution";
+                    fulfillment: "fulfillment";
+                    recording: "recording";
+                }>;
+                code: z.ZodEnum<{
+                    INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                    UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                    PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                    UNAUTHENTICATED: "UNAUTHENTICATED";
+                    FORBIDDEN: "FORBIDDEN";
+                    SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                    INVALID_REQUEST: "INVALID_REQUEST";
+                    NOT_FOUND: "NOT_FOUND";
+                    CONFLICT: "CONFLICT";
+                    PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                    RATE_LIMITED: "RATE_LIMITED";
+                    SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                    NOT_CONFIGURED: "NOT_CONFIGURED";
+                    CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                    INTERNAL_ERROR: "INTERNAL_ERROR";
+                }>;
+                reason: z.ZodOptional<z.ZodEnum<{
+                    CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                    INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                    PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                    PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                    IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                    RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                    STATE_CHANGED: "STATE_CHANGED";
+                    OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                    FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+                }>>;
+                recovery: z.ZodEnum<{
+                    fix_request: "fix_request";
+                    authenticate: "authenticate";
+                    check_permissions: "check_permissions";
+                    check_scope: "check_scope";
+                    resolve_conflict: "resolve_conflict";
+                    reload_state: "reload_state";
+                    retry_same_request: "retry_same_request";
+                    configure_integration: "configure_integration";
+                    check_availability: "check_availability";
+                    upgrade_sdk: "upgrade_sdk";
+                    recover_operation: "recover_operation";
+                    contact_support: "contact_support";
+                }>;
+                retryable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pollAfterMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"subscription_change">;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                pending: "pending";
+                applied: "applied";
+                failed: "failed";
+                scheduled: "scheduled";
+            }>;
+            merchantSubscriptionId: z.ZodString;
+            scheduledFor: z.ZodNullable<z.ZodISODateTime>;
+            operationId: z.ZodUUID;
+            customerId: z.ZodUUID;
+            merchantExecutionId: z.ZodString;
+            fulfillmentStatus: z.ZodEnum<{
+                not_started: "not_started";
+                pending: "pending";
+                applied: "applied";
+                failed: "failed";
+                not_applicable: "not_applicable";
+            }>;
+            recordingStatus: z.ZodEnum<{
+                pending: "pending";
+                failed: "failed";
+                not_ready: "not_ready";
+                accepted: "accepted";
+            }>;
+            updatedAt: z.ZodISODateTime;
+            problem: z.ZodNullable<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    payment: "payment";
+                    execution: "execution";
+                    fulfillment: "fulfillment";
+                    recording: "recording";
+                }>;
+                code: z.ZodEnum<{
+                    INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                    UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                    PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                    UNAUTHENTICATED: "UNAUTHENTICATED";
+                    FORBIDDEN: "FORBIDDEN";
+                    SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                    INVALID_REQUEST: "INVALID_REQUEST";
+                    NOT_FOUND: "NOT_FOUND";
+                    CONFLICT: "CONFLICT";
+                    PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                    RATE_LIMITED: "RATE_LIMITED";
+                    SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                    NOT_CONFIGURED: "NOT_CONFIGURED";
+                    CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                    INTERNAL_ERROR: "INTERNAL_ERROR";
+                }>;
+                reason: z.ZodOptional<z.ZodEnum<{
+                    CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                    INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                    PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                    PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                    IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                    RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                    STATE_CHANGED: "STATE_CHANGED";
+                    OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                    FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+                }>>;
+                recovery: z.ZodEnum<{
+                    fix_request: "fix_request";
+                    authenticate: "authenticate";
+                    check_permissions: "check_permissions";
+                    check_scope: "check_scope";
+                    resolve_conflict: "resolve_conflict";
+                    reload_state: "reload_state";
+                    retry_same_request: "retry_same_request";
+                    configure_integration: "configure_integration";
+                    check_availability: "check_availability";
+                    upgrade_sdk: "upgrade_sdk";
+                    recover_operation: "recover_operation";
+                    contact_support: "contact_support";
+                }>;
+                retryable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pollAfterMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"refund">;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                pending: "pending";
+                failed: "failed";
+                succeeded: "succeeded";
+            }>;
+            merchantRefundId: z.ZodNullable<z.ZodString>;
+            operationId: z.ZodUUID;
+            customerId: z.ZodUUID;
+            merchantExecutionId: z.ZodString;
+            fulfillmentStatus: z.ZodEnum<{
+                not_started: "not_started";
+                pending: "pending";
+                applied: "applied";
+                failed: "failed";
+                not_applicable: "not_applicable";
+            }>;
+            recordingStatus: z.ZodEnum<{
+                pending: "pending";
+                failed: "failed";
+                not_ready: "not_ready";
+                accepted: "accepted";
+            }>;
+            updatedAt: z.ZodISODateTime;
+            problem: z.ZodNullable<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    payment: "payment";
+                    execution: "execution";
+                    fulfillment: "fulfillment";
+                    recording: "recording";
+                }>;
+                code: z.ZodEnum<{
+                    INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                    UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                    PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                    UNAUTHENTICATED: "UNAUTHENTICATED";
+                    FORBIDDEN: "FORBIDDEN";
+                    SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                    INVALID_REQUEST: "INVALID_REQUEST";
+                    NOT_FOUND: "NOT_FOUND";
+                    CONFLICT: "CONFLICT";
+                    PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                    RATE_LIMITED: "RATE_LIMITED";
+                    SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                    NOT_CONFIGURED: "NOT_CONFIGURED";
+                    CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                    INTERNAL_ERROR: "INTERNAL_ERROR";
+                }>;
+                reason: z.ZodOptional<z.ZodEnum<{
+                    CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                    INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                    PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                    PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                    IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                    RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                    STATE_CHANGED: "STATE_CHANGED";
+                    OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                    FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+                }>>;
+                recovery: z.ZodEnum<{
+                    fix_request: "fix_request";
+                    authenticate: "authenticate";
+                    check_permissions: "check_permissions";
+                    check_scope: "check_scope";
+                    resolve_conflict: "resolve_conflict";
+                    reload_state: "reload_state";
+                    retry_same_request: "retry_same_request";
+                    configure_integration: "configure_integration";
+                    check_availability: "check_availability";
+                    upgrade_sdk: "upgrade_sdk";
+                    recover_operation: "recover_operation";
+                    contact_support: "contact_support";
+                }>;
+                retryable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pollAfterMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>], "type">;
+        readAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        lookup: z.ZodLiteral<"not_received">;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        execution: z.ZodNull;
+        readAt: z.ZodISODateTime;
+    }, z.core.$strict>], "lookup">;
+    readonly "subscription.change": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"purchase">;
+        merchantOrderId: z.ZodNullable<z.ZodString>;
+        paymentStatus: z.ZodEnum<{
+            unknown: "unknown";
+            not_started: "not_started";
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+            not_required: "not_required";
+            expired: "expired";
+        }>;
+        checkoutUrl: z.ZodNullable<z.ZodURL>;
+        checkoutExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subscription_change">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            scheduled: "scheduled";
+        }>;
+        merchantSubscriptionId: z.ZodString;
+        scheduledFor: z.ZodNullable<z.ZodISODateTime>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refund">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        merchantRefundId: z.ZodNullable<z.ZodString>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>], "type">;
+    readonly "refund.execute": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"purchase">;
+        merchantOrderId: z.ZodNullable<z.ZodString>;
+        paymentStatus: z.ZodEnum<{
+            unknown: "unknown";
+            not_started: "not_started";
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+            not_required: "not_required";
+            expired: "expired";
+        }>;
+        checkoutUrl: z.ZodNullable<z.ZodURL>;
+        checkoutExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subscription_change">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            scheduled: "scheduled";
+        }>;
+        merchantSubscriptionId: z.ZodString;
+        scheduledFor: z.ZodNullable<z.ZodISODateTime>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refund">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pending: "pending";
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        merchantRefundId: z.ZodNullable<z.ZodString>;
+        operationId: z.ZodUUID;
+        customerId: z.ZodUUID;
+        merchantExecutionId: z.ZodString;
+        fulfillmentStatus: z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            applied: "applied";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        recordingStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            not_ready: "not_ready";
+            accepted: "accepted";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        problem: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                payment: "payment";
+                execution: "execution";
+                fulfillment: "fulfillment";
+                recording: "recording";
+            }>;
+            code: z.ZodEnum<{
+                INVALID_PROTOCOL_VERSION: "INVALID_PROTOCOL_VERSION";
+                UNSUPPORTED_PROTOCOL_VERSION: "UNSUPPORTED_PROTOCOL_VERSION";
+                PROTOCOL_RETIRED: "PROTOCOL_RETIRED";
+                UNAUTHENTICATED: "UNAUTHENTICATED";
+                FORBIDDEN: "FORBIDDEN";
+                SCOPE_MISMATCH: "SCOPE_MISMATCH";
+                INVALID_REQUEST: "INVALID_REQUEST";
+                NOT_FOUND: "NOT_FOUND";
+                CONFLICT: "CONFLICT";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                RATE_LIMITED: "RATE_LIMITED";
+                SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+                NOT_CONFIGURED: "NOT_CONFIGURED";
+                CAPABILITY_UNAVAILABLE: "CAPABILITY_UNAVAILABLE";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                CAPABILITY_NOT_ENABLED: "CAPABILITY_NOT_ENABLED";
+                INTEGRATION_MISSING: "INTEGRATION_MISSING";
+                PROVIDER_CREDENTIAL_REJECTED: "PROVIDER_CREDENTIAL_REJECTED";
+                PRICE_BINDING_REQUIRED: "PRICE_BINDING_REQUIRED";
+                IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+                RESULT_UNKNOWN: "RESULT_UNKNOWN";
+                STATE_CHANGED: "STATE_CHANGED";
+                OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS";
+                FUNNEL_VERSION_RETIRED: "FUNNEL_VERSION_RETIRED";
+            }>>;
+            recovery: z.ZodEnum<{
+                fix_request: "fix_request";
+                authenticate: "authenticate";
+                check_permissions: "check_permissions";
+                check_scope: "check_scope";
+                resolve_conflict: "resolve_conflict";
+                reload_state: "reload_state";
+                retry_same_request: "retry_same_request";
+                configure_integration: "configure_integration";
+                check_availability: "check_availability";
+                upgrade_sdk: "upgrade_sdk";
+                recover_operation: "recover_operation";
+                contact_support: "contact_support";
+            }>;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>], "type">;
+};
+declare const merchantBridgeRequestSchema: z.ZodObject<{
+    bridgeVersion: z.ZodLiteral<3>;
+    requestId: z.ZodUUID;
+    scope: z.ZodObject<{
+        projectId: z.ZodUUID;
+        environmentId: z.ZodUUID;
+        environment: z.ZodEnum<{
+            sandbox: "sandbox";
+            live: "live";
+        }>;
+    }, z.core.$strict>;
+    command: z.ZodEnum<{
+        "session.create": "session.create";
+        "catalog.read": "catalog.read";
+        "customer.commerce.read": "customer.commerce.read";
+        "presentation.resolve": "presentation.resolve";
+        "presentation.report": "presentation.report";
+        "purchase.execute": "purchase.execute";
+        "operation.read": "operation.read";
+        "subscription.change": "subscription.change";
+        "refund.execute": "refund.execute";
+        "bridge.ping": "bridge.ping";
+        "bridge.describe": "bridge.describe";
+    }>;
+    data: z.ZodUnknown;
+}, z.core.$strict>;
+type MerchantBridgeRequest = z.infer<typeof merchantBridgeRequestSchema>;
+declare const funnelConfigurationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    evaluationMode: z.ZodLiteral<"local">;
+    growth: z.ZodObject<{
+        scope: z.ZodObject<{
+            projectId: z.ZodString;
+            environment: z.ZodEnum<{
+                sandbox: "sandbox";
+                live: "live";
+            }>;
+        }, z.core.$strict>;
+        generation: z.ZodString;
+        evaluatedAt: z.ZodISODateTime;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        features: z.ZodRecord<z.ZodString, z.ZodObject<{
+            defaultValue: z.ZodOptional<z.ZodJSONSchema>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                force: z.ZodOptional<z.ZodJSONSchema>;
+                variations: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                key: z.ZodOptional<z.ZodString>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                tracks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    experiment: z.ZodObject<{
+                        key: z.ZodString;
+                        variations: z.ZodTuple<[z.ZodJSONSchema, z.ZodJSONSchema], z.ZodJSONSchema>;
+                        urlPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            include: z.ZodBoolean;
+                            type: z.ZodEnum<{
+                                regex: "regex";
+                                simple: "simple";
+                            }>;
+                            pattern: z.ZodString;
+                        }, z.core.$strict>>>;
+                        force: z.ZodOptional<z.ZodNumber>;
+                        active: z.ZodOptional<z.ZodBoolean>;
+                        persistQueryString: z.ZodOptional<z.ZodBoolean>;
+                        condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                        parentConditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                            gate: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strict>>>;
+                        weights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                        coverage: z.ZodOptional<z.ZodNumber>;
+                        hashAttribute: z.ZodOptional<z.ZodString>;
+                        fallbackAttribute: z.ZodOptional<z.ZodString>;
+                        hashVersion: z.ZodOptional<z.ZodLiteral<2>>;
+                        disableStickyBucketing: z.ZodOptional<z.ZodBoolean>;
+                        bucketVersion: z.ZodOptional<z.ZodNumber>;
+                        minBucketVersion: z.ZodOptional<z.ZodNumber>;
+                        filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            attribute: z.ZodOptional<z.ZodString>;
+                            seed: z.ZodString;
+                            hashVersion: z.ZodLiteral<2>;
+                            ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                        }, z.core.$strict>>>;
+                        ranges: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                        meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            key: z.ZodOptional<z.ZodString>;
+                            name: z.ZodOptional<z.ZodString>;
+                            passthrough: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strict>>>;
+                        seed: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                        phase: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    result: z.ZodObject<{
+                        value: z.ZodJSONSchema;
+                        variationId: z.ZodNumber;
+                        key: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                        bucket: z.ZodOptional<z.ZodNumber>;
+                        passthrough: z.ZodOptional<z.ZodBoolean>;
+                        inExperiment: z.ZodBoolean;
+                        hashUsed: z.ZodOptional<z.ZodBoolean>;
+                        hashAttribute: z.ZodString;
+                        hashValue: z.ZodString;
+                        featureId: z.ZodNullable<z.ZodString>;
+                        stickyBucketUsed: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+                condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                parentConditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                    gate: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                weights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                coverage: z.ZodOptional<z.ZodNumber>;
+                hashAttribute: z.ZodOptional<z.ZodString>;
+                fallbackAttribute: z.ZodOptional<z.ZodString>;
+                hashVersion: z.ZodOptional<z.ZodLiteral<2>>;
+                disableStickyBucketing: z.ZodOptional<z.ZodBoolean>;
+                bucketVersion: z.ZodOptional<z.ZodNumber>;
+                minBucketVersion: z.ZodOptional<z.ZodNumber>;
+                filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    attribute: z.ZodOptional<z.ZodString>;
+                    seed: z.ZodString;
+                    hashVersion: z.ZodLiteral<2>;
+                    ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strict>>>;
+                ranges: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    passthrough: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                seed: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                phase: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        savedGroups: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"hashed">;
+            attributeKey: z.ZodString;
+            values: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"list">;
+            attributeKey: z.ZodString;
+            values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"condition">;
+            condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>]>>;
+        experiments: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+            key: z.ZodString;
+            variations: z.ZodTuple<[z.ZodJSONSchema, z.ZodJSONSchema], z.ZodJSONSchema>;
+            urlPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                include: z.ZodBoolean;
+                type: z.ZodEnum<{
+                    regex: "regex";
+                    simple: "simple";
+                }>;
+                pattern: z.ZodString;
+            }, z.core.$strict>>>;
+            force: z.ZodOptional<z.ZodNumber>;
+            active: z.ZodOptional<z.ZodBoolean>;
+            persistQueryString: z.ZodOptional<z.ZodBoolean>;
+            condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            parentConditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                gate: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            weights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            coverage: z.ZodOptional<z.ZodNumber>;
+            hashAttribute: z.ZodOptional<z.ZodString>;
+            fallbackAttribute: z.ZodOptional<z.ZodString>;
+            hashVersion: z.ZodOptional<z.ZodLiteral<2>>;
+            disableStickyBucketing: z.ZodOptional<z.ZodBoolean>;
+            bucketVersion: z.ZodOptional<z.ZodNumber>;
+            minBucketVersion: z.ZodOptional<z.ZodNumber>;
+            filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attribute: z.ZodOptional<z.ZodString>;
+                seed: z.ZodString;
+                hashVersion: z.ZodLiteral<2>;
+                ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>>;
+            ranges: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                passthrough: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            seed: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            phase: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    conditions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        port: z.ZodString;
+    }, z.core.$strict>>>;
+    scope: z.ZodObject<{
+        projectId: z.ZodString;
+        environment: z.ZodEnum<{
+            sandbox: "sandbox";
+            live: "live";
+        }>;
+    }, z.core.$strict>;
+    funnelId: z.ZodUUID;
+    versionId: z.ZodUUID;
+    evaluationRevision: z.ZodNumber;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    topology: z.ZodObject<{
+        entry: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                output: "output";
+                action: "action";
+                split: "split";
+                feature: "feature";
+                condition: "condition";
+                entry: "entry";
+                coupon: "coupon";
+                end: "end";
+                screen: "screen";
+                offering: "offering";
+                coupons: "coupons";
+                external_page: "external_page";
+                wait: "wait";
+            }>;
+            outputs: z.ZodRecord<z.ZodString, z.ZodString>;
+            writes: z.ZodRecord<z.ZodString, z.ZodString>;
+            resources: z.ZodObject<{
+                screenId: z.ZodOptional<z.ZodString>;
+                paywallVersionId: z.ZodOptional<z.ZodUUID>;
+                couponId: z.ZodOptional<z.ZodUUID>;
+                couponIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+                experimentId: z.ZodOptional<z.ZodUUID>;
+                featureKey: z.ZodOptional<z.ZodString>;
+                offeringVersionId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    evaluationMode: z.ZodLiteral<"remote">;
+    scope: z.ZodObject<{
+        projectId: z.ZodString;
+        environment: z.ZodEnum<{
+            sandbox: "sandbox";
+            live: "live";
+        }>;
+    }, z.core.$strict>;
+    funnelId: z.ZodUUID;
+    versionId: z.ZodUUID;
+    evaluationRevision: z.ZodNumber;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    topology: z.ZodObject<{
+        entry: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                output: "output";
+                action: "action";
+                split: "split";
+                feature: "feature";
+                condition: "condition";
+                entry: "entry";
+                coupon: "coupon";
+                end: "end";
+                screen: "screen";
+                offering: "offering";
+                coupons: "coupons";
+                external_page: "external_page";
+                wait: "wait";
+            }>;
+            outputs: z.ZodRecord<z.ZodString, z.ZodString>;
+            writes: z.ZodRecord<z.ZodString, z.ZodString>;
+            resources: z.ZodObject<{
+                screenId: z.ZodOptional<z.ZodString>;
+                paywallVersionId: z.ZodOptional<z.ZodUUID>;
+                couponId: z.ZodOptional<z.ZodUUID>;
+                couponIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+                experimentId: z.ZodOptional<z.ZodUUID>;
+                featureKey: z.ZodOptional<z.ZodString>;
+                offeringVersionId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "evaluationMode">;
+type FunnelConfiguration = z.infer<typeof funnelConfigurationSchema>;
+/** Dedicated pure-evaluation delivery; existing configuration responses retain their exact contract. */
+declare const funnelLocalConfigurationSchema: z.ZodObject<{
+    evaluationMode: z.ZodLiteral<"local">;
+    growth: z.ZodObject<{
+        scope: z.ZodObject<{
+            projectId: z.ZodString;
+            environment: z.ZodEnum<{
+                sandbox: "sandbox";
+                live: "live";
+            }>;
+        }, z.core.$strict>;
+        generation: z.ZodString;
+        evaluatedAt: z.ZodISODateTime;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        features: z.ZodRecord<z.ZodString, z.ZodObject<{
+            defaultValue: z.ZodOptional<z.ZodJSONSchema>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                force: z.ZodOptional<z.ZodJSONSchema>;
+                variations: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                key: z.ZodOptional<z.ZodString>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                tracks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    experiment: z.ZodObject<{
+                        key: z.ZodString;
+                        variations: z.ZodTuple<[z.ZodJSONSchema, z.ZodJSONSchema], z.ZodJSONSchema>;
+                        urlPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            include: z.ZodBoolean;
+                            type: z.ZodEnum<{
+                                regex: "regex";
+                                simple: "simple";
+                            }>;
+                            pattern: z.ZodString;
+                        }, z.core.$strict>>>;
+                        force: z.ZodOptional<z.ZodNumber>;
+                        active: z.ZodOptional<z.ZodBoolean>;
+                        persistQueryString: z.ZodOptional<z.ZodBoolean>;
+                        condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                        parentConditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                            gate: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strict>>>;
+                        weights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                        coverage: z.ZodOptional<z.ZodNumber>;
+                        hashAttribute: z.ZodOptional<z.ZodString>;
+                        fallbackAttribute: z.ZodOptional<z.ZodString>;
+                        hashVersion: z.ZodOptional<z.ZodLiteral<2>>;
+                        disableStickyBucketing: z.ZodOptional<z.ZodBoolean>;
+                        bucketVersion: z.ZodOptional<z.ZodNumber>;
+                        minBucketVersion: z.ZodOptional<z.ZodNumber>;
+                        filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            attribute: z.ZodOptional<z.ZodString>;
+                            seed: z.ZodString;
+                            hashVersion: z.ZodLiteral<2>;
+                            ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                        }, z.core.$strict>>>;
+                        ranges: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                        meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            key: z.ZodOptional<z.ZodString>;
+                            name: z.ZodOptional<z.ZodString>;
+                            passthrough: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strict>>>;
+                        seed: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                        phase: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    result: z.ZodObject<{
+                        value: z.ZodJSONSchema;
+                        variationId: z.ZodNumber;
+                        key: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                        bucket: z.ZodOptional<z.ZodNumber>;
+                        passthrough: z.ZodOptional<z.ZodBoolean>;
+                        inExperiment: z.ZodBoolean;
+                        hashUsed: z.ZodOptional<z.ZodBoolean>;
+                        hashAttribute: z.ZodString;
+                        hashValue: z.ZodString;
+                        featureId: z.ZodNullable<z.ZodString>;
+                        stickyBucketUsed: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+                condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                parentConditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                    gate: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                weights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                coverage: z.ZodOptional<z.ZodNumber>;
+                hashAttribute: z.ZodOptional<z.ZodString>;
+                fallbackAttribute: z.ZodOptional<z.ZodString>;
+                hashVersion: z.ZodOptional<z.ZodLiteral<2>>;
+                disableStickyBucketing: z.ZodOptional<z.ZodBoolean>;
+                bucketVersion: z.ZodOptional<z.ZodNumber>;
+                minBucketVersion: z.ZodOptional<z.ZodNumber>;
+                filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    attribute: z.ZodOptional<z.ZodString>;
+                    seed: z.ZodString;
+                    hashVersion: z.ZodLiteral<2>;
+                    ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strict>>>;
+                ranges: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    passthrough: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                seed: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                phase: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        savedGroups: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"hashed">;
+            attributeKey: z.ZodString;
+            values: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"list">;
+            attributeKey: z.ZodString;
+            values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"condition">;
+            condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>]>>;
+        experiments: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+            key: z.ZodString;
+            variations: z.ZodTuple<[z.ZodJSONSchema, z.ZodJSONSchema], z.ZodJSONSchema>;
+            urlPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                include: z.ZodBoolean;
+                type: z.ZodEnum<{
+                    regex: "regex";
+                    simple: "simple";
+                }>;
+                pattern: z.ZodString;
+            }, z.core.$strict>>>;
+            force: z.ZodOptional<z.ZodNumber>;
+            active: z.ZodOptional<z.ZodBoolean>;
+            persistQueryString: z.ZodOptional<z.ZodBoolean>;
+            condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            parentConditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                gate: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            weights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            coverage: z.ZodOptional<z.ZodNumber>;
+            hashAttribute: z.ZodOptional<z.ZodString>;
+            fallbackAttribute: z.ZodOptional<z.ZodString>;
+            hashVersion: z.ZodOptional<z.ZodLiteral<2>>;
+            disableStickyBucketing: z.ZodOptional<z.ZodBoolean>;
+            bucketVersion: z.ZodOptional<z.ZodNumber>;
+            minBucketVersion: z.ZodOptional<z.ZodNumber>;
+            filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attribute: z.ZodOptional<z.ZodString>;
+                seed: z.ZodString;
+                hashVersion: z.ZodLiteral<2>;
+                ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strict>>>;
+            ranges: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                passthrough: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            seed: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            phase: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    conditions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        condition: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        port: z.ZodString;
+    }, z.core.$strict>>>;
+    scope: z.ZodObject<{
+        projectId: z.ZodString;
+        environment: z.ZodEnum<{
+            sandbox: "sandbox";
+            live: "live";
+        }>;
+    }, z.core.$strict>;
+    funnelId: z.ZodUUID;
+    versionId: z.ZodUUID;
+    evaluationRevision: z.ZodNumber;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    topology: z.ZodObject<{
+        entry: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                output: "output";
+                action: "action";
+                split: "split";
+                feature: "feature";
+                condition: "condition";
+                entry: "entry";
+                coupon: "coupon";
+                end: "end";
+                screen: "screen";
+                offering: "offering";
+                coupons: "coupons";
+                external_page: "external_page";
+                wait: "wait";
+            }>;
+            outputs: z.ZodRecord<z.ZodString, z.ZodString>;
+            writes: z.ZodRecord<z.ZodString, z.ZodString>;
+            resources: z.ZodObject<{
+                screenId: z.ZodOptional<z.ZodString>;
+                paywallVersionId: z.ZodOptional<z.ZodUUID>;
+                couponId: z.ZodOptional<z.ZodUUID>;
+                couponIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+                experimentId: z.ZodOptional<z.ZodUUID>;
+                featureKey: z.ZodOptional<z.ZodString>;
+                offeringVersionId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evaluation: z.ZodObject<{
+        maxTransitions: z.ZodNumber;
+        variables: z.ZodRecord<z.ZodString, z.ZodObject<{
+            nullable: z.ZodBoolean;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                array: "array";
+                strings: "strings";
+                json: "json";
+                offering_version: "offering_version";
+                reward: "reward";
+                paywall_version: "paywall_version";
+            }>;
+            items: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    strings: "strings";
+                    json: "json";
+                    offering_version: "offering_version";
+                    reward: "reward";
+                    paywall_version: "paywall_version";
+                }>;
+                nullable: z.ZodBoolean;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"input">;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"node">;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodEnum<{
+                    attribute: "attribute";
+                    parameter: "parameter";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>>;
+        outputSchema: z.ZodObject<{
+            nullable: z.ZodBoolean;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                array: "array";
+                strings: "strings";
+                json: "json";
+                offering_version: "offering_version";
+                reward: "reward";
+                paywall_version: "paywall_version";
+            }>;
+            items: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    strings: "strings";
+                    json: "json";
+                    offering_version: "offering_version";
+                    reward: "reward";
+                    paywall_version: "paywall_version";
+                }>;
+                nullable: z.ZodBoolean;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        terminals: z.ZodRecord<z.ZodString, z.ZodObject<{
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                closed: "closed";
+                ineligible: "ineligible";
+            }>;
+            output: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"literal">;
+                value: z.ZodJSONSchema;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"variable">;
+                key: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"feature">;
+                featureKey: z.ZodString;
+            }, z.core.$strict>], "type">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type FunnelLocalConfiguration = z.infer<typeof funnelLocalConfigurationSchema>;
+type FunnelNodeEvaluationContext = Pick<EvaluationContext, "attributes" | "stickyBucketAssignmentDocs" | "saveStickyBucketAssignmentDoc" | "onFeatureUsage" | "onExperimentViewed">;
+/** Pure rule evaluation, never a command or permission to perform a commercial action. No network I/O. */
+declare function evaluateFunnelNode(configuration: FunnelConfiguration, nodeId: string, input: FunnelNodeEvaluationContext): {
+    nodeId: string;
+    port: string;
+    target: string;
+    value?: JsonValue;
+};
+export { type FunnelNodeEvaluationContext as F, type MerchantBridgeManifest as M, type FunnelLocalConfiguration as a, type MerchantBridgeCommand as b, type MerchantBridgeRequest as c, merchantBridgeCommandInputs as d, evaluateFunnelNode as e, merchantBridgeCommandOutputs as f, merchantBridgeOperationInputSchema as g, merchantBridgeOperationAuthoritySchema as m };