@stardeckai/autumn-js 0.1.85

package/dist/sdk/index.d.mts

@@ -0,0 +1,2859 @@
+import { z } from 'zod/v4';
+
+declare const Infinite = "inf";
+declare enum FreeTrialDuration {
+    Day = "day"
+}
+declare enum UsageModel {
+    Prepaid = "prepaid",
+    PayPerUse = "pay_per_use"
+}
+type UsageModelType = "prepaid" | "pay_per_use";
+declare enum ProductItemInterval {
+    Minute = "minute",
+    Hour = "hour",
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Quarter = "quarter",
+    SemiAnnual = "semi_annual",
+    Year = "year",
+    Multiple = "multiple"
+}
+type ProductItemIntervalType = "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | "multiple";
+
+type CheckFeatureScenario = "usage_limit" | "feature_flag";
+declare const CheckFeatureResultSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    feature_id: z.ZodString;
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    required_balance: z.ZodNumber;
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    interval: z.ZodOptional<z.ZodEnum<typeof ProductItemInterval>>;
+    balance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    usage: z.ZodOptional<z.ZodNumber>;
+    included_usage: z.ZodOptional<z.ZodNumber>;
+    next_reset_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    overage_allowed: z.ZodOptional<z.ZodBoolean>;
+    usage_limit: z.ZodOptional<z.ZodNumber>;
+    rollovers: z.ZodOptional<z.ZodObject<{
+        balance: z.ZodNumber;
+        expires_at: z.ZodNumber;
+    }, z.core.$strip>>;
+    breakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        interval: z.ZodEnum<typeof ProductItemInterval>;
+        balance: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodNumber>;
+        included_usage: z.ZodOptional<z.ZodNumber>;
+        next_reset_at: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    credit_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        credit_amount: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CheckFeatureResult = z.infer<typeof CheckFeatureResultSchema>;
+interface CheckFeaturePreview {
+    scenario: CheckFeatureScenario;
+    title: string;
+    message: string;
+    feature_id: string;
+    feature_name: string;
+    products: Product[];
+}
+type ProductScenario = "scheduled" | "active" | "new" | "renew" | "upgrade" | "downgrade" | "cancel";
+interface CheckProductResult {
+    allowed: boolean;
+    customer_id: string;
+    product_id: string;
+    entity_id?: string;
+    status?: string;
+    preview?: CheckProductPreview;
+}
+interface CheckProductPreview {
+    scenario: ProductScenario;
+    product_id: string;
+    product_name: string;
+    recurring: boolean;
+    error_on_attach?: boolean;
+    next_cycle_at?: number;
+    current_product_name?: string;
+    items?: {
+        price: string;
+        description: string;
+        usage_model?: UsageModelType;
+    }[];
+    options?: {
+        feature_id: string;
+        feature_name: string;
+        billing_units: number;
+        price?: number;
+        tiers?: {
+            to: number | string;
+            amount: number;
+        }[];
+    }[];
+    due_today?: {
+        price: number;
+        currency: string;
+    };
+    due_next_cycle?: {
+        price: number;
+        currency: string;
+    };
+}
+
+declare enum AppEnv {
+    Sandbox = "sandbox",
+    Live = "live"
+}
+
+interface PriceTier {
+    to: number;
+    amount: number | "inf";
+}
+interface Feature$1 {
+    id: string;
+    name: string;
+    type: "boolean" | "continuous_use" | "single_use" | "credit_system";
+}
+interface ProductItem {
+    type?: "feature" | "priced_feature" | "price";
+    feature_id?: string;
+    included_usage?: number | typeof Infinite;
+    interval?: ProductItemIntervalType;
+    feature?: Feature$1;
+    usage_model?: UsageModel;
+    price?: number;
+    billing_units?: number;
+    entity_feature_id?: string;
+    reset_usage_when_enabled?: boolean;
+    quantity?: number;
+    next_cycle_quantity?: number;
+    display?: {
+        primary_text?: string;
+        secondary_text?: string;
+    };
+}
+interface FreeTrial {
+    duration: FreeTrialDuration;
+    length: number;
+    unique_fingerprint: boolean;
+    trial_available?: boolean;
+}
+interface Product {
+    id: string;
+    created_at: number;
+    name: string;
+    env: AppEnv;
+    is_add_on: boolean;
+    is_default: boolean;
+    group: string;
+    version: number;
+    items: ProductItem[];
+    free_trial: FreeTrial | null;
+    scenario?: ProductScenario;
+    base_variant_id: string | null;
+    properties: {
+        is_free: boolean;
+        is_one_off: boolean;
+        interval_group: string;
+        has_trial: boolean;
+        updateable: boolean;
+    };
+    display?: {
+        name?: string;
+        description?: string;
+        button_text?: string;
+        recommend_text?: string;
+        everything_from?: string;
+        button_url?: string;
+    };
+}
+interface CreateProductParams {
+    id: string;
+    name?: string;
+    is_add_on?: boolean;
+    is_default?: boolean;
+    items?: ProductItem[];
+    free_trial?: FreeTrial;
+}
+interface ListProductsParams {
+    customer_id?: string;
+}
+interface DeleteProductParams {
+    all_versions?: boolean;
+}
+
+declare enum ProductStatus {
+    Active = "active",
+    Expired = "expired",
+    Trialing = "trialing",
+    Scheduled = "scheduled",
+    PastDue = "past_due"
+}
+declare const CustomerExpandEnum: z.ZodEnum<{
+    invoices: "invoices";
+    rewards: "rewards";
+    trials_used: "trials_used";
+    entities: "entities";
+    referrals: "referrals";
+    payment_method: "payment_method";
+}>;
+type CustomerExpandOption = "invoices" | "rewards" | "trials_used" | "entities" | "referrals" | "payment_method";
+
+type EntityExpandOption = "invoices";
+
+interface CreateEntityParams {
+    id: string;
+    name: string;
+    feature_id: string;
+    customer_data?: CustomerData;
+}
+interface CreateEntityResult {
+    success: boolean;
+}
+interface DeleteEntityResult {
+    success: boolean;
+}
+interface GetEntityParams {
+    expand?: EntityExpandOption[];
+}
+interface Entity {
+    id: string;
+    name: string;
+    customer_id: string;
+    created_at: number;
+    env: string;
+    products: CustomerProduct[];
+    features: Record<string, CustomerFeature>;
+    invoices?: CustomerInvoice[];
+}
+declare const EntityDataSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    feature_id: z.ZodString;
+}, z.core.$strip>;
+type EntityData = z.infer<typeof EntityDataSchema>;
+declare const TransferProductParamsSchema: z.ZodObject<{
+    from_entity_id: z.ZodString;
+    to_entity_id: z.ZodString;
+    product_id: z.ZodString;
+}, z.core.$strip>;
+type TransferProductParams = z.infer<typeof TransferProductParamsSchema>;
+type TransferProductResult = {
+    success: boolean;
+};
+
+declare const PurchaseLimitIntervalEnum: z.ZodEnum<{
+    hour: "hour";
+    day: "day";
+    week: "week";
+    month: "month";
+}>;
+declare const PurchaseLimitInterval: readonly ["hour", "day", "week", "month"];
+type PurchaseLimitInterval = (typeof PurchaseLimitInterval)[number];
+declare const AutoTopupPurchaseLimitSchema: z.ZodObject<{
+    interval: z.ZodEnum<{
+        hour: "hour";
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+    interval_count: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+declare const AutoTopupSchema: z.ZodObject<{
+    feature_id: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    threshold: z.ZodNumber;
+    quantity: z.ZodNumber;
+    purchase_limit: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodEnum<{
+            hour: "hour";
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+        interval_count: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const CustomerBillingControlsSchema: z.ZodObject<{
+    auto_topups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        threshold: z.ZodNumber;
+        quantity: z.ZodNumber;
+        purchase_limit: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodEnum<{
+                hour: "hour";
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+            interval_count: z.ZodDefault<z.ZodNumber>;
+            limit: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type AutoTopupPurchaseLimit = z.infer<typeof AutoTopupPurchaseLimitSchema>;
+type AutoTopup = z.infer<typeof AutoTopupSchema>;
+type CustomerBillingControls = z.infer<typeof CustomerBillingControlsSchema>;
+declare const CoreCusFeatureSchema: z.ZodObject<{
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    interval: z.ZodOptional<z.ZodEnum<typeof ProductItemInterval>>;
+    balance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    usage: z.ZodOptional<z.ZodNumber>;
+    included_usage: z.ZodOptional<z.ZodNumber>;
+    next_reset_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    overage_allowed: z.ZodOptional<z.ZodBoolean>;
+    usage_limit: z.ZodOptional<z.ZodNumber>;
+    rollovers: z.ZodOptional<z.ZodObject<{
+        balance: z.ZodNumber;
+        expires_at: z.ZodNumber;
+    }, z.core.$strip>>;
+    breakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        interval: z.ZodEnum<typeof ProductItemInterval>;
+        balance: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodNumber>;
+        included_usage: z.ZodOptional<z.ZodNumber>;
+        next_reset_at: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    credit_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        credit_amount: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CoreCustomerFeature = z.infer<typeof CoreCusFeatureSchema>;
+interface CustomerFeature extends CoreCustomerFeature {
+    id: string;
+    name: string;
+    type: "static" | "single_use" | "continuous_use";
+}
+interface CustomerReferral {
+    program_id: string;
+    customer: {
+        id: string;
+        name: string | null;
+        email: string | null;
+    };
+    reward_applied: boolean;
+    created_at: number;
+}
+interface CustomerProduct {
+    id: string;
+    name: string | null;
+    group: string | null;
+    status: ProductStatus;
+    started_at: number;
+    canceled_at: number | null;
+    version: number;
+    subscription_ids?: string[] | null;
+    current_period_start?: number | null;
+    current_period_end?: number | null;
+    trial_ends_at?: number;
+    entity_id?: string;
+    is_add_on: boolean;
+    is_default: boolean;
+    items: ProductItem[];
+}
+interface Customer {
+    id: string | null;
+    created_at: number;
+    name: string | null;
+    email: string | null;
+    fingerprint: string | null;
+    stripe_id: string | null;
+    env: AppEnv;
+    metadata: Record<string, any>;
+    send_email_receipts: boolean;
+    billing_controls: CustomerBillingControls;
+    products: CustomerProduct[];
+    features: Record<string, CustomerFeature>;
+    payment_method?: any;
+    referrals?: CustomerReferral[];
+}
+/**
+ * Maps expand option strings to their corresponding types.
+ * Used for conditional type expansion based on the expand parameter.
+ */
+interface CustomerExpandedFields {
+    invoices: CustomerInvoice[];
+    entities: Entity[];
+    referrals: CustomerReferral[];
+    rewards: unknown;
+    trials_used: unknown;
+    payment_method: unknown;
+}
+/**
+ * Utility type that creates a Customer with additional expanded fields
+ * based on the expand array passed to the API.
+ *
+ * @example
+ * // Base customer without expanded fields
+ * type Base = ExpandedCustomer<[]>;
+ *
+ * // Customer with invoices and entities expanded
+ * type WithExpansion = ExpandedCustomer<['invoices', 'entities']>;
+ * // Result: Customer & { invoices: CustomerInvoice[]; entities: Entity[] }
+ */
+type ExpandedCustomer<T extends readonly CustomerExpandOption[] = readonly []> = Customer & {
+    [K in T[number]]: CustomerExpandedFields[K];
+};
+declare const CustomerDataSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type CustomerData = z.infer<typeof CustomerDataSchema>;
+interface GetCustomerParams<T extends readonly CustomerExpandOption[] = readonly []> {
+    expand?: T;
+}
+declare const CreateCustomerParamsSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    expand: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        invoices: "invoices";
+        rewards: "rewards";
+        trials_used: "trials_used";
+        entities: "entities";
+        referrals: "referrals";
+        payment_method: "payment_method";
+    }>>>;
+    stripe_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    auto_enable_plan_id: z.ZodOptional<z.ZodString>;
+    billing_controls: z.ZodOptional<z.ZodObject<{
+        auto_topups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature_id: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodNumber;
+            quantity: z.ZodNumber;
+            purchase_limit: z.ZodOptional<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+                interval_count: z.ZodDefault<z.ZodNumber>;
+                limit: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CreateCustomerParamsBase = z.infer<typeof CreateCustomerParamsSchema>;
+/**
+ * Generic version of CreateCustomerParams that preserves the expand array type
+ * for proper ExpandedCustomer inference.
+ */
+interface CreateCustomerParams<T extends readonly CustomerExpandOption[] = readonly []> extends Omit<CreateCustomerParamsBase, "expand"> {
+    expand?: T;
+}
+interface UpdateCustomerParams {
+    id?: string | null;
+    name?: string | null;
+    email?: string | null;
+    fingerprint?: string | null;
+    metadata?: Record<string, any>;
+    stripe_id?: string;
+    billing_controls?: CustomerBillingControls;
+}
+declare const BillingPortalParamsSchema: z.ZodObject<{
+    return_url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type BillingPortalParams = z.infer<typeof BillingPortalParamsSchema>;
+interface BillingPortalResult {
+    customer_id: string;
+    url: string;
+}
+interface CustomerInvoice {
+    product_ids: string[];
+    stripe_id: string;
+    status: string;
+    total: number;
+    currency: string;
+    created_at: number;
+    hosted_invoice_url: string;
+}
+declare const UpdateBalancesParamsSchema: z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+    feature_id: z.ZodString;
+    balance: z.ZodNumber;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    feature_id: z.ZodString;
+    balance: z.ZodNumber;
+}, z.core.$strip>>]>, z.ZodObject<{
+    entity_id: z.ZodOptional<z.ZodString>;
+    balances: z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        balance: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+declare const DeleteCustomerParamsSchema: z.ZodObject<{
+    delete_in_stripe: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ListCustomersParamsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ListCustomersParams = z.infer<typeof ListCustomersParamsSchema>;
+type DeleteCustomerParams = z.infer<typeof DeleteCustomerParamsSchema>;
+type UpdateBalancesParams = z.infer<typeof UpdateBalancesParamsSchema>;
+type UpdateBalancesResult = {
+    success: boolean;
+};
+
+declare const LockParamsSchema: z.ZodObject<{
+    lock_id: z.ZodString;
+    enabled: z.ZodLiteral<true>;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type LockParams = z.infer<typeof LockParamsSchema>;
+declare const CancelParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    product_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    cancel_immediately: z.ZodOptional<z.ZodBoolean>;
+    prorate: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type CancelParams = z.infer<typeof CancelParamsSchema>;
+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 TrackParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    value: z.ZodOptional<z.ZodNumber>;
+    feature_id: z.ZodOptional<z.ZodString>;
+    event_name: z.ZodOptional<z.ZodString>;
+    entity_id: z.ZodOptional<z.ZodString>;
+    customer_data: z.ZodOptional<z.ZodAny>;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+    entity_data: z.ZodOptional<z.ZodAny>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    lock: z.ZodOptional<z.ZodObject<{
+        lock_id: z.ZodString;
+        enabled: z.ZodLiteral<true>;
+        expires_at: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TrackParams = z.infer<typeof TrackParamsSchema>;
+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>;
+declare const CheckParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    feature_id: z.ZodOptional<z.ZodString>;
+    product_id: z.ZodOptional<z.ZodString>;
+    entity_id: z.ZodOptional<z.ZodString>;
+    customer_data: z.ZodOptional<z.ZodAny>;
+    required_balance: z.ZodOptional<z.ZodNumber>;
+    send_event: z.ZodOptional<z.ZodBoolean>;
+    with_preview: z.ZodOptional<z.ZodBoolean>;
+    entity_data: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        feature_id: z.ZodString;
+    }, z.core.$strip>>;
+    lock: z.ZodOptional<z.ZodObject<{
+        lock_id: z.ZodString;
+        enabled: z.ZodLiteral<true>;
+        expires_at: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CheckParams = z.infer<typeof CheckParamsSchema>;
+type CheckResult = CheckFeatureResult & CheckProductResult;
+interface UsageParams {
+    customer_id: string;
+    feature_id: string;
+    value: number;
+    customer_data?: CustomerData;
+}
+interface UsageResult {
+    code: string;
+    customer_id: string;
+    feature_id: string;
+}
+interface SetupPaymentParams$1 {
+    customer_id: string;
+    success_url?: string;
+    checkout_session_params?: Record<string, any>;
+}
+interface SetupPaymentResult {
+    customer_id: string;
+    url: string;
+}
+
+declare const AttachFeatureOptionsSchema: z.ZodObject<{
+    feature_id: z.ZodString;
+    quantity: z.ZodNumber;
+}, z.core.$strip>;
+type AttachFeatureOptions = z.infer<typeof AttachFeatureOptionsSchema>;
+declare const AttachParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    product_id: z.ZodOptional<z.ZodString>;
+    entity_id: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>>;
+    product_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    free_trial: z.ZodOptional<z.ZodBoolean>;
+    success_url: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    force_checkout: z.ZodOptional<z.ZodBoolean>;
+    customer_data: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    entity_data: z.ZodOptional<z.ZodAny>;
+    checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    reward: z.ZodOptional<z.ZodString>;
+    invoice: z.ZodOptional<z.ZodBoolean>;
+    new_billing_subscription: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type AttachParams = z.infer<typeof AttachParamsSchema>;
+declare const AttachResultSchema: z.ZodObject<{
+    checkout_url: z.ZodOptional<z.ZodString>;
+    customer_id: z.ZodString;
+    product_ids: z.ZodArray<z.ZodString>;
+    code: z.ZodString;
+    message: z.ZodString;
+    customer_data: z.ZodOptional<z.ZodAny>;
+    invoice: z.ZodOptional<z.ZodObject<{
+        status: z.ZodString;
+        stripe_id: z.ZodString;
+        hosted_invoice_url: z.ZodNullable<z.ZodString>;
+        total: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AttachResult = z.infer<typeof AttachResultSchema>;
+declare const CheckoutParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    product_id: z.ZodString;
+    product_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entity_id: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>>;
+    force_checkout: z.ZodOptional<z.ZodBoolean>;
+    invoice: z.ZodOptional<z.ZodBoolean>;
+    success_url: z.ZodOptional<z.ZodString>;
+    customer_data: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    entity_data: z.ZodOptional<z.ZodAny>;
+    checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    reward: z.ZodOptional<z.ZodString>;
+    new_billing_subscription: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type CheckoutParams = z.infer<typeof CheckoutParamsSchema>;
+type CheckoutResult = {
+    url?: string;
+    customer_id: string;
+    has_prorations: boolean;
+    lines: {
+        description: string;
+        amount: number;
+        item: ProductItem;
+    }[];
+    total: number;
+    currency: string;
+    options: AttachFeatureOptions[];
+    product: Product;
+    current_product: Product;
+    free_trial?: boolean;
+    next_cycle?: {
+        starts_at: number;
+        total: number;
+    };
+};
+
+declare const QueryRangeEnum: z.ZodEnum<{
+    "24h": "24h";
+    "7d": "7d";
+    "30d": "30d";
+    "90d": "90d";
+    last_cycle: "last_cycle";
+    "1bc": "1bc";
+    "3bc": "3bc";
+}>;
+declare const BinSizeEnum: z.ZodEnum<{
+    hour: "hour";
+    day: "day";
+}>;
+declare const QueryParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    feature_id: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>;
+    range: z.ZodOptional<z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        last_cycle: "last_cycle";
+        "1bc": "1bc";
+        "3bc": "3bc";
+    }>>;
+    group_by: z.ZodOptional<z.ZodString>;
+    bin_size: z.ZodOptional<z.ZodEnum<{
+        hour: "hour";
+        day: "day";
+    }>>;
+    custom_range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type QueryParams = z.infer<typeof QueryParamsSchema>;
+type QueryResult = {
+    list: Array<{
+        period: number;
+    } & {
+        [key: string]: number | Record<string, number>;
+    }>;
+};
+declare const EventsListParamsSchema: z.ZodObject<{
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    customer_id: z.ZodString;
+    feature_id: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>;
+    custom_range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        end: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EventsListParams = z.infer<typeof EventsListParamsSchema>;
+declare const EventsListItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    feature_id: z.ZodString;
+    customer_id: z.ZodString;
+    value: z.ZodNumber;
+    properties: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>;
+type EventsListItem = z.infer<typeof EventsListItemSchema>;
+declare const EventsListResponseSchema: z.ZodObject<{
+    list: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        feature_id: z.ZodString;
+        customer_id: z.ZodString;
+        value: z.ZodNumber;
+        properties: z.ZodObject<{}, z.core.$strip>;
+    }, z.core.$strip>>;
+    has_more: z.ZodBoolean;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+type EventsListResponse = z.infer<typeof EventsListResponseSchema>;
+
+declare enum FeatureType {
+    Boolean = "boolean",
+    SingleUse = "single_use",
+    ContinuousUse = "continuous_use",
+    CreditSystem = "credit_system"
+}
+declare const FeatureSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<typeof FeatureType>;
+    display: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        singular: z.ZodString;
+        plural: z.ZodString;
+    }, z.core.$strip>>>;
+    credit_schema: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        metered_feature_id: z.ZodString;
+        credit_cost: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    archived: z.ZodBoolean;
+}, z.core.$strip>;
+type Feature = z.infer<typeof FeatureSchema>;
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+declare class AutumnError extends Error {
+    readonly message: string;
+    readonly code: string;
+    constructor(response: ErrorResponse);
+    static fromError(error: any): AutumnError;
+    toString(): string;
+    toJSON(): {
+        message: string;
+        code: string;
+    };
+}
+type AutumnErrorWithStatus = AutumnError & {
+    statusCode?: number;
+};
+
+type Success<T> = {
+    data: T;
+    error: null;
+    statusCode?: number;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+    statusCode?: number;
+};
+declare const toContainerResult: ({ response, logger, logError, }: {
+    response: Response;
+    logger: Console;
+    logError?: boolean;
+}) => Promise<Result<any, AutumnError>>;
+type Result<T, E> = Success<T> | Failure<E>;
+type AutumnPromise<T> = Promise<Result<T, AutumnError>>;
+
+declare class Autumn {
+    private readonly secretKey;
+    private readonly publishableKey;
+    private headers;
+    private url;
+    private logger;
+    readonly defaultReturnUrl?: string;
+    constructor(options?: {
+        secretKey?: string;
+        publishableKey?: string;
+        url?: string;
+        version?: string;
+        headers?: Record<string, string>;
+        logLevel?: string;
+        defaultReturnUrl?: string;
+    });
+    get(path: string): Promise<Result<any, AutumnError>>;
+    post(path: string, body: unknown): Promise<Result<any, AutumnError>>;
+    postWithVersion(path: string, body: unknown, version: string): Promise<Result<any, AutumnError>>;
+    delete(path: string): Promise<Result<any, AutumnError>>;
+    static customers: {
+        list: (params?: ListCustomersParams) => Promise<Result<{
+            list: Customer[];
+            total: number;
+            limit: number;
+            offset: number;
+        }, AutumnError>>;
+        get: <const T extends readonly CustomerExpandOption[] = readonly []>(id: string, params?: GetCustomerParams<T>) => AutumnPromise<ExpandedCustomer<T>>;
+        create: <const T extends readonly CustomerExpandOption[] = readonly []>(params?: CreateCustomerParams<T>) => AutumnPromise<ExpandedCustomer<T>>;
+        update: (id: string, params: UpdateCustomerParams) => Promise<Result<Customer, AutumnError>>;
+        delete: (id: string, params?: DeleteCustomerParams) => Promise<Result<Customer, AutumnError>>;
+        billingPortal: (id: string, params?: BillingPortalParams) => Promise<Result<BillingPortalResult, AutumnError>>;
+        updateBalances: (id: string, params: UpdateBalancesParams) => Promise<Result<UpdateBalancesResult, AutumnError>>;
+    };
+    static products: {
+        get: (id: string) => Promise<Result<Product, AutumnError>>;
+        create: (params?: CreateProductParams) => Promise<Result<Product, AutumnError>>;
+        list: (params?: ListProductsParams) => Promise<Result<{
+            list: Product[];
+        }, AutumnError>>;
+        delete: (id: string) => Promise<Result<{
+            success: boolean;
+        }, AutumnError>>;
+    };
+    static entities: {
+        get: (customer_id: string, entity_id: string, params?: GetEntityParams) => Promise<Result<Entity, AutumnError>>;
+        create: (customer_id: string, params?: CreateEntityParams | CreateEntityParams[]) => Promise<Result<CreateEntityResult, AutumnError>>;
+        transfer: (customer_id: string, params: TransferProductParams) => Promise<Result<TransferProductResult, AutumnError>>;
+        delete: (customer_id: string, entity_id: string) => Promise<Result<DeleteEntityResult, AutumnError>>;
+    };
+    static referrals: {
+        createCode: (params: CreateReferralCodeParams) => Promise<Result<CreateReferralCodeResult, AutumnError>>;
+        redeemCode: (params: RedeemReferralCodeParams) => Promise<Result<RedeemReferralCodeResult, AutumnError>>;
+    };
+    static features: {
+        list: () => Promise<Result<{
+            list: Feature[];
+        }, AutumnError>>;
+        get: (id: string) => Promise<Result<{
+            id: string;
+            name: string;
+            type: FeatureType;
+            archived: boolean;
+            display?: {
+                singular: string;
+                plural: string;
+            } | null | undefined;
+            credit_schema?: {
+                metered_feature_id: string;
+                credit_cost: number;
+            }[] | null | undefined;
+        }, AutumnError>>;
+    };
+    static events: {
+        list: (params: EventsListParams) => Promise<Result<{
+            list: {
+                id: string;
+                timestamp: number;
+                feature_id: string;
+                customer_id: string;
+                value: number;
+                properties: Record<string, never>;
+            }[];
+            has_more: boolean;
+            offset: number;
+            limit: number;
+            total: number;
+        }, AutumnError>>;
+        aggregate: (params: QueryParams) => Promise<Result<QueryResult, AutumnError>>;
+    };
+    static balances: {
+        create: (params: CreateBalanceParams) => Promise<Result<CreateBalanceResponse, AutumnError>>;
+    };
+    static v2: {
+        billing: {
+            attach: (params: BillingAttachParams) => Promise<Result<{
+                customer_id: string;
+                payment_url: string | null;
+                entity_id?: string | undefined;
+                invoice?: {
+                    status: string | null;
+                    stripe_id: string;
+                    total: number;
+                    currency: string;
+                    hosted_invoice_url: string | null;
+                } | undefined;
+                required_action?: {
+                    code: "3ds_required" | "payment_method_required" | "payment_failed";
+                    reason: string;
+                } | undefined;
+            }, AutumnError>>;
+            update: (params: BillingUpdateParams) => Promise<Result<{
+                customer_id: string;
+                payment_url: string | null;
+                entity_id?: string | undefined;
+                invoice?: {
+                    status: string | null;
+                    stripe_id: string;
+                    total: number;
+                    currency: string;
+                    hosted_invoice_url: string | null;
+                } | undefined;
+                required_action?: {
+                    code: "3ds_required" | "payment_method_required" | "payment_failed";
+                    reason: string;
+                } | undefined;
+            }, AutumnError>>;
+            previewAttach: (params: BillingAttachParams) => Promise<Result<{
+                customer_id: string;
+                line_items: {
+                    title: string;
+                    description: string;
+                    amount: number;
+                }[];
+                total: number;
+                currency: string;
+                next_cycle?: {
+                    starts_at: number;
+                    total: number;
+                } | undefined;
+            }, AutumnError>>;
+            previewUpdate: (params: BillingUpdateParams) => Promise<Result<{
+                customer_id: string;
+                line_items: {
+                    title: string;
+                    description: string;
+                    amount: number;
+                }[];
+                total: number;
+                currency: string;
+                next_cycle?: {
+                    starts_at: number;
+                    total: number;
+                } | undefined;
+            }, AutumnError>>;
+            multiAttach: (params: MultiAttachParams) => Promise<Result<{
+                customer_id: string;
+                payment_url: string | null;
+                entity_id?: string | undefined;
+                invoice?: {
+                    status: string | null;
+                    stripe_id: string;
+                    total: number;
+                    currency: string;
+                    hosted_invoice_url: string | null;
+                } | undefined;
+                required_action?: {
+                    code: "3ds_required" | "payment_method_required" | "payment_failed";
+                    reason: string;
+                } | undefined;
+            }, AutumnError>>;
+            previewMultiAttach: (params: MultiAttachParams) => Promise<Result<{
+                customer_id: string;
+                line_items: {
+                    title: string;
+                    description: string;
+                    amount: number;
+                }[];
+                total: number;
+                currency: string;
+                next_cycle?: {
+                    starts_at: number;
+                    total: number;
+                } | undefined;
+            }, AutumnError>>;
+            setupPayment: (params: SetupPaymentParams) => Promise<Result<{
+                customer_id: string;
+                url: string;
+                entity_id?: string | undefined;
+            }, AutumnError>>;
+        };
+        balances: {
+            update: (params: V2UpdateBalanceParams) => Promise<Result<{
+                message: string;
+            }, AutumnError>>;
+            finalize: (params: V2FinalizeLockParams) => Promise<Result<{
+                success: true;
+            }, AutumnError>>;
+        };
+    };
+    customers: {
+        list: (params?: ListCustomersParams) => Promise<Result<{
+            list: Customer[];
+            total: number;
+            limit: number;
+            offset: number;
+        }, AutumnError>>;
+        get: <const T extends readonly CustomerExpandOption[] = readonly []>(id: string, params?: GetCustomerParams<T>) => AutumnPromise<ExpandedCustomer<T>>;
+        create: <const T extends readonly CustomerExpandOption[] = readonly []>(params?: CreateCustomerParams<T>) => AutumnPromise<ExpandedCustomer<T>>;
+        update: (id: string, params: UpdateCustomerParams) => Promise<Result<Customer, AutumnError>>;
+        delete: (id: string, params?: DeleteCustomerParams) => Promise<Result<Customer, AutumnError>>;
+        billingPortal: (id: string, params?: BillingPortalParams) => Promise<Result<BillingPortalResult, AutumnError>>;
+        updateBalances: (id: string, params: UpdateBalancesParams) => Promise<Result<UpdateBalancesResult, AutumnError>>;
+    };
+    products: {
+        get: (id: string) => Promise<Result<Product, AutumnError>>;
+        create: (params?: CreateProductParams) => Promise<Result<Product, AutumnError>>;
+        list: (params?: ListProductsParams) => Promise<Result<{
+            list: Product[];
+        }, AutumnError>>;
+        delete: (id: string) => Promise<Result<{
+            success: boolean;
+        }, AutumnError>>;
+    };
+    entities: {
+        get: (customer_id: string, entity_id: string, params?: GetEntityParams) => Promise<Result<Entity, AutumnError>>;
+        create: (customer_id: string, params?: CreateEntityParams | CreateEntityParams[]) => Promise<Result<CreateEntityResult, AutumnError>>;
+        transfer: (customer_id: string, params: TransferProductParams) => Promise<Result<TransferProductResult, AutumnError>>;
+        delete: (customer_id: string, entity_id: string) => Promise<Result<DeleteEntityResult, AutumnError>>;
+    };
+    referrals: {
+        createCode: (params: CreateReferralCodeParams) => Promise<Result<CreateReferralCodeResult, AutumnError>>;
+        redeemCode: (params: RedeemReferralCodeParams) => Promise<Result<RedeemReferralCodeResult, AutumnError>>;
+    };
+    features: {
+        list: () => Promise<Result<{
+            list: Feature[];
+        }, AutumnError>>;
+        get: (id: string) => Promise<Result<{
+            id: string;
+            name: string;
+            type: FeatureType;
+            archived: boolean;
+            display?: {
+                singular: string;
+                plural: string;
+            } | null | undefined;
+            credit_schema?: {
+                metered_feature_id: string;
+                credit_cost: number;
+            }[] | null | undefined;
+        }, AutumnError>>;
+    };
+    events: {
+        list: (params: EventsListParams) => Promise<Result<{
+            list: {
+                id: string;
+                timestamp: number;
+                feature_id: string;
+                customer_id: string;
+                value: number;
+                properties: Record<string, never>;
+            }[];
+            has_more: boolean;
+            offset: number;
+            limit: number;
+            total: number;
+        }, AutumnError>>;
+        aggregate: (params: QueryParams) => Promise<Result<QueryResult, AutumnError>>;
+    };
+    balances: {
+        create: (params: CreateBalanceParams) => Promise<Result<CreateBalanceResponse, AutumnError>>;
+    };
+    v2: {
+        billing: {
+            attach: (params: BillingAttachParams) => Promise<Result<{
+                customer_id: string;
+                payment_url: string | null;
+                entity_id?: string | undefined;
+                invoice?: {
+                    status: string | null;
+                    stripe_id: string;
+                    total: number;
+                    currency: string;
+                    hosted_invoice_url: string | null;
+                } | undefined;
+                required_action?: {
+                    code: "3ds_required" | "payment_method_required" | "payment_failed";
+                    reason: string;
+                } | undefined;
+            }, AutumnError>>;
+            update: (params: BillingUpdateParams) => Promise<Result<{
+                customer_id: string;
+                payment_url: string | null;
+                entity_id?: string | undefined;
+                invoice?: {
+                    status: string | null;
+                    stripe_id: string;
+                    total: number;
+                    currency: string;
+                    hosted_invoice_url: string | null;
+                } | undefined;
+                required_action?: {
+                    code: "3ds_required" | "payment_method_required" | "payment_failed";
+                    reason: string;
+                } | undefined;
+            }, AutumnError>>;
+            previewAttach: (params: BillingAttachParams) => Promise<Result<{
+                customer_id: string;
+                line_items: {
+                    title: string;
+                    description: string;
+                    amount: number;
+                }[];
+                total: number;
+                currency: string;
+                next_cycle?: {
+                    starts_at: number;
+                    total: number;
+                } | undefined;
+            }, AutumnError>>;
+            previewUpdate: (params: BillingUpdateParams) => Promise<Result<{
+                customer_id: string;
+                line_items: {
+                    title: string;
+                    description: string;
+                    amount: number;
+                }[];
+                total: number;
+                currency: string;
+                next_cycle?: {
+                    starts_at: number;
+                    total: number;
+                } | undefined;
+            }, AutumnError>>;
+            multiAttach: (params: MultiAttachParams) => Promise<Result<{
+                customer_id: string;
+                payment_url: string | null;
+                entity_id?: string | undefined;
+                invoice?: {
+                    status: string | null;
+                    stripe_id: string;
+                    total: number;
+                    currency: string;
+                    hosted_invoice_url: string | null;
+                } | undefined;
+                required_action?: {
+                    code: "3ds_required" | "payment_method_required" | "payment_failed";
+                    reason: string;
+                } | undefined;
+            }, AutumnError>>;
+            previewMultiAttach: (params: MultiAttachParams) => Promise<Result<{
+                customer_id: string;
+                line_items: {
+                    title: string;
+                    description: string;
+                    amount: number;
+                }[];
+                total: number;
+                currency: string;
+                next_cycle?: {
+                    starts_at: number;
+                    total: number;
+                } | undefined;
+            }, AutumnError>>;
+            setupPayment: (params: SetupPaymentParams) => Promise<Result<{
+                customer_id: string;
+                url: string;
+                entity_id?: string | undefined;
+            }, AutumnError>>;
+        };
+        balances: {
+            update: (params: V2UpdateBalanceParams) => Promise<Result<{
+                message: string;
+            }, AutumnError>>;
+            finalize: (params: V2FinalizeLockParams) => Promise<Result<{
+                success: true;
+            }, AutumnError>>;
+        };
+    };
+    /**
+     * Initiates a checkout flow for a product purchase.
+     *
+     * The checkout function handles the purchase process for products with pricing.
+     * It determines whether to show a dialog for user input or redirect directly
+     * to Stripe based on the customer's state and product requirements.
+     *
+     * @param params - Checkout parameters including product ID, customer data, and options
+     * @returns Promise resolving to checkout details including pricing, prorations, and URLs
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.checkout({
+     *   customer_id: "user_123",
+     *   product_id: "pro",
+     *   success_url: "https://myapp.com/success"
+     * });
+     *
+     * if (result.url) {
+     *   // Redirect to Stripe checkout
+     *   window.location.href = result.url;
+     * }
+     * ```
+     */
+    checkout(params: CheckoutParams): Promise<Result<CheckoutResult, AutumnError>>;
+    static checkout: (params: CheckoutParams) => Promise<Result<CheckoutResult, AutumnError>>;
+    static usage: (params: UsageParams) => Promise<Result<UsageResult, AutumnError>>;
+    /**
+     * Attaches a product to a customer, enabling access and handling billing.
+     *
+     * The attach function activates a product for a customer and applies all product items.
+     * When you attach a product:
+     * - The customer gains access to all features in the product
+     * - If the product has prices, the customer will be billed accordingly
+     * - If there's no existing payment method, a checkout URL will be generated
+     *
+     * @param params - Attach parameters including customer ID, product ID, and options
+     * @returns Promise resolving to attachment result with checkout URL if needed
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.attach({
+     *   customer_id: "user_123",
+     *   product_id: "pro",
+     *   success_url: "https://myapp.com/success"
+     * });
+     *
+     * if (result.checkout_url) {
+     *   // Payment required - redirect to checkout
+     *   window.location.href = result.checkout_url;
+     * } else {
+     *   // Product successfully attached
+     *   console.log("Access granted:", result.message);
+     * }
+     * ```
+     */
+    attach(params: AttachParams): Promise<Result<{
+        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;
+    }, AutumnError>>;
+    static attach: (params: AttachParams) => Promise<Result<{
+        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;
+    }, AutumnError>>;
+    static setupPayment: (params: SetupPaymentParams$1) => Promise<Result<SetupPaymentResult, AutumnError>>;
+    /**
+     * Sets up a payment method for a customer.
+     *
+     * This method allows you to set up payment methods for customers without
+     * immediately charging them. Useful for collecting payment information
+     * before product attachment or for updating existing payment methods.
+     *
+     * @param params - Setup payment parameters including customer information
+     * @returns Promise resolving to setup payment result
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.setupPayment({
+     *   customer_id: "user_123"
+     * });
+     * ```
+     */
+    setupPayment(params: SetupPaymentParams$1): Promise<Result<SetupPaymentResult, AutumnError>>;
+    static cancel: (params: CancelParams) => Promise<Result<{
+        success: boolean;
+        customer_id: string;
+        product_id: string;
+    }, AutumnError>>;
+    /**
+     * Cancels a customer's subscription or product attachment.
+     *
+     * This method allows you to cancel a customer's subscription to a specific product.
+     * You can choose to cancel immediately or at the end of the billing cycle.
+     *
+     * @param params - Cancel parameters including customer ID and product ID
+     * @returns Promise resolving to cancellation result
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.cancel({
+     *   customer_id: "user_123",
+     *   product_id: "pro",
+     *   cancel_immediately: false // Cancel at end of billing cycle
+     * });
+     * ```
+     */
+    cancel(params: CancelParams): Promise<Result<{
+        success: boolean;
+        customer_id: string;
+        product_id: string;
+    }, AutumnError>>;
+    static check: (params: CheckParams) => Promise<Result<CheckResult, AutumnError>>;
+    /**
+     * Checks if a customer has access to a specific feature.
+     *
+     * This method verifies whether a customer has permission to use a feature
+     * and checks their remaining balance/usage limits. It can be used to gate
+     * features and determine when to show upgrade prompts.
+     *
+     * @param params - Check parameters including customer ID and feature ID
+     * @returns Promise resolving to access check result with allowed status and balance info
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.check({
+     *   customer_id: "user_123",
+     *   feature_id: "messages",
+     *   required_balance: 1
+     * });
+     *
+     * if (!result.allowed) {
+     *   console.log("Feature access denied - upgrade required");
+     * }
+     * ```
+     */
+    check(params: CheckParams): Promise<Result<CheckResult, AutumnError>>;
+    static track: (params: TrackParams) => Promise<Result<{
+        id: string;
+        code: string;
+        customer_id: string;
+        feature_id?: string | undefined;
+        event_name?: string | undefined;
+    }, AutumnError>>;
+    /**
+     * Tracks usage events for features or analytics.
+     *
+     * This method records usage events for metered features, updating the customer's
+     * balance and usage statistics. It's typically used server-side to ensure
+     * accurate tracking that cannot be manipulated by users.
+     *
+     * @param params - Track parameters including customer ID, feature ID, and usage value
+     * @returns Promise resolving to tracking result
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.track({
+     *   customer_id: "user_123",
+     *   feature_id: "messages",
+     *   value: 1 // Track 1 message sent
+     * });
+     * ```
+     */
+    track(params: TrackParams): Promise<Result<{
+        id: string;
+        code: string;
+        customer_id: string;
+        feature_id?: string | undefined;
+        event_name?: string | undefined;
+    }, AutumnError>>;
+    /**
+     * Retrieves usage statistics and analytics for a customer.
+     *
+     * This method fetches detailed usage information for a customer's features,
+     * including current balances, usage history, and analytics data. Useful
+     * for displaying usage dashboards or generating reports.
+     *
+     * @param params - Usage parameters including customer ID and optional filters
+     * @returns Promise resolving to usage statistics and analytics data
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.usage({
+     *   customer_id: "user_123",
+     *   feature_id: "messages"
+     *   value: 20 // Usage value
+     * });
+     * ```
+     */
+    usage(params: UsageParams): Promise<Result<UsageResult, AutumnError>>;
+    static query: (params: QueryParams) => Promise<Result<QueryResult, AutumnError>>;
+    /**
+     * Performs advanced queries on customer data and analytics.
+     *
+     * This method allows you to run complex queries against customer data,
+     * usage patterns, and billing information. Useful for generating reports,
+     * analytics, and custom data insights.
+     *
+     * @param params - Query parameters including customer ID and query specifications
+     * @returns Promise resolving to query results with requested data
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.query({
+     *   customer_id: "user_123",
+     *   feature_id: "messages" // feature id to fetch for query, can also be an array
+     * });
+     *
+     * ```
+     */
+    query(params: QueryParams): Promise<Result<QueryResult, AutumnError>>;
+}
+
+interface GetPricingTableParams {
+    customer_id?: string;
+}
+interface PricingTableProduct {
+    id: string;
+    name: string;
+    description?: string;
+    button_text?: string;
+    recommend_text?: string;
+    everything_from?: string;
+    price: {
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem;
+    items: ({
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem)[];
+    scenario: ProductScenario;
+}
+
+declare const fetchPricingTable: ({ instance, params, }: {
+    instance: Autumn;
+    params?: GetPricingTableParams;
+}) => AutumnPromise<PricingTableProduct[]>;
+
+declare const CreateReferralCodeParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    program_id: z.ZodString;
+}, z.core.$strip>;
+type CreateReferralCodeParams = z.infer<typeof CreateReferralCodeParamsSchema>;
+interface CreateReferralCodeResult {
+    code: string;
+    customer_id: string;
+    created_at: number;
+}
+declare const RedeemReferralCodeParamsSchema: z.ZodObject<{
+    code: z.ZodString;
+    customer_id: z.ZodString;
+}, z.core.$strip>;
+type RedeemReferralCodeParams = z.infer<typeof RedeemReferralCodeParamsSchema>;
+interface RedeemReferralCodeResult {
+    id: string;
+    customer_id: string;
+    reward_id: string;
+    referrer: {
+        id: string;
+        name: string | null;
+        email: string | null;
+    };
+}
+
+declare const ResetInterval: readonly ["one_off", "minute", "hour", "day", "week", "month", "quarter", "semi_annual", "year"];
+declare const CreateBalanceParamsSchema: z.ZodObject<{
+    feature_id: z.ZodString;
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    granted_balance: z.ZodOptional<z.ZodNumber>;
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    reset: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodEnum<{
+            one_off: "one_off";
+            minute: "minute";
+            hour: "hour";
+            day: "day";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            semi_annual: "semi_annual";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type CreateBalanceParams = z.infer<typeof CreateBalanceParamsSchema>;
+type CreateBalanceResponse = {
+    message: string;
+};
+
+declare const BillingIntervalSchema: z.ZodEnum<{
+    one_off: "one_off";
+    week: "week";
+    month: "month";
+    quarter: "quarter";
+    semi_annual: "semi_annual";
+    year: "year";
+}>;
+type BillingInterval = z.infer<typeof BillingIntervalSchema>;
+declare const BillingMethodSchema: z.ZodEnum<{
+    prepaid: "prepaid";
+    usage_based: "usage_based";
+}>;
+type BillingMethod = z.infer<typeof BillingMethodSchema>;
+declare const OnIncreaseSchema: z.ZodEnum<{
+    bill_immediately: "bill_immediately";
+    prorate_immediately: "prorate_immediately";
+    prorate_next_cycle: "prorate_next_cycle";
+    bill_next_cycle: "bill_next_cycle";
+}>;
+type OnIncrease = z.infer<typeof OnIncreaseSchema>;
+declare const OnDecreaseSchema: z.ZodEnum<{
+    prorate: "prorate";
+    prorate_immediately: "prorate_immediately";
+    prorate_next_cycle: "prorate_next_cycle";
+    none: "none";
+    no_prorations: "no_prorations";
+}>;
+type OnDecrease = z.infer<typeof OnDecreaseSchema>;
+declare const RolloverExpiryDurationTypeSchema: z.ZodEnum<{
+    month: "month";
+    forever: "forever";
+}>;
+type RolloverExpiryDurationType = z.infer<typeof RolloverExpiryDurationTypeSchema>;
+declare const FeatureQuantityParamsSchema: z.ZodObject<{
+    feature_id: z.ZodString;
+    quantity: z.ZodOptional<z.ZodNumber>;
+    adjustable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type FeatureQuantityParams = z.infer<typeof FeatureQuantityParamsSchema>;
+declare const FreeTrialParamsSchema: z.ZodObject<{
+    duration_length: z.ZodNumber;
+    duration_type: z.ZodDefault<z.ZodEnum<{
+        day: "day";
+        month: "month";
+        year: "year";
+    }>>;
+    card_required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type FreeTrialParams = z.infer<typeof FreeTrialParamsSchema>;
+declare const AttachDiscountSchema: z.ZodUnion<readonly [z.ZodObject<{
+    reward_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    promotion_code: z.ZodString;
+}, z.core.$strip>]>;
+type AttachDiscount = z.infer<typeof AttachDiscountSchema>;
+declare const InvoiceModeParamsSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    enable_plan_immediately: z.ZodDefault<z.ZodBoolean>;
+    finalize: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type InvoiceModeParams = z.infer<typeof InvoiceModeParamsSchema>;
+declare const ProrationBehaviorSchema: z.ZodEnum<{
+    prorate_immediately: "prorate_immediately";
+    none: "none";
+}>;
+type ProrationBehavior = z.infer<typeof ProrationBehaviorSchema>;
+declare const RedirectModeSchema: z.ZodEnum<{
+    never: "never";
+    always: "always";
+    if_required: "if_required";
+}>;
+type RedirectMode = z.infer<typeof RedirectModeSchema>;
+declare const PlanScheduleSchema: z.ZodEnum<{
+    immediate: "immediate";
+    end_of_cycle: "end_of_cycle";
+}>;
+type PlanSchedule = z.infer<typeof PlanScheduleSchema>;
+declare const CancelActionSchema: z.ZodEnum<{
+    cancel_immediately: "cancel_immediately";
+    cancel_end_of_cycle: "cancel_end_of_cycle";
+    uncancel: "uncancel";
+}>;
+type CancelAction = z.infer<typeof CancelActionSchema>;
+declare const UsageTierSchema: z.ZodObject<{
+    to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+type UsageTier = z.infer<typeof UsageTierSchema>;
+declare const BasePriceParamsSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    interval: z.ZodEnum<{
+        one_off: "one_off";
+        week: "week";
+        month: "month";
+        quarter: "quarter";
+        semi_annual: "semi_annual";
+        year: "year";
+    }>;
+    interval_count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type BasePriceParams = z.infer<typeof BasePriceParamsSchema>;
+declare const CreatePlanItemParamsSchema: z.ZodObject<{
+    feature_id: z.ZodString;
+    included: z.ZodOptional<z.ZodNumber>;
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    reset: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodEnum<{
+            one_off: "one_off";
+            minute: "minute";
+            hour: "hour";
+            day: "day";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            semi_annual: "semi_annual";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    price: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodOptional<z.ZodNumber>;
+        tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>>;
+        interval: z.ZodEnum<{
+            one_off: "one_off";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            semi_annual: "semi_annual";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        billing_method: z.ZodEnum<{
+            prepaid: "prepaid";
+            usage_based: "usage_based";
+        }>;
+        max_purchase: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    proration: z.ZodOptional<z.ZodObject<{
+        on_increase: z.ZodEnum<{
+            bill_immediately: "bill_immediately";
+            prorate_immediately: "prorate_immediately";
+            prorate_next_cycle: "prorate_next_cycle";
+            bill_next_cycle: "bill_next_cycle";
+        }>;
+        on_decrease: z.ZodEnum<{
+            prorate: "prorate";
+            prorate_immediately: "prorate_immediately";
+            prorate_next_cycle: "prorate_next_cycle";
+            none: "none";
+            no_prorations: "no_prorations";
+        }>;
+    }, z.core.$strip>>;
+    rollover: z.ZodOptional<z.ZodObject<{
+        max: z.ZodOptional<z.ZodNumber>;
+        expiry_duration_type: z.ZodEnum<{
+            month: "month";
+            forever: "forever";
+        }>;
+        expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CreatePlanItemParams = z.infer<typeof CreatePlanItemParamsSchema>;
+declare const CustomizePlanSchema: z.ZodObject<{
+    price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodNumber;
+        interval: z.ZodEnum<{
+            one_off: "one_off";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            semi_annual: "semi_annual";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        included: z.ZodOptional<z.ZodNumber>;
+        unlimited: z.ZodOptional<z.ZodBoolean>;
+        reset: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                minute: "minute";
+                hour: "hour";
+                day: "day";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        price: z.ZodOptional<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNumber>;
+            tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                amount: z.ZodNumber;
+            }, z.core.$strip>>>;
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            billing_method: z.ZodEnum<{
+                prepaid: "prepaid";
+                usage_based: "usage_based";
+            }>;
+            max_purchase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        proration: z.ZodOptional<z.ZodObject<{
+            on_increase: z.ZodEnum<{
+                bill_immediately: "bill_immediately";
+                prorate_immediately: "prorate_immediately";
+                prorate_next_cycle: "prorate_next_cycle";
+                bill_next_cycle: "bill_next_cycle";
+            }>;
+            on_decrease: z.ZodEnum<{
+                prorate: "prorate";
+                prorate_immediately: "prorate_immediately";
+                prorate_next_cycle: "prorate_next_cycle";
+                none: "none";
+                no_prorations: "no_prorations";
+            }>;
+        }, z.core.$strip>>;
+        rollover: z.ZodOptional<z.ZodObject<{
+            max: z.ZodOptional<z.ZodNumber>;
+            expiry_duration_type: z.ZodEnum<{
+                month: "month";
+                forever: "forever";
+            }>;
+            expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    free_trial: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        duration_length: z.ZodNumber;
+        duration_type: z.ZodDefault<z.ZodEnum<{
+            day: "day";
+            month: "month";
+            year: "year";
+        }>>;
+        card_required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CustomizePlan = z.infer<typeof CustomizePlanSchema>;
+declare const CustomLineItemSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    description: z.ZodString;
+}, z.core.$strip>;
+type CustomLineItem = z.infer<typeof CustomLineItemSchema>;
+declare const BillingAttachParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    feature_quantities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        adjustable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    version: z.ZodOptional<z.ZodNumber>;
+    customize: z.ZodOptional<z.ZodObject<{
+        price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodNumber;
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature_id: z.ZodString;
+            included: z.ZodOptional<z.ZodNumber>;
+            unlimited: z.ZodOptional<z.ZodBoolean>;
+            reset: z.ZodOptional<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    minute: "minute";
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            price: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodOptional<z.ZodNumber>;
+                tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                    amount: z.ZodNumber;
+                }, z.core.$strip>>>;
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_method: z.ZodEnum<{
+                    prepaid: "prepaid";
+                    usage_based: "usage_based";
+                }>;
+                max_purchase: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            proration: z.ZodOptional<z.ZodObject<{
+                on_increase: z.ZodEnum<{
+                    bill_immediately: "bill_immediately";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    bill_next_cycle: "bill_next_cycle";
+                }>;
+                on_decrease: z.ZodEnum<{
+                    prorate: "prorate";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    none: "none";
+                    no_prorations: "no_prorations";
+                }>;
+            }, z.core.$strip>>;
+            rollover: z.ZodOptional<z.ZodObject<{
+                max: z.ZodOptional<z.ZodNumber>;
+                expiry_duration_type: z.ZodEnum<{
+                    month: "month";
+                    forever: "forever";
+                }>;
+                expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        free_trial: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            duration_length: z.ZodNumber;
+            duration_type: z.ZodDefault<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                year: "year";
+            }>>;
+            card_required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    invoice_mode: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        enable_plan_immediately: z.ZodDefault<z.ZodBoolean>;
+        finalize: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    proration_behavior: z.ZodOptional<z.ZodEnum<{
+        prorate_immediately: "prorate_immediately";
+        none: "none";
+    }>>;
+    subscription_id: z.ZodOptional<z.ZodString>;
+    plan_id: z.ZodString;
+    discounts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        reward_id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        promotion_code: z.ZodString;
+    }, z.core.$strip>]>>>;
+    success_url: z.ZodOptional<z.ZodString>;
+    redirect_mode: z.ZodOptional<z.ZodEnum<{
+        never: "never";
+        always: "always";
+        if_required: "if_required";
+    }>>;
+    new_billing_subscription: z.ZodOptional<z.ZodBoolean>;
+    plan_schedule: z.ZodOptional<z.ZodEnum<{
+        immediate: "immediate";
+        end_of_cycle: "end_of_cycle";
+    }>>;
+    checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    custom_line_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type BillingAttachParams = z.infer<typeof BillingAttachParamsSchema>;
+declare const BillingUpdateParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    feature_quantities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        adjustable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    version: z.ZodOptional<z.ZodNumber>;
+    customize: z.ZodOptional<z.ZodObject<{
+        price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodNumber;
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature_id: z.ZodString;
+            included: z.ZodOptional<z.ZodNumber>;
+            unlimited: z.ZodOptional<z.ZodBoolean>;
+            reset: z.ZodOptional<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    minute: "minute";
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            price: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodOptional<z.ZodNumber>;
+                tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                    amount: z.ZodNumber;
+                }, z.core.$strip>>>;
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_method: z.ZodEnum<{
+                    prepaid: "prepaid";
+                    usage_based: "usage_based";
+                }>;
+                max_purchase: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            proration: z.ZodOptional<z.ZodObject<{
+                on_increase: z.ZodEnum<{
+                    bill_immediately: "bill_immediately";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    bill_next_cycle: "bill_next_cycle";
+                }>;
+                on_decrease: z.ZodEnum<{
+                    prorate: "prorate";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    none: "none";
+                    no_prorations: "no_prorations";
+                }>;
+            }, z.core.$strip>>;
+            rollover: z.ZodOptional<z.ZodObject<{
+                max: z.ZodOptional<z.ZodNumber>;
+                expiry_duration_type: z.ZodEnum<{
+                    month: "month";
+                    forever: "forever";
+                }>;
+                expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        free_trial: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            duration_length: z.ZodNumber;
+            duration_type: z.ZodDefault<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                year: "year";
+            }>>;
+            card_required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    invoice_mode: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        enable_plan_immediately: z.ZodDefault<z.ZodBoolean>;
+        finalize: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    proration_behavior: z.ZodOptional<z.ZodEnum<{
+        prorate_immediately: "prorate_immediately";
+        none: "none";
+    }>>;
+    subscription_id: z.ZodOptional<z.ZodString>;
+    plan_id: z.ZodOptional<z.ZodString>;
+    cancel_action: z.ZodOptional<z.ZodEnum<{
+        cancel_immediately: "cancel_immediately";
+        cancel_end_of_cycle: "cancel_end_of_cycle";
+        uncancel: "uncancel";
+    }>>;
+}, z.core.$strip>;
+type BillingUpdateParams = z.infer<typeof BillingUpdateParamsSchema>;
+declare const PaymentFailureCodeSchema: z.ZodEnum<{
+    "3ds_required": "3ds_required";
+    payment_method_required: "payment_method_required";
+    payment_failed: "payment_failed";
+}>;
+type PaymentFailureCode = z.infer<typeof PaymentFailureCodeSchema>;
+declare const BillingRequiredActionSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        "3ds_required": "3ds_required";
+        payment_method_required: "payment_method_required";
+        payment_failed: "payment_failed";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+type BillingRequiredAction = z.infer<typeof BillingRequiredActionSchema>;
+declare const BillingResponseSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    invoice: z.ZodOptional<z.ZodObject<{
+        status: z.ZodNullable<z.ZodString>;
+        stripe_id: z.ZodString;
+        total: z.ZodNumber;
+        currency: z.ZodString;
+        hosted_invoice_url: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    payment_url: z.ZodNullable<z.ZodString>;
+    required_action: z.ZodOptional<z.ZodObject<{
+        code: z.ZodEnum<{
+            "3ds_required": "3ds_required";
+            payment_method_required: "payment_method_required";
+            payment_failed: "payment_failed";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type BillingResponse = z.infer<typeof BillingResponseSchema>;
+declare const MultiAttachCustomizePlanSchema: z.ZodObject<{
+    price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodNumber;
+        interval: z.ZodEnum<{
+            one_off: "one_off";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            semi_annual: "semi_annual";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        included: z.ZodOptional<z.ZodNumber>;
+        unlimited: z.ZodOptional<z.ZodBoolean>;
+        reset: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                minute: "minute";
+                hour: "hour";
+                day: "day";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        price: z.ZodOptional<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNumber>;
+            tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                amount: z.ZodNumber;
+            }, z.core.$strip>>>;
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            billing_method: z.ZodEnum<{
+                prepaid: "prepaid";
+                usage_based: "usage_based";
+            }>;
+            max_purchase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        proration: z.ZodOptional<z.ZodObject<{
+            on_increase: z.ZodEnum<{
+                bill_immediately: "bill_immediately";
+                prorate_immediately: "prorate_immediately";
+                prorate_next_cycle: "prorate_next_cycle";
+                bill_next_cycle: "bill_next_cycle";
+            }>;
+            on_decrease: z.ZodEnum<{
+                prorate: "prorate";
+                prorate_immediately: "prorate_immediately";
+                prorate_next_cycle: "prorate_next_cycle";
+                none: "none";
+                no_prorations: "no_prorations";
+            }>;
+        }, z.core.$strip>>;
+        rollover: z.ZodOptional<z.ZodObject<{
+            max: z.ZodOptional<z.ZodNumber>;
+            expiry_duration_type: z.ZodEnum<{
+                month: "month";
+                forever: "forever";
+            }>;
+            expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type MultiAttachCustomizePlan = z.infer<typeof MultiAttachCustomizePlanSchema>;
+declare const MultiAttachPlanSchema: z.ZodObject<{
+    plan_id: z.ZodString;
+    customize: z.ZodOptional<z.ZodObject<{
+        price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodNumber;
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature_id: z.ZodString;
+            included: z.ZodOptional<z.ZodNumber>;
+            unlimited: z.ZodOptional<z.ZodBoolean>;
+            reset: z.ZodOptional<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    minute: "minute";
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            price: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodOptional<z.ZodNumber>;
+                tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                    amount: z.ZodNumber;
+                }, z.core.$strip>>>;
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_method: z.ZodEnum<{
+                    prepaid: "prepaid";
+                    usage_based: "usage_based";
+                }>;
+                max_purchase: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            proration: z.ZodOptional<z.ZodObject<{
+                on_increase: z.ZodEnum<{
+                    bill_immediately: "bill_immediately";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    bill_next_cycle: "bill_next_cycle";
+                }>;
+                on_decrease: z.ZodEnum<{
+                    prorate: "prorate";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    none: "none";
+                    no_prorations: "no_prorations";
+                }>;
+            }, z.core.$strip>>;
+            rollover: z.ZodOptional<z.ZodObject<{
+                max: z.ZodOptional<z.ZodNumber>;
+                expiry_duration_type: z.ZodEnum<{
+                    month: "month";
+                    forever: "forever";
+                }>;
+                expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    feature_quantities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        adjustable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    version: z.ZodOptional<z.ZodNumber>;
+    subscription_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MultiAttachPlan = z.infer<typeof MultiAttachPlanSchema>;
+declare const MultiAttachParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    plans: z.ZodArray<z.ZodObject<{
+        plan_id: z.ZodString;
+        customize: z.ZodOptional<z.ZodObject<{
+            price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                amount: z.ZodNumber;
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                feature_id: z.ZodString;
+                included: z.ZodOptional<z.ZodNumber>;
+                unlimited: z.ZodOptional<z.ZodBoolean>;
+                reset: z.ZodOptional<z.ZodObject<{
+                    interval: z.ZodEnum<{
+                        one_off: "one_off";
+                        minute: "minute";
+                        hour: "hour";
+                        day: "day";
+                        week: "week";
+                        month: "month";
+                        quarter: "quarter";
+                        semi_annual: "semi_annual";
+                        year: "year";
+                    }>;
+                    interval_count: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                price: z.ZodOptional<z.ZodObject<{
+                    amount: z.ZodOptional<z.ZodNumber>;
+                    tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                        amount: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                    interval: z.ZodEnum<{
+                        one_off: "one_off";
+                        week: "week";
+                        month: "month";
+                        quarter: "quarter";
+                        semi_annual: "semi_annual";
+                        year: "year";
+                    }>;
+                    interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                    billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                    billing_method: z.ZodEnum<{
+                        prepaid: "prepaid";
+                        usage_based: "usage_based";
+                    }>;
+                    max_purchase: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                proration: z.ZodOptional<z.ZodObject<{
+                    on_increase: z.ZodEnum<{
+                        bill_immediately: "bill_immediately";
+                        prorate_immediately: "prorate_immediately";
+                        prorate_next_cycle: "prorate_next_cycle";
+                        bill_next_cycle: "bill_next_cycle";
+                    }>;
+                    on_decrease: z.ZodEnum<{
+                        prorate: "prorate";
+                        prorate_immediately: "prorate_immediately";
+                        prorate_next_cycle: "prorate_next_cycle";
+                        none: "none";
+                        no_prorations: "no_prorations";
+                    }>;
+                }, z.core.$strip>>;
+                rollover: z.ZodOptional<z.ZodObject<{
+                    max: z.ZodOptional<z.ZodNumber>;
+                    expiry_duration_type: z.ZodEnum<{
+                        month: "month";
+                        forever: "forever";
+                    }>;
+                    expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        feature_quantities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature_id: z.ZodString;
+            quantity: z.ZodOptional<z.ZodNumber>;
+            adjustable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        subscription_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    free_trial: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        duration_length: z.ZodNumber;
+        duration_type: z.ZodDefault<z.ZodEnum<{
+            day: "day";
+            month: "month";
+            year: "year";
+        }>>;
+        card_required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    invoice_mode: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        enable_plan_immediately: z.ZodDefault<z.ZodBoolean>;
+        finalize: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    discounts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        reward_id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        promotion_code: z.ZodString;
+    }, z.core.$strip>]>>>;
+    success_url: z.ZodOptional<z.ZodString>;
+    checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    redirect_mode: z.ZodOptional<z.ZodEnum<{
+        never: "never";
+        always: "always";
+        if_required: "if_required";
+    }>>;
+    new_billing_subscription: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type MultiAttachParams = z.infer<typeof MultiAttachParamsSchema>;
+declare const SetupPaymentParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    plan_id: z.ZodOptional<z.ZodString>;
+    feature_quantities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        adjustable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    version: z.ZodOptional<z.ZodNumber>;
+    customize: z.ZodOptional<z.ZodObject<{
+        price: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodNumber;
+            interval: z.ZodEnum<{
+                one_off: "one_off";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                semi_annual: "semi_annual";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature_id: z.ZodString;
+            included: z.ZodOptional<z.ZodNumber>;
+            unlimited: z.ZodOptional<z.ZodBoolean>;
+            reset: z.ZodOptional<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    minute: "minute";
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            price: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodOptional<z.ZodNumber>;
+                tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    to: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"inf">]>;
+                    amount: z.ZodNumber;
+                }, z.core.$strip>>>;
+                interval: z.ZodEnum<{
+                    one_off: "one_off";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    semi_annual: "semi_annual";
+                    year: "year";
+                }>;
+                interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                billing_method: z.ZodEnum<{
+                    prepaid: "prepaid";
+                    usage_based: "usage_based";
+                }>;
+                max_purchase: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            proration: z.ZodOptional<z.ZodObject<{
+                on_increase: z.ZodEnum<{
+                    bill_immediately: "bill_immediately";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    bill_next_cycle: "bill_next_cycle";
+                }>;
+                on_decrease: z.ZodEnum<{
+                    prorate: "prorate";
+                    prorate_immediately: "prorate_immediately";
+                    prorate_next_cycle: "prorate_next_cycle";
+                    none: "none";
+                    no_prorations: "no_prorations";
+                }>;
+            }, z.core.$strip>>;
+            rollover: z.ZodOptional<z.ZodObject<{
+                max: z.ZodOptional<z.ZodNumber>;
+                expiry_duration_type: z.ZodEnum<{
+                    month: "month";
+                    forever: "forever";
+                }>;
+                expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        free_trial: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            duration_length: z.ZodNumber;
+            duration_type: z.ZodDefault<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                year: "year";
+            }>>;
+            card_required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    discounts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        reward_id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        promotion_code: z.ZodString;
+    }, z.core.$strip>]>>>;
+    success_url: z.ZodOptional<z.ZodString>;
+    checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type SetupPaymentParams = z.infer<typeof SetupPaymentParamsSchema>;
+declare const SetupPaymentResponseSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+}, z.core.$strip>;
+type SetupPaymentResponse = z.infer<typeof SetupPaymentResponseSchema>;
+declare const PreviewLineItemSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+type PreviewLineItem = z.infer<typeof PreviewLineItemSchema>;
+declare const BillingPreviewResponseSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    line_items: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    currency: z.ZodString;
+    next_cycle: z.ZodOptional<z.ZodObject<{
+        starts_at: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type BillingPreviewResponse = z.infer<typeof BillingPreviewResponseSchema>;
+
+/**
+ * Creates the v2 billing methods object
+ */
+declare const v2BillingMethods: (instance?: Autumn) => {
+    /**
+     * Attaches a plan to a customer, enabling access and handling billing.
+     *
+     * @param params - Attach parameters including customer ID, plan ID, and options
+     * @returns Promise resolving to billing response with checkout URL if needed
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.v2.billing.attach({
+     *   customer_id: "cus_123",
+     *   plan_id: "pro_plan",
+     *   success_url: "https://myapp.com/success"
+     * });
+     *
+     * if (result.payment_url) {
+     *   // Payment required - redirect to checkout
+     *   window.location.href = result.payment_url;
+     * }
+     * ```
+     */
+    attach: (params: BillingAttachParams) => Promise<Result<{
+        customer_id: string;
+        payment_url: string | null;
+        entity_id?: string | undefined;
+        invoice?: {
+            status: string | null;
+            stripe_id: string;
+            total: number;
+            currency: string;
+            hosted_invoice_url: string | null;
+        } | undefined;
+        required_action?: {
+            code: "3ds_required" | "payment_method_required" | "payment_failed";
+            reason: string;
+        } | undefined;
+    }, AutumnError>>;
+    /**
+     * Updates a customer's subscription, handling plan changes and cancellations.
+     *
+     * @param params - Update parameters including customer ID, plan ID, and cancel action
+     * @returns Promise resolving to billing response with invoice details
+     *
+     * @example
+     * ```typescript
+     * // Update to a new plan
+     * const result = await autumn.v2.billing.update({
+     *   customer_id: "cus_123",
+     *   plan_id: "enterprise_plan",
+     *   feature_quantities: [{ feature_id: "seats", quantity: 10 }]
+     * });
+     *
+     * // Cancel at end of billing cycle
+     * const cancelResult = await autumn.v2.billing.update({
+     *   customer_id: "cus_123",
+     *   plan_id: "pro_plan",
+     *   cancel_action: "cancel_end_of_cycle"
+     * });
+     * ```
+     */
+    update: (params: BillingUpdateParams) => Promise<Result<{
+        customer_id: string;
+        payment_url: string | null;
+        entity_id?: string | undefined;
+        invoice?: {
+            status: string | null;
+            stripe_id: string;
+            total: number;
+            currency: string;
+            hosted_invoice_url: string | null;
+        } | undefined;
+        required_action?: {
+            code: "3ds_required" | "payment_method_required" | "payment_failed";
+            reason: string;
+        } | undefined;
+    }, AutumnError>>;
+    /**
+     * Preview what attaching a plan would cost without actually attaching it.
+     *
+     * @param params - Same parameters as attach
+     * @returns Promise resolving to preview response with line items and totals
+     *
+     * @example
+     * ```typescript
+     * const preview = await autumn.v2.billing.previewAttach({
+     *   customer_id: "cus_123",
+     *   plan_id: "pro_plan"
+     * });
+     *
+     * console.log(`Total: $${preview.total / 100}`);
+     * preview.line_items.forEach(item => {
+     *   console.log(`${item.title}: $${item.amount / 100}`);
+     * });
+     * ```
+     */
+    previewAttach: (params: BillingAttachParams) => Promise<Result<{
+        customer_id: string;
+        line_items: {
+            title: string;
+            description: string;
+            amount: number;
+        }[];
+        total: number;
+        currency: string;
+        next_cycle?: {
+            starts_at: number;
+            total: number;
+        } | undefined;
+    }, AutumnError>>;
+    /**
+     * Preview what updating a subscription would cost without actually updating it.
+     *
+     * @param params - Same parameters as update
+     * @returns Promise resolving to preview response with line items and totals
+     *
+     * @example
+     * ```typescript
+     * const preview = await autumn.v2.billing.previewUpdate({
+     *   customer_id: "cus_123",
+     *   plan_id: "enterprise_plan",
+     *   feature_quantities: [{ feature_id: "seats", quantity: 20 }]
+     * });
+     *
+     * console.log(`Prorated charge: $${preview.total / 100}`);
+     * ```
+     */
+    previewUpdate: (params: BillingUpdateParams) => Promise<Result<{
+        customer_id: string;
+        line_items: {
+            title: string;
+            description: string;
+            amount: number;
+        }[];
+        total: number;
+        currency: string;
+        next_cycle?: {
+            starts_at: number;
+            total: number;
+        } | undefined;
+    }, AutumnError>>;
+    /**
+     * Attaches multiple plans to a customer in a single request.
+     *
+     * @param params - Multi-attach parameters including customer ID and array of plans
+     * @returns Promise resolving to billing response with checkout URL if needed
+     *
+     * @example
+     * ```typescript
+     * const result = await autumn.v2.billing.multiAttach({
+     *   customer_id: "cus_123",
+     *   plans: [
+     *     { plan_id: "base_plan" },
+     *     { plan_id: "addon_plan", feature_quantities: [{ feature_id: "seats", quantity: 5 }] }
+     *   ],
+     *   success_url: "https://myapp.com/success"
+     * });
+     * ```
+     */
+    multiAttach: (params: MultiAttachParams) => Promise<Result<{
+        customer_id: string;
+        payment_url: string | null;
+        entity_id?: string | undefined;
+        invoice?: {
+            status: string | null;
+            stripe_id: string;
+            total: number;
+            currency: string;
+            hosted_invoice_url: string | null;
+        } | undefined;
+        required_action?: {
+            code: "3ds_required" | "payment_method_required" | "payment_failed";
+            reason: string;
+        } | undefined;
+    }, AutumnError>>;
+    /**
+     * Preview what attaching multiple plans would cost without actually attaching them.
+     *
+     * @param params - Same parameters as multiAttach
+     * @returns Promise resolving to preview response with line items and totals
+     *
+     * @example
+     * ```typescript
+     * const preview = await autumn.v2.billing.previewMultiAttach({
+     *   customer_id: "cus_123",
+     *   plans: [
+     *     { plan_id: "base_plan" },
+     *     { plan_id: "addon_plan" }
+     *   ]
+     * });
+     *
+     * console.log(`Total: $${preview.total / 100}`);
+     * ```
+     */
+    previewMultiAttach: (params: MultiAttachParams) => Promise<Result<{
+        customer_id: string;
+        line_items: {
+            title: string;
+            description: string;
+            amount: number;
+        }[];
+        total: number;
+        currency: string;
+        next_cycle?: {
+            starts_at: number;
+            total: number;
+        } | undefined;
+    }, AutumnError>>;
+    /**
+     * Sets up a payment method for a customer. Optionally attach a plan after setup.
+     *
+     * @param params - Setup payment parameters including customer ID and optional plan
+     * @returns Promise resolving to setup payment response with redirect URL
+     *
+     * @example
+     * ```typescript
+     * // Just setup payment method
+     * const result = await autumn.v2.billing.setupPayment({
+     *   customer_id: "cus_123",
+     *   success_url: "https://myapp.com/account"
+     * });
+     *
+     * // Setup payment and attach a plan after
+     * const result = await autumn.v2.billing.setupPayment({
+     *   customer_id: "cus_123",
+     *   plan_id: "pro_plan",
+     *   success_url: "https://myapp.com/success"
+     * });
+     *
+     * // Redirect to Stripe
+     * window.location.href = result.url;
+     * ```
+     */
+    setupPayment: (params: SetupPaymentParams) => Promise<Result<{
+        customer_id: string;
+        url: string;
+        entity_id?: string | undefined;
+    }, AutumnError>>;
+};
+
+declare const V2ResetIntervalSchema: z.ZodEnum<{
+    one_off: "one_off";
+    minute: "minute";
+    hour: "hour";
+    day: "day";
+    week: "week";
+    month: "month";
+    quarter: "quarter";
+    semi_annual: "semi_annual";
+    year: "year";
+}>;
+type V2ResetInterval = z.infer<typeof V2ResetIntervalSchema>;
+declare const V2UpdateBalanceParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    feature_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    remaining: z.ZodOptional<z.ZodNumber>;
+    add_to_balance: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodNumber>;
+    interval: z.ZodOptional<z.ZodEnum<{
+        one_off: "one_off";
+        minute: "minute";
+        hour: "hour";
+        day: "day";
+        week: "week";
+        month: "month";
+        quarter: "quarter";
+        semi_annual: "semi_annual";
+        year: "year";
+    }>>;
+    included_grant: z.ZodOptional<z.ZodNumber>;
+    balance_id: z.ZodOptional<z.ZodString>;
+    next_reset_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type V2UpdateBalanceParams = z.infer<typeof V2UpdateBalanceParamsSchema>;
+declare const V2UpdateBalanceResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+type V2UpdateBalanceResponse = z.infer<typeof V2UpdateBalanceResponseSchema>;
+declare const V2FinalizeLockActionSchema: z.ZodEnum<{
+    confirm: "confirm";
+    release: "release";
+}>;
+type V2FinalizeLockAction = z.infer<typeof V2FinalizeLockActionSchema>;
+declare const V2FinalizeLockParamsSchema: z.ZodObject<{
+    lock_id: z.ZodString;
+    action: z.ZodEnum<{
+        confirm: "confirm";
+        release: "release";
+    }>;
+    override_value: z.ZodOptional<z.ZodNumber>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+type V2FinalizeLockParams = z.infer<typeof V2FinalizeLockParamsSchema>;
+declare const V2FinalizeLockResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+type V2FinalizeLockResponse = z.infer<typeof V2FinalizeLockResponseSchema>;
+
+/**
+ * Creates the v2 balances methods object
+ */
+declare const v2BalancesMethods: (instance?: Autumn) => {
+    /**
+     * Updates a customer's balance for a specific feature.
+     *
+     * @param params - Update balance parameters
+     * @returns Promise resolving to update balance response
+     *
+     * @example
+     * ```typescript
+     * // Set remaining balance to exact value
+     * await autumn.v2.balances.update({
+     *   customer_id: "cus_123",
+     *   feature_id: "api_calls",
+     *   remaining: 1000,
+     * });
+     *
+     * // Add to existing balance
+     * await autumn.v2.balances.update({
+     *   customer_id: "cus_123",
+     *   feature_id: "credits",
+     *   add_to_balance: 500,
+     * });
+     *
+     * // Update usage
+     * await autumn.v2.balances.update({
+     *   customer_id: "cus_123",
+     *   feature_id: "api_calls",
+     *   usage: 100,
+     * });
+     *
+     * // Target specific balance by interval or balance_id
+     * await autumn.v2.balances.update({
+     *   customer_id: "cus_123",
+     *   feature_id: "api_calls",
+     *   balance_id: "bal_xyz",
+     *   remaining: 500,
+     * });
+     * ```
+     */
+    update: (params: V2UpdateBalanceParams) => Promise<Result<{
+        message: string;
+    }, AutumnError>>;
+    /**
+     * Finalizes a balance lock by confirming or releasing it.
+     *
+     * @param params - Finalize lock parameters
+     * @returns Promise resolving to finalize lock response
+     *
+     * @example
+     * ```typescript
+     * // Confirm a lock (deduct the reserved balance)
+     * await autumn.v2.balances.finalize({
+     *   lock_id: "lock_abc123",
+     *   action: "confirm",
+     * });
+     *
+     * // Release a lock (return the reserved balance)
+     * await autumn.v2.balances.finalize({
+     *   lock_id: "lock_abc123",
+     *   action: "release",
+     * });
+     *
+     * // Confirm with a different value than originally reserved
+     * await autumn.v2.balances.finalize({
+     *   lock_id: "lock_abc123",
+     *   action: "confirm",
+     *   override_value: 5,
+     * });
+     * ```
+     */
+    finalize: (params: V2FinalizeLockParams) => Promise<Result<{
+        success: true;
+    }, AutumnError>>;
+};
+
+export { AppEnv, type AttachDiscount, AttachDiscountSchema, type AttachFeatureOptions, AttachFeatureOptionsSchema, type AttachParams, AttachParamsSchema, type AttachResult, AttachResultSchema, type AutoTopup, type AutoTopupPurchaseLimit, AutoTopupPurchaseLimitSchema, AutoTopupSchema, Autumn, AutumnError, type AutumnErrorWithStatus, type AutumnPromise, type BasePriceParams, BasePriceParamsSchema, type BillingAttachParams, BillingAttachParamsSchema, type BillingInterval, BillingIntervalSchema, type BillingMethod, BillingMethodSchema, type BillingPortalParams, BillingPortalParamsSchema, type BillingPortalResult, type BillingPreviewResponse, BillingPreviewResponseSchema, type BillingRequiredAction, BillingRequiredActionSchema, type BillingResponse, BillingResponseSchema, type BillingUpdateParams, BillingUpdateParamsSchema, BinSizeEnum, type CancelAction, CancelActionSchema, type CancelParams, CancelParamsSchema, type CancelResult, CancelResultSchema, type CheckFeaturePreview, type CheckFeatureResult, CheckFeatureResultSchema, type CheckFeatureScenario, type CheckParams, CheckParamsSchema, type CheckProductPreview, type CheckProductResult, type CheckResult, type CheckoutParams, CheckoutParamsSchema, type CheckoutResult, CoreCusFeatureSchema, type CoreCustomerFeature, type CreateBalanceParams, CreateBalanceParamsSchema, type CreateBalanceResponse, type CreateCustomerParams, type CreateCustomerParamsBase, CreateCustomerParamsSchema, type CreateEntityParams, type CreateEntityResult, type CreatePlanItemParams, CreatePlanItemParamsSchema, type CreateProductParams, type CreateReferralCodeParams, CreateReferralCodeParamsSchema, type CreateReferralCodeResult, type CustomLineItem, CustomLineItemSchema, type Customer, type CustomerBillingControls, CustomerBillingControlsSchema, type CustomerData, CustomerDataSchema, CustomerExpandEnum, type CustomerExpandOption, type CustomerExpandedFields, type CustomerFeature, type CustomerInvoice, type CustomerProduct, type CustomerReferral, type CustomizePlan, CustomizePlanSchema, type DeleteCustomerParams, DeleteCustomerParamsSchema, type DeleteEntityResult, type DeleteProductParams, type Entity, type EntityData, EntityDataSchema, type EntityExpandOption, type ErrorResponse, type EventsListItem, EventsListItemSchema, type EventsListParams, EventsListParamsSchema, type EventsListResponse, EventsListResponseSchema, type ExpandedCustomer, type Feature$1 as Feature, type FeatureQuantityParams, FeatureQuantityParamsSchema, FeatureSchema, type FreeTrial, FreeTrialDuration, type FreeTrialParams, FreeTrialParamsSchema, type GetCustomerParams, type GetEntityParams, type GetPricingTableParams, Infinite, type InvoiceModeParams, InvoiceModeParamsSchema, type ListCustomersParams, ListCustomersParamsSchema, type ListProductsParams, type LockParams, LockParamsSchema, type MultiAttachCustomizePlan, MultiAttachCustomizePlanSchema, type MultiAttachParams, MultiAttachParamsSchema, type MultiAttachPlan, MultiAttachPlanSchema, type OnDecrease, OnDecreaseSchema, type OnIncrease, OnIncreaseSchema, type PaymentFailureCode, PaymentFailureCodeSchema, type PlanSchedule, PlanScheduleSchema, type PreviewLineItem, PreviewLineItemSchema, type PriceTier, type PricingTableProduct, type Product, type ProductItem, ProductItemInterval, type ProductItemIntervalType, type ProductScenario, ProductStatus, type ProrationBehavior, ProrationBehaviorSchema, PurchaseLimitInterval, PurchaseLimitIntervalEnum, type QueryParams, QueryParamsSchema, QueryRangeEnum, type QueryResult, type RedeemReferralCodeParams, RedeemReferralCodeParamsSchema, type RedeemReferralCodeResult, type RedirectMode, RedirectModeSchema, ResetInterval, type RolloverExpiryDurationType, RolloverExpiryDurationTypeSchema, type SetupPaymentParams$1 as SetupPaymentParams, type SetupPaymentResponse, SetupPaymentResponseSchema, type SetupPaymentResult, type TrackParams, TrackParamsSchema, type TrackResult, TrackResultSchema, type TransferProductParams, TransferProductParamsSchema, type TransferProductResult, type UpdateBalancesParams, UpdateBalancesParamsSchema, type UpdateBalancesResult, type UpdateCustomerParams, UsageModel, type UsageModelType, type UsageParams, type UsageResult, type UsageTier, UsageTierSchema, type V2FinalizeLockAction, V2FinalizeLockActionSchema, type V2FinalizeLockParams, V2FinalizeLockParamsSchema, type V2FinalizeLockResponse, V2FinalizeLockResponseSchema, type V2ResetInterval, V2ResetIntervalSchema, type SetupPaymentParams as V2SetupPaymentParams, SetupPaymentParamsSchema as V2SetupPaymentParamsSchema, type V2UpdateBalanceParams, V2UpdateBalanceParamsSchema, type V2UpdateBalanceResponse, V2UpdateBalanceResponseSchema, fetchPricingTable, toContainerResult, v2BalancesMethods, v2BillingMethods };