/**
 * SvelteKit-specific Autumn client with SSR support.
 *
 * Extends the vanilla Svelte client with SvelteKit features.
 */
import type { AutumnConvexApi, Customer, Product, CheckParams, CheckResult, CheckoutParams, CheckoutResult, TrackParams, TrackResult, AttachParams, AttachResult, CancelParams, BillingPortalParams, BillingPortalResult, CreateEntityParams, GetEntityParams, SetupPaymentParams, SetupPaymentResult, CreateReferralCodeParams, CreateReferralCodeResult, RedeemReferralCodeParams, RedeemReferralCodeResult, SetUsageParams, SetUsageResult, QueryParams, QueryResult, EventListParams, EventListResult, EventAggregateParams, Entity, LocalCheckResult, RefetchOptions } from "../svelte/types.js";
/**
 * Server state for SSR hydration.
 */
export interface AutumnServerState {
    customer: Customer | null;
    _timeFetched: number;
}
/**
 * SvelteKit's invalidate function type.
 *
 * Import from '$app/navigation' in your consuming application and pass it to the client.
 */
export type InvalidateFunction = (url: string | URL) => Promise<void>;
/**
 * Create an Autumn client for SvelteKit with SSR support.
 *
 * @param params - Configuration options
 * @param params.convexApi - The Autumn Convex API object
 * @param params.getServerState - Optional function to retrieve server state
 * @param params.invalidate - Optional SvelteKit invalidate function for data refetching
 * @returns The Autumn client API with reactive state and methods
 */
export declare function createAutumnClientSvelteKit({ convexApi, getServerState, invalidate, }: {
    convexApi: AutumnConvexApi;
    getServerState?: () => AutumnServerState;
    invalidate?: InvalidateFunction;
}): {
    readonly customer: Customer | null;
    allowed: (params: CheckParams) => LocalCheckResult;
    check: (params: CheckParams, options?: RefetchOptions) => Promise<CheckResult>;
    checkout: (params: CheckoutParams, options?: RefetchOptions) => Promise<CheckoutResult>;
    track: (params: TrackParams, options?: RefetchOptions) => Promise<TrackResult>;
    attach: (params: AttachParams, options?: RefetchOptions) => Promise<AttachResult>;
    cancel: (params: CancelParams, options?: RefetchOptions) => Promise<void>;
    openBillingPortal: (params?: BillingPortalParams) => Promise<BillingPortalResult>;
    createEntity: (params: CreateEntityParams, options?: RefetchOptions) => Promise<Entity>;
    getEntity: (params: GetEntityParams) => Promise<Entity>;
    setupPayment: (params?: SetupPaymentParams, options?: RefetchOptions) => Promise<SetupPaymentResult>;
    createReferralCode: (params: CreateReferralCodeParams, options?: RefetchOptions) => Promise<CreateReferralCodeResult>;
    redeemReferralCode: (params: RedeemReferralCodeParams, options?: RefetchOptions) => Promise<RedeemReferralCodeResult>;
    listProducts: () => Promise<Product[]>;
    usage: (params: SetUsageParams) => Promise<SetUsageResult>;
    query: (params: QueryParams) => Promise<QueryResult>;
    listEvents: (params: EventListParams) => Promise<EventListResult>;
    aggregateEvents: (params: EventAggregateParams) => Promise<QueryResult>;
    refetch: () => Promise<void>;
};
/**
 * Set the Autumn client in the context.
 *
 * @param autumnClient - The Autumn client instance
 * @returns The Autumn client instance
 */
export declare function setAutumnContext(autumnClient: ReturnType<typeof createAutumnClientSvelteKit>): {
    readonly customer: Customer | null;
    allowed: (params: CheckParams) => LocalCheckResult;
    check: (params: CheckParams, options?: RefetchOptions) => Promise<CheckResult>;
    checkout: (params: CheckoutParams, options?: RefetchOptions) => Promise<CheckoutResult>;
    track: (params: TrackParams, options?: RefetchOptions) => Promise<TrackResult>;
    attach: (params: AttachParams, options?: RefetchOptions) => Promise<AttachResult>;
    cancel: (params: CancelParams, options?: RefetchOptions) => Promise<void>;
    openBillingPortal: (params?: BillingPortalParams) => Promise<BillingPortalResult>;
    createEntity: (params: CreateEntityParams, options?: RefetchOptions) => Promise<Entity>;
    getEntity: (params: GetEntityParams) => Promise<Entity>;
    setupPayment: (params?: SetupPaymentParams, options?: RefetchOptions) => Promise<SetupPaymentResult>;
    createReferralCode: (params: CreateReferralCodeParams, options?: RefetchOptions) => Promise<CreateReferralCodeResult>;
    redeemReferralCode: (params: RedeemReferralCodeParams, options?: RefetchOptions) => Promise<RedeemReferralCodeResult>;
    listProducts: () => Promise<Product[]>;
    usage: (params: SetUsageParams) => Promise<SetUsageResult>;
    query: (params: QueryParams) => Promise<QueryResult>;
    listEvents: (params: EventListParams) => Promise<EventListResult>;
    aggregateEvents: (params: EventAggregateParams) => Promise<QueryResult>;
    refetch: () => Promise<void>;
};
/**
 * Get the Autumn client from the context.
 *
 * @returns The Autumn client instance from context
 */
export declare function getAutumnContext(): {
    readonly customer: Customer | null;
    allowed: (params: CheckParams) => LocalCheckResult;
    check: (params: CheckParams, options?: RefetchOptions) => Promise<CheckResult>;
    checkout: (params: CheckoutParams, options?: RefetchOptions) => Promise<CheckoutResult>;
    track: (params: TrackParams, options?: RefetchOptions) => Promise<TrackResult>;
    attach: (params: AttachParams, options?: RefetchOptions) => Promise<AttachResult>;
    cancel: (params: CancelParams, options?: RefetchOptions) => Promise<void>;
    openBillingPortal: (params?: BillingPortalParams) => Promise<BillingPortalResult>;
    createEntity: (params: CreateEntityParams, options?: RefetchOptions) => Promise<Entity>;
    getEntity: (params: GetEntityParams) => Promise<Entity>;
    setupPayment: (params?: SetupPaymentParams, options?: RefetchOptions) => Promise<SetupPaymentResult>;
    createReferralCode: (params: CreateReferralCodeParams, options?: RefetchOptions) => Promise<CreateReferralCodeResult>;
    redeemReferralCode: (params: RedeemReferralCodeParams, options?: RefetchOptions) => Promise<RedeemReferralCodeResult>;
    listProducts: () => Promise<Product[]>;
    usage: (params: SetUsageParams) => Promise<SetUsageResult>;
    query: (params: QueryParams) => Promise<QueryResult>;
    listEvents: (params: EventListParams) => Promise<EventListResult>;
    aggregateEvents: (params: EventAggregateParams) => Promise<QueryResult>;
    refetch: () => Promise<void>;
};
/**
 * Check if Autumn has been set up.
 *
 * @returns True if the Autumn context exists
 */
export declare function hasAutumnContext(): boolean;
/**
 * Creates reactive state for an Autumn operation with loading, error, and result tracking.
 *
 * This helper reduces boilerplate for managing loading states, error handling, and results
 * when calling Autumn billing operations. Perfect for operations triggered by user actions
 * like checkout, track, attach, etc.
 *
 * @template TParams - The parameters type for the operation
 * @template TResult - The result type returned by the operation
 * @param operation - The Autumn operation function to wrap (e.g., autumn.checkout)
 * @param defaultOptions - Default RefetchOptions to use for all executions
 * @returns Object with execute function and reactive state (isLoading, error, result, reset)
 *
 * @example
 * ```svelte
 * <script lang="ts">
 *   import { useCustomer, useAutumnOperation } from './';
 *
 *   const autumn = useCustomer();
 *
 *   // Simple usage - auto-refetch enabled
 *   const upgrade = useAutumnOperation(autumn.checkout);
 *
 *   async function handleUpgrade() {
 *     const result = await upgrade.execute({ productId: 'pro' });
 *     if (result?.url) {
 *       window.location.href = result.url;
 *     }
 *   }
 * </script>
 *
 * <button disabled={upgrade.isLoading} onclick={handleUpgrade}>
 *   {upgrade.isLoading ? 'Processing...' : 'Upgrade to Pro'}
 * </button>
 *
 * {#if upgrade.error}
 *   <p class="error">{upgrade.error.message}</p>
 * {/if}
 * ```
 *
 * @example
 * ```svelte
 * <script lang="ts">
 *   import { useCustomer, useAutumnOperation } from './';
 *
 *   const autumn = useCustomer();
 *   const checkout = useAutumnOperation(autumn.checkout);
 *
 *   async function handleCheckout() {
 *     const result = await checkout.execute({ productId: 'pro' });
 *     if (result?.url) window.location.href = result.url;
 *   }
 * </script>
 *
 * {#if checkout.error}
 *   <div class="error">
 *     {checkout.error.message}
 *     <button onclick={() => checkout.reset()}>Dismiss</button>
 *   </div>
 * {/if}
 *
 * <button disabled={checkout.isLoading} onclick={handleCheckout}>
 *   {checkout.isLoading ? 'Processing...' : 'Upgrade'}
 * </button>
 * ```
 *
 * @example
 * ```svelte
 * <!-- Override default options per execution -->
 * <script lang="ts">
 *   import { useCustomer, useAutumnOperation } from './';
 *
 *   const autumn = useCustomer();
 *
 *   // Default: refetch disabled
 *   const checkout = useAutumnOperation(autumn.checkout, { refetch: false });
 *
 *   async function handleQuickCheckout() {
 *     // Override: enable refetch for this specific call
 *     await checkout.execute({ productId: 'basic' }, { refetch: true });
 *   }
 * </script>
 * ```
 */
export declare function useAutumnOperation<TParams, TResult>(operation: (params: TParams, options?: RefetchOptions) => Promise<TResult>, defaultOptions?: RefetchOptions): {
    execute: (params: TParams, executeOptions?: RefetchOptions) => Promise<TResult | null>;
    readonly isLoading: boolean;
    readonly error: Error | null;
    readonly result: TResult | null;
    reset: () => void;
};
//# sourceMappingURL=client.svelte.d.ts.map