/**
 * Svelte bindings for Autumn billing integration
 *
 * @module
 */
import type { AutumnConvexApi } from "./types.js";
/**
 * Initialize Autumn for Svelte.
 *
 * This function sets up Autumn billing integration for your Svelte application.
 * It should be called in your root layout or App component.
 *
 * @param convexApi - The Autumn API from your Convex backend (e.g., api.autumn)
 * @returns The Autumn client instance that can be used to access billing methods
 * @example
 * ```svelte
 * <script>
 *   import { setupAutumn } from '@stickerdaniel/convex-autumn-svelte/autumn/svelte';
 *   import { api } from './convex/_generated/api';
 *
 *   // Set up Autumn
 *   setupAutumn({ convexApi: api.autumn });
 * </script>
 *
 * <!-- Your app content here -->
 * ```
 */
export declare function setupAutumn({ convexApi, }: {
    /** Autumn Convex API object (e.g., api.autumn from generated types) */
    convexApi: AutumnConvexApi;
}): {
    readonly customer: import("./types.js").Customer | null | undefined;
    readonly isLoading: boolean;
    readonly error: Error | null | undefined;
    allowed: (params: import("./types.js").CheckParams) => import("./types.js").LocalCheckResult;
    check: (params: import("./types.js").CheckParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").CheckResult>;
    checkout: (params: import("./types.js").CheckoutParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").CheckoutResult>;
    track: (params: import("./types.js").TrackParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").TrackResult>;
    attach: (params: import("./types.js").AttachParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").AttachResult>;
    cancel: (params: import("./types.js").CancelParams, options?: import("./types.js").RefetchOptions) => Promise<void>;
    openBillingPortal: (params?: import("./types.js").BillingPortalParams) => Promise<import("./types.js").BillingPortalResult>;
    createEntity: (params: import("./types.js").CreateEntityParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").Entity>;
    getEntity: (params: import("./types.js").GetEntityParams) => Promise<import("./types.js").Entity>;
    setupPayment: (params?: import("./types.js").SetupPaymentParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").SetupPaymentResult>;
    createReferralCode: (params: import("./types.js").CreateReferralCodeParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").CreateReferralCodeResult>;
    redeemReferralCode: (params: import("./types.js").RedeemReferralCodeParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").RedeemReferralCodeResult>;
    listProducts: () => Promise<import("./types.js").Product[]>;
    usage: (params: import("./types.js").SetUsageParams) => Promise<import("./types.js").SetUsageResult>;
    query: (params: import("./types.js").QueryParams) => Promise<import("./types.js").QueryResult>;
    listEvents: (params: import("./types.js").EventListParams) => Promise<import("./types.js").EventListResult>;
    aggregateEvents: (params: import("./types.js").EventAggregateParams) => Promise<import("./types.js").QueryResult>;
    refetch: () => Promise<void>;
};
/**
 * Hook for accessing customer data and Autumn billing operations.
 *
 * Must be called after `setupAutumn()` has been called in a parent component.
 *
 * Note: Customer data is fetched once on initialization and automatically
 * refreshed after mutations (checkout, track, attach, cancel, createEntity).
 * Use `refetch()` to manually refresh customer data.
 *
 * @returns Customer data and billing methods
 * @returns {Customer | null | undefined} customer - Customer data (null if not found, undefined if loading)
 * @returns {boolean} isLoading - Whether customer data is currently loading
 * @returns {Error | null | undefined} error - Error if customer fetch failed
 * @returns {function(CheckParams): LocalCheckResult} allowed - Local check for feature access without consuming usage
 * @returns {function(CheckParams): Promise<CheckResult>} check - Server-side check with usage tracking
 * @returns {function(CheckoutParams): Promise<CheckoutResult>} checkout - Initiate checkout; returns a hosted url or a preview to confirm with attach
 * @returns {function(TrackParams): Promise<TrackResult>} track - Track usage of a feature
 * @returns {function(AttachParams): Promise<AttachResult>} attach - Attach a product to the customer
 * @returns {function(CancelParams): Promise<void>} cancel - Cancel a product subscription
 * @returns {function(BillingPortalParams): Promise<BillingPortalResult>} openBillingPortal - Open Stripe billing portal
 * @returns {function(CreateEntityParams): Promise<Entity>} createEntity - Create a new entity
 * @returns {function(GetEntityParams): Promise<Entity>} getEntity - Get entity by ID
 * @returns {function(SetupPaymentParams): Promise<SetupPaymentResult>} setupPayment - Setup payment method without charging
 * @returns {function(CreateReferralCodeParams): Promise<CreateReferralCodeResult>} createReferralCode - Create a referral code
 * @returns {function(RedeemReferralCodeParams): Promise<RedeemReferralCodeResult>} redeemReferralCode - Redeem a referral code for rewards
 * @returns {function(): Promise<Product[]>} listProducts - List all available products
 * @returns {function(SetUsageParams): Promise<SetUsageResult>} usage - Set usage to an absolute value (not a query - use customer.features for reading)
 * @returns {function(QueryParams): Promise<QueryResult>} query - Query customer data with custom parameters
 * @returns {function(EventListParams): Promise<EventListResult>} listEvents - List raw Autumn usage events
 * @returns {function(EventAggregateParams): Promise<QueryResult>} aggregateEvents - Aggregate Autumn usage events
 * @returns {function(): Promise<void>} refetch - Manually refresh customer data
 *
 * @example
 * ```svelte
 * <!-- Basic usage with feature checks and checkout -->
 * <script lang="ts">
 *   import { useCustomer } from "@stickerdaniel/convex-autumn-svelte/autumn/svelte";
 *
 *   const { customer, isLoading, error, allowed, checkout } = useCustomer();
 *
 *   const canUpload = $derived(allowed({ featureId: 'uploads' }).allowed);
 * </script>
 *
 * {#if isLoading}
 *   <p>Loading...</p>
 * {:else if error}
 *   <p>Error: {error.message}</p>
 * {:else if customer}
 *   <p>Welcome {customer.name}!</p>
 *   <p>Messages: {customer.features?.messages?.balance}</p>
 *   {#if !canUpload}
 *     <button onclick={() => checkout({ productId: 'pro' })}>
 *       Upgrade to enable uploads
 *     </button>
 *   {/if}
 * {/if}
 * ```
 *
 * @example
 * ```svelte
 * <!-- Payment setup and referral codes -->
 * <script lang="ts">
 *   import { useCustomer } from "@stickerdaniel/convex-autumn-svelte/autumn/svelte";
 *
 *   const { setupPayment, createReferralCode, redeemReferralCode } = useCustomer();
 *
 *   async function addPaymentMethod() {
 *     await setupPayment({ successUrl: '/dashboard' });
 *   }
 *
 *   async function generateReferralCode() {
 *     const { code } = await createReferralCode({ programId: 'friends' });
 *     alert(`Your referral code: ${code}`);
 *   }
 *
 *   async function redeemCode(code: string) {
 *     const { success, reward } = await redeemReferralCode({ code });
 *     if (success) {
 *       alert('Reward received!');
 *     }
 *   }
 * </script>
 *
 * <button onclick={addPaymentMethod}>Add Payment Method</button>
 * <button onclick={generateReferralCode}>Generate Referral Code</button>
 * ```
 *
 * @example
 * ```svelte
 * <!-- Product listing and reading usage data -->
 * <script lang="ts">
 *   import { useCustomer } from "@stickerdaniel/convex-autumn-svelte/autumn/svelte";
 *
 *   const { customer, listProducts, query, track } = useCustomer();
 *
 *   let products = $state<Product[]>([]);
 *
 *   // Access usage data from customer.features (reactive)
 *   const messagesFeature = $derived(customer?.features?.messages);
 *   const messagesUsed = $derived(
 *     messagesFeature?.included_usage && messagesFeature?.balance
 *       ? messagesFeature.included_usage - messagesFeature.balance
 *       : 0
 *   );
 *   const messagesTotal = $derived(messagesFeature?.included_usage ?? 0);
 *   const messagesRemaining = $derived(messagesFeature?.balance ?? 0);
 *
 *   async function loadPricing() {
 *     products = await listProducts();
 *   }
 *
 *   async function queryLastMonth() {
 *     const data = await query({ featureId: 'messages', range: '30d' });
 *     console.log('Last 30 days:', data);
 *   }
 *
 *   async function sendMessage() {
 *     await track({ featureId: 'messages', value: 1 });
 *     // Usage data updates automatically in customer.features
 *   }
 * </script>
 *
 * <button onclick={loadPricing}>Show Pricing</button>
 * <button onclick={queryLastMonth}>Query Analytics</button>
 * <button onclick={sendMessage}>Send Message</button>
 *
 * {#if messagesFeature}
 *   <p>Usage: {messagesUsed} / {messagesTotal} (Remaining: {messagesRemaining})</p>
 * {/if}
 * ```
 */
export declare function useCustomer(): {
    readonly customer: import("./types.js").Customer | null | undefined;
    readonly isLoading: boolean;
    readonly error: Error | null | undefined;
    allowed: (params: import("./types.js").CheckParams) => import("./types.js").LocalCheckResult;
    check: (params: import("./types.js").CheckParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").CheckResult>;
    checkout: (params: import("./types.js").CheckoutParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").CheckoutResult>;
    track: (params: import("./types.js").TrackParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").TrackResult>;
    attach: (params: import("./types.js").AttachParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").AttachResult>;
    cancel: (params: import("./types.js").CancelParams, options?: import("./types.js").RefetchOptions) => Promise<void>;
    openBillingPortal: (params?: import("./types.js").BillingPortalParams) => Promise<import("./types.js").BillingPortalResult>;
    createEntity: (params: import("./types.js").CreateEntityParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").Entity>;
    getEntity: (params: import("./types.js").GetEntityParams) => Promise<import("./types.js").Entity>;
    setupPayment: (params?: import("./types.js").SetupPaymentParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").SetupPaymentResult>;
    createReferralCode: (params: import("./types.js").CreateReferralCodeParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").CreateReferralCodeResult>;
    redeemReferralCode: (params: import("./types.js").RedeemReferralCodeParams, options?: import("./types.js").RefetchOptions) => Promise<import("./types.js").RedeemReferralCodeResult>;
    listProducts: () => Promise<import("./types.js").Product[]>;
    usage: (params: import("./types.js").SetUsageParams) => Promise<import("./types.js").SetUsageResult>;
    query: (params: import("./types.js").QueryParams) => Promise<import("./types.js").QueryResult>;
    listEvents: (params: import("./types.js").EventListParams) => Promise<import("./types.js").EventListResult>;
    aggregateEvents: (params: import("./types.js").EventAggregateParams) => Promise<import("./types.js").QueryResult>;
    refetch: () => Promise<void>;
};
/**
 * Check if Autumn has been set up in the current context.
 */
export declare function isAutumnSetup(): boolean;
export type { Customer, Entity, Feature, Product, ProductItem, CheckParams, CheckResult, CheckoutParams, CheckoutResult, TrackParams, TrackResult, AttachParams, AttachResult, AttachFeatureOptions, CancelParams, BillingPortalParams, BillingPortalResult, CreateCustomerParams, CreateEntityParams, GetEntityParams, SetupPaymentParams, SetupPaymentResult, CreateReferralCodeParams, CreateReferralCodeResult, RedeemReferralCodeParams, RedeemReferralCodeResult, SetUsageParams, SetUsageResult, FeatureUsageData, QueryParams, QueryResult, EventRecord, EventListParams, EventListResult, EventAggregateParams, LocalCheckResult, RefetchOptions, AutumnConvexApi, AutumnActionResponse, } from "./types.js";
export { AutumnError, unwrapAutumnResponse } from "./types.js";
//# sourceMappingURL=index.svelte.d.ts.map