autumn-js 0.1.42 → 0.1.43

package/dist/next/client/NextAutumnClient.d.mts

@@ -0,0 +1,253 @@
+import { a as AutumnPromise, R as Result, g as CheckResult, d as SetupPaymentResult, Q as QueryResult, A as AttachParams, C as CancelParams, c as CancelResult, f as CheckParams, T as TrackParams, b as TrackResult, O as OpenBillingPortalParams } from './clientAttachTypes-yOuJqDWt.mjs';
+import { C as CheckoutResult, a as CreateReferralCodeResult, R as RedeemReferralCodeResult, A as AttachResult, b as CreateEntityParams, G as GetEntityParams } from './clientEntTypes-aLfa3lyP.mjs';
+import { C as CustomerData, b as CreateCustomerParams, a as Customer, B as BillingPortalResult } from './cusTypes-CXjHwB-c.mjs';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-BkN-Puru.mjs';
+import { A as AutumnError } from './error-DHbclCVh.mjs';
+import { P as Product } from './prodTypes-B_VMILpU.mjs';
+import 'zod/v4';
+
+interface AutumnClientConfig {
+    backendUrl?: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    customerData?: CustomerData;
+    includeCredentials?: boolean;
+    betterAuthUrl?: string;
+    headers?: Record<string, string>;
+    pathPrefix?: string;
+}
+interface IAutumnClient {
+    readonly backendUrl?: string;
+    readonly prefix: string;
+    readonly headers?: Record<string, string>;
+    readonly customerData?: CustomerData;
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<any>;
+    detectCors(): Promise<{
+        valid: boolean;
+        includeCredentials: boolean | undefined;
+    }>;
+    shouldIncludeCredentials(): Promise<boolean>;
+    getHeaders(): Promise<Record<string, string>>;
+    handleFetch(options: {
+        path: string;
+        method: string;
+        body?: any;
+    }): Promise<any>;
+    post(path: string, body: any): Promise<any>;
+    get(path: string): Promise<any>;
+    delete(path: string): Promise<any>;
+    attach(args: any): Promise<any>;
+    checkout(args: any): Promise<any>;
+    cancel(args: any): Promise<any>;
+    check(args: any): Promise<any>;
+    track(args: any): Promise<any>;
+    openBillingPortal(args: any): Promise<any>;
+    setupPayment(args: any): Promise<any>;
+    query(args: any): Promise<any>;
+    entities: {
+        create(args: any): Promise<any>;
+        get(entityId: string, args: any): Promise<any>;
+        delete(args: any): Promise<any>;
+    };
+    referrals: {
+        createCode(args: any): Promise<any>;
+        redeemCode(args: any): Promise<any>;
+    };
+    products: {
+        list(): AutumnPromise<{
+            list: Product[];
+        }>;
+    };
+}
+declare class AutumnClient implements IAutumnClient {
+    readonly backendUrl?: string;
+    protected readonly getBearerToken?: () => Promise<string | null | undefined>;
+    readonly customerData?: CustomerData;
+    protected includeCredentials?: boolean;
+    readonly prefix: string;
+    readonly camelCase: boolean;
+    readonly headers?: Record<string, string>;
+    readonly framework?: string;
+    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, betterAuthUrl, headers, pathPrefix, }: AutumnClientConfig);
+    /**
+     * Detects if the backend supports CORS credentials by making an OPTIONS request
+     */
+    detectCors(): Promise<{
+        valid: boolean;
+        includeCredentials: boolean;
+    } | {
+        valid: boolean;
+        includeCredentials: undefined;
+    }>;
+    /**
+     * Automatically determines whether to include credentials based on CORS detection
+     */
+    shouldIncludeCredentials(): Promise<boolean>;
+    getHeaders(): Promise<Record<string, string>>;
+    handleFetch({ path, method, body, }: {
+        path: string;
+        method: string;
+        body?: Record<string, unknown> | Record<string, unknown>[];
+    }): Promise<Result<any, AutumnError>>;
+    post(path: string, body: Record<string, unknown> | Record<string, unknown>[]): Promise<Result<any, AutumnError>>;
+    get(path: string): Promise<Result<any, AutumnError>>;
+    delete(path: string): Promise<Result<any, AutumnError>>;
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<Result<Customer, AutumnError>>;
+    attach: (params: {
+        productId?: string | undefined;
+        entityId?: string | undefined;
+        options?: {
+            featureId: string;
+            quantity: number;
+        }[] | undefined;
+        productIds?: string[] | undefined;
+        freeTrial?: boolean | undefined;
+        successUrl?: string | undefined;
+        metadata?: Record<string, string> | undefined;
+        forceCheckout?: boolean | undefined;
+        dialog?: any;
+        entityData?: any;
+        openInNewTab?: boolean | undefined;
+        reward?: string | undefined;
+        checkoutSessionParams?: Record<string, any> | undefined;
+    }) => AutumnPromise<{
+        customer_id: string;
+        product_ids: string[];
+        code: string;
+        message: string;
+        checkout_url?: string | undefined;
+        customer_data?: any;
+        invoice?: {
+            status: string;
+            stripe_id: string;
+            hosted_invoice_url: string | null;
+            total: number;
+            currency: string;
+        } | undefined;
+    }>;
+    checkout: (params: {
+        productId?: string | undefined;
+        productIds?: string[] | undefined;
+        entityId?: string | undefined;
+        entityData?: any;
+        options?: {
+            featureId: string;
+            quantity: number;
+        }[] | undefined;
+        successUrl?: string | undefined;
+        openInNewTab?: boolean | undefined;
+        dialog?: any;
+        forceCheckout?: boolean | undefined;
+        checkoutSessionParams?: Record<string, any> | undefined;
+        reward?: string | undefined;
+    }) => AutumnPromise<CheckoutResult>;
+    cancel: (params: {
+        productId: string;
+        entityId?: string | undefined;
+        cancelImmediately?: boolean | undefined;
+    }) => AutumnPromise<{
+        success: boolean;
+        customer_id: string;
+        product_id: string;
+    }>;
+    check: (params: {
+        featureId?: string | undefined;
+        productId?: string | undefined;
+        entityId?: string | undefined;
+        requiredBalance?: number | undefined;
+        sendEvent?: boolean | undefined;
+        withPreview?: boolean | undefined;
+        dialog?: any;
+        entityData?: any;
+        properties?: Record<string, any> | undefined;
+    }) => AutumnPromise<CheckResult>;
+    track: (params: {
+        featureId?: string | undefined;
+        eventName?: string | undefined;
+        entityId?: string | undefined;
+        value?: number | undefined;
+        idempotencyKey?: string | undefined;
+        entityData?: any;
+    }) => AutumnPromise<{
+        id: string;
+        code: string;
+        customer_id: string;
+        feature_id?: string | undefined;
+        event_name?: string | undefined;
+    }>;
+    openBillingPortal: (params?: {
+        returnUrl?: string | undefined;
+        openInNewTab?: boolean | undefined;
+    } | undefined) => AutumnPromise<BillingPortalResult>;
+    setupPayment: (params: {
+        successUrl?: string | undefined;
+        checkoutSessionParams?: Record<string, any> | undefined;
+        openInNewTab?: boolean | undefined;
+    }) => AutumnPromise<SetupPaymentResult>;
+    query: (params: {
+        featureId: string | string[];
+        range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | undefined;
+    }) => AutumnPromise<QueryResult>;
+    entities: {
+        create: (params: {
+            id: string;
+            featureId: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            featureId: string;
+            name?: string | undefined;
+        }[]) => AutumnPromise<Entity | Entity[]>;
+        get: (entityId: string, params?: {
+            expand?: string[] | undefined;
+        } | undefined) => AutumnPromise<Entity>;
+        delete: (entityId: string) => AutumnPromise<DeleteEntityResult>;
+    };
+    referrals: {
+        createCode: (params: {
+            programId: string;
+        }) => AutumnPromise<CreateReferralCodeResult>;
+        redeemCode: (params: {
+            code: string;
+        }) => AutumnPromise<RedeemReferralCodeResult>;
+    };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
+    };
+}
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+type OmitCustomerType = "id" | "name" | "email" | "fingerprint" | "customer_id";
+interface NextAutumnClientConfig {
+    encryptedCustomerId?: string;
+    customerData?: CustomerData;
+}
+declare class NextAutumnClient extends AutumnClient {
+    private readonly encryptedCustomerId?;
+    constructor({ encryptedCustomerId, customerData }: NextAutumnClientConfig);
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<any>;
+    getPricingTable(): Promise<any>;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => Promise<any>;
+    entities: {
+        create: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
+        get: (entityId: string, params?: GetEntityParams) => AutumnPromise<Entity>;
+        delete: (entityId: string) => AutumnPromise<DeleteEntityResult>;
+    };
+    referrals: any;
+}
+
+export { type ErrorResponse, NextAutumnClient, type NextAutumnClientConfig, type OmitCustomerType };

package/dist/next/client/NextAutumnClient.d.ts

@@ -0,0 +1,253 @@
+import { a as AutumnPromise, R as Result, g as CheckResult, d as SetupPaymentResult, Q as QueryResult, A as AttachParams, C as CancelParams, c as CancelResult, f as CheckParams, T as TrackParams, b as TrackResult, O as OpenBillingPortalParams } from './clientAttachTypes-BtZh00uu.js';
+import { C as CheckoutResult, a as CreateReferralCodeResult, R as RedeemReferralCodeResult, A as AttachResult, b as CreateEntityParams, G as GetEntityParams } from './clientEntTypes-Bsi7ciUF.js';
+import { C as CustomerData, b as CreateCustomerParams, a as Customer, B as BillingPortalResult } from './cusTypes-B-rJwpui.js';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-DjKFS-Zk.js';
+import { A as AutumnError } from './error-DHbclCVh.js';
+import { P as Product } from './prodTypes-B_VMILpU.js';
+import 'zod/v4';
+
+interface AutumnClientConfig {
+    backendUrl?: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    customerData?: CustomerData;
+    includeCredentials?: boolean;
+    betterAuthUrl?: string;
+    headers?: Record<string, string>;
+    pathPrefix?: string;
+}
+interface IAutumnClient {
+    readonly backendUrl?: string;
+    readonly prefix: string;
+    readonly headers?: Record<string, string>;
+    readonly customerData?: CustomerData;
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<any>;
+    detectCors(): Promise<{
+        valid: boolean;
+        includeCredentials: boolean | undefined;
+    }>;
+    shouldIncludeCredentials(): Promise<boolean>;
+    getHeaders(): Promise<Record<string, string>>;
+    handleFetch(options: {
+        path: string;
+        method: string;
+        body?: any;
+    }): Promise<any>;
+    post(path: string, body: any): Promise<any>;
+    get(path: string): Promise<any>;
+    delete(path: string): Promise<any>;
+    attach(args: any): Promise<any>;
+    checkout(args: any): Promise<any>;
+    cancel(args: any): Promise<any>;
+    check(args: any): Promise<any>;
+    track(args: any): Promise<any>;
+    openBillingPortal(args: any): Promise<any>;
+    setupPayment(args: any): Promise<any>;
+    query(args: any): Promise<any>;
+    entities: {
+        create(args: any): Promise<any>;
+        get(entityId: string, args: any): Promise<any>;
+        delete(args: any): Promise<any>;
+    };
+    referrals: {
+        createCode(args: any): Promise<any>;
+        redeemCode(args: any): Promise<any>;
+    };
+    products: {
+        list(): AutumnPromise<{
+            list: Product[];
+        }>;
+    };
+}
+declare class AutumnClient implements IAutumnClient {
+    readonly backendUrl?: string;
+    protected readonly getBearerToken?: () => Promise<string | null | undefined>;
+    readonly customerData?: CustomerData;
+    protected includeCredentials?: boolean;
+    readonly prefix: string;
+    readonly camelCase: boolean;
+    readonly headers?: Record<string, string>;
+    readonly framework?: string;
+    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, betterAuthUrl, headers, pathPrefix, }: AutumnClientConfig);
+    /**
+     * Detects if the backend supports CORS credentials by making an OPTIONS request
+     */
+    detectCors(): Promise<{
+        valid: boolean;
+        includeCredentials: boolean;
+    } | {
+        valid: boolean;
+        includeCredentials: undefined;
+    }>;
+    /**
+     * Automatically determines whether to include credentials based on CORS detection
+     */
+    shouldIncludeCredentials(): Promise<boolean>;
+    getHeaders(): Promise<Record<string, string>>;
+    handleFetch({ path, method, body, }: {
+        path: string;
+        method: string;
+        body?: Record<string, unknown> | Record<string, unknown>[];
+    }): Promise<Result<any, AutumnError>>;
+    post(path: string, body: Record<string, unknown> | Record<string, unknown>[]): Promise<Result<any, AutumnError>>;
+    get(path: string): Promise<Result<any, AutumnError>>;
+    delete(path: string): Promise<Result<any, AutumnError>>;
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<Result<Customer, AutumnError>>;
+    attach: (params: {
+        productId?: string | undefined;
+        entityId?: string | undefined;
+        options?: {
+            featureId: string;
+            quantity: number;
+        }[] | undefined;
+        productIds?: string[] | undefined;
+        freeTrial?: boolean | undefined;
+        successUrl?: string | undefined;
+        metadata?: Record<string, string> | undefined;
+        forceCheckout?: boolean | undefined;
+        dialog?: any;
+        entityData?: any;
+        openInNewTab?: boolean | undefined;
+        reward?: string | undefined;
+        checkoutSessionParams?: Record<string, any> | undefined;
+    }) => AutumnPromise<{
+        customer_id: string;
+        product_ids: string[];
+        code: string;
+        message: string;
+        checkout_url?: string | undefined;
+        customer_data?: any;
+        invoice?: {
+            status: string;
+            stripe_id: string;
+            hosted_invoice_url: string | null;
+            total: number;
+            currency: string;
+        } | undefined;
+    }>;
+    checkout: (params: {
+        productId?: string | undefined;
+        productIds?: string[] | undefined;
+        entityId?: string | undefined;
+        entityData?: any;
+        options?: {
+            featureId: string;
+            quantity: number;
+        }[] | undefined;
+        successUrl?: string | undefined;
+        openInNewTab?: boolean | undefined;
+        dialog?: any;
+        forceCheckout?: boolean | undefined;
+        checkoutSessionParams?: Record<string, any> | undefined;
+        reward?: string | undefined;
+    }) => AutumnPromise<CheckoutResult>;
+    cancel: (params: {
+        productId: string;
+        entityId?: string | undefined;
+        cancelImmediately?: boolean | undefined;
+    }) => AutumnPromise<{
+        success: boolean;
+        customer_id: string;
+        product_id: string;
+    }>;
+    check: (params: {
+        featureId?: string | undefined;
+        productId?: string | undefined;
+        entityId?: string | undefined;
+        requiredBalance?: number | undefined;
+        sendEvent?: boolean | undefined;
+        withPreview?: boolean | undefined;
+        dialog?: any;
+        entityData?: any;
+        properties?: Record<string, any> | undefined;
+    }) => AutumnPromise<CheckResult>;
+    track: (params: {
+        featureId?: string | undefined;
+        eventName?: string | undefined;
+        entityId?: string | undefined;
+        value?: number | undefined;
+        idempotencyKey?: string | undefined;
+        entityData?: any;
+    }) => AutumnPromise<{
+        id: string;
+        code: string;
+        customer_id: string;
+        feature_id?: string | undefined;
+        event_name?: string | undefined;
+    }>;
+    openBillingPortal: (params?: {
+        returnUrl?: string | undefined;
+        openInNewTab?: boolean | undefined;
+    } | undefined) => AutumnPromise<BillingPortalResult>;
+    setupPayment: (params: {
+        successUrl?: string | undefined;
+        checkoutSessionParams?: Record<string, any> | undefined;
+        openInNewTab?: boolean | undefined;
+    }) => AutumnPromise<SetupPaymentResult>;
+    query: (params: {
+        featureId: string | string[];
+        range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | undefined;
+    }) => AutumnPromise<QueryResult>;
+    entities: {
+        create: (params: {
+            id: string;
+            featureId: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            featureId: string;
+            name?: string | undefined;
+        }[]) => AutumnPromise<Entity | Entity[]>;
+        get: (entityId: string, params?: {
+            expand?: string[] | undefined;
+        } | undefined) => AutumnPromise<Entity>;
+        delete: (entityId: string) => AutumnPromise<DeleteEntityResult>;
+    };
+    referrals: {
+        createCode: (params: {
+            programId: string;
+        }) => AutumnPromise<CreateReferralCodeResult>;
+        redeemCode: (params: {
+            code: string;
+        }) => AutumnPromise<RedeemReferralCodeResult>;
+    };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
+    };
+}
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+type OmitCustomerType = "id" | "name" | "email" | "fingerprint" | "customer_id";
+interface NextAutumnClientConfig {
+    encryptedCustomerId?: string;
+    customerData?: CustomerData;
+}
+declare class NextAutumnClient extends AutumnClient {
+    private readonly encryptedCustomerId?;
+    constructor({ encryptedCustomerId, customerData }: NextAutumnClientConfig);
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<any>;
+    getPricingTable(): Promise<any>;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => Promise<any>;
+    entities: {
+        create: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
+        get: (entityId: string, params?: GetEntityParams) => AutumnPromise<Entity>;
+        delete: (entityId: string) => AutumnPromise<DeleteEntityResult>;
+    };
+    referrals: any;
+}
+
+export { type ErrorResponse, NextAutumnClient, type NextAutumnClientConfig, type OmitCustomerType };

package/dist/next/client/NextAutumnProvider.d.mts

@@ -0,0 +1,12 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { C as CustomerData } from './cusTypes-CXjHwB-c.mjs';
+import './prodTypes-B_VMILpU.mjs';
+import 'zod/v4';
+
+declare const NextAutumnProvider: ({ encryptedCustomerId, customerData, children, }: {
+    encryptedCustomerId?: string;
+    customerData?: CustomerData;
+    children: React.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+export { NextAutumnProvider };

package/dist/next/client/NextAutumnProvider.d.ts

@@ -0,0 +1,12 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { C as CustomerData } from './cusTypes-B-rJwpui.js';
+import './prodTypes-B_VMILpU.js';
+import 'zod/v4';
+
+declare const NextAutumnProvider: ({ encryptedCustomerId, customerData, children, }: {
+    encryptedCustomerId?: string;
+    customerData?: CustomerData;
+    children: React.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+export { NextAutumnProvider };

package/dist/next/client/clientAttachTypes-BtZh00uu.d.ts

@@ -0,0 +1,121 @@
+import { C as CheckFeatureResult, c as CheckProductResult } from './prodTypes-B_VMILpU.js';
+import { z } from 'zod/v4';
+import { A as AutumnError } from './error-DHbclCVh.js';
+
+declare const CancelResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    customer_id: z.ZodString;
+    product_id: z.ZodString;
+}, z.core.$strip>;
+type CancelResult = z.infer<typeof CancelResultSchema>;
+declare const TrackResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    customer_id: z.ZodString;
+    feature_id: z.ZodOptional<z.ZodString>;
+    event_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TrackResult = z.infer<typeof TrackResultSchema>;
+type CheckResult = CheckFeatureResult & CheckProductResult;
+interface SetupPaymentResult {
+    customer_id: string;
+    url: string;
+}
+type QueryResult = {
+    list: Array<{
+        period: number;
+    } & {
+        [key: string]: number;
+    }>;
+};
+
+type Success<T> = {
+    data: T;
+    error: null;
+    statusCode?: number;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+    statusCode?: number;
+};
+type Result<T, E> = Success<T> | Failure<E>;
+type AutumnPromise<T> = Promise<Result<T, AutumnError>>;
+
+declare const CancelParamsSchema: z.ZodObject<{
+    productId: z.ZodString;
+    entityId: z.ZodOptional<z.ZodString>;
+    cancelImmediately: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type CancelParams = z.infer<typeof CancelParamsSchema>;
+declare const CheckParamsSchema: z.ZodObject<{
+    featureId: z.ZodOptional<z.ZodString>;
+    productId: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    requiredBalance: z.ZodOptional<z.ZodNumber>;
+    sendEvent: z.ZodOptional<z.ZodBoolean>;
+    withPreview: z.ZodOptional<z.ZodBoolean>;
+    dialog: z.ZodOptional<z.ZodAny>;
+    entityData: z.ZodOptional<z.ZodAny>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+type CheckParams = z.infer<typeof CheckParamsSchema>;
+declare const TrackParamsSchema: z.ZodObject<{
+    featureId: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodNumber>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    entityData: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+type TrackParams = z.infer<typeof TrackParamsSchema>;
+declare const OpenBillingPortalParamsSchema: z.ZodObject<{
+    returnUrl: z.ZodOptional<z.ZodString>;
+    openInNewTab: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type OpenBillingPortalParams = z.infer<typeof OpenBillingPortalParamsSchema>;
+declare const SetupPaymentParamsSchema: z.ZodObject<{
+    successUrl: z.ZodOptional<z.ZodString>;
+    checkoutSessionParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    openInNewTab: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type SetupPaymentParams = z.infer<typeof SetupPaymentParamsSchema>;
+
+declare const AttachParamsSchema: z.ZodObject<{
+    productId: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        featureId: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>>;
+    productIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    freeTrial: z.ZodOptional<z.ZodBoolean>;
+    successUrl: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    forceCheckout: z.ZodOptional<z.ZodBoolean>;
+    dialog: z.ZodOptional<z.ZodAny>;
+    entityData: z.ZodOptional<z.ZodAny>;
+    openInNewTab: z.ZodOptional<z.ZodBoolean>;
+    reward: z.ZodOptional<z.ZodString>;
+    checkoutSessionParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+type AttachParams = z.infer<typeof AttachParamsSchema>;
+declare const CheckoutParamsSchema: z.ZodObject<{
+    productId: z.ZodOptional<z.ZodString>;
+    productIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entityId: z.ZodOptional<z.ZodString>;
+    entityData: z.ZodOptional<z.ZodAny>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        featureId: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>>;
+    successUrl: z.ZodOptional<z.ZodString>;
+    openInNewTab: z.ZodOptional<z.ZodBoolean>;
+    dialog: z.ZodOptional<z.ZodAny>;
+    forceCheckout: z.ZodOptional<z.ZodBoolean>;
+    checkoutSessionParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    reward: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CheckoutParams = z.infer<typeof CheckoutParamsSchema>;
+
+export type { AttachParams as A, CancelParams as C, OpenBillingPortalParams as O, QueryResult as Q, Result as R, SetupPaymentParams as S, TrackParams as T, AutumnPromise as a, TrackResult as b, CancelResult as c, SetupPaymentResult as d, CheckoutParams as e, CheckParams as f, CheckResult as g, Success as h };