import { a as CheckResult, S as SetupPaymentResult } from './genTypes-BouhbtKm.js';
import { C as CheckoutResult } from './attachTypes-eg914-6v.js';
import { E as EventsListResponse, Q as QueryResult } from './eventTypes-5iJYcv30.js';
import { A as AutumnError } from './error-DHbclCVh.js';
import { P as Product } from './prodTypes-C4aZSZfO.js';
import { C as CustomerData, a as CustomerExpandOption, b as CreateCustomerParams, E as ExpandedCustomer, B as BillingPortalResult, c as Entity, D as DeleteEntityResult } from './cusTypes-B1wzqLIi.js';
import { EventsListParams, EventAggregationParams, EventAggregationResponse } from './client/types/clientAnalyticsTypes.js';

type Success<T> = {
    data: T;
    error: null;
    statusCode?: number;
};
type Failure<E> = {
    data: null;
    error: E;
    statusCode?: number;
};
type Result<T, E> = Success<T> | Failure<E>;
type AutumnPromise<T> = Promise<Result<T, AutumnError>>;

interface CreateReferralCodeResult {
    code: string;
    customer_id: string;
    created_at: number;
}
interface RedeemReferralCodeResult {
    id: string;
    customer_id: string;
    reward_id: string;
    referrer: {
        id: string;
        name: string | null;
        email: string | null;
    };
}

interface ErrorResponse {
    message: string;
    code: string;
}
type OmitCustomerType = "id" | "name" | "email" | "fingerprint" | "customer_id";
interface AutumnClientConfig {
    backendUrl?: string;
    getBearerToken?: () => Promise<string | null | undefined>;
    customerData?: CustomerData;
    includeCredentials?: boolean;
    betterAuthUrl?: string;
    headers?: Record<string, string>;
    pathPrefix?: string;
    defaultReturnUrl?: string;
    suppressLogs?: boolean;
}
interface IAutumnClient {
    readonly backendUrl?: string;
    readonly prefix: string;
    readonly headers?: Record<string, string>;
    readonly customerData?: CustomerData;
    createCustomer<const T extends readonly CustomerExpandOption[] = readonly []>(params: Omit<CreateCustomerParams<T>, "id" | "data"> & {
        errorOnNotFound?: boolean;
    }): AutumnPromise<ExpandedCustomer<T>>;
    detectCors(): Promise<{
        valid: boolean;
        includeCredentials: boolean | undefined;
    }>;
    shouldIncludeCredentials(): Promise<boolean>;
    getHeaders(): Promise<Record<string, string>>;
    handleFetch(options: {
        path: string;
        method: string;
        body?: any;
    }): Promise<any>;
    post(path: string, body: any): Promise<any>;
    get(path: string): Promise<any>;
    delete(path: string): Promise<any>;
    attach(args: any): Promise<any>;
    checkout(args: any): Promise<any>;
    cancel(args: any): Promise<any>;
    check(args: any): Promise<any>;
    track(args: any): Promise<any>;
    openBillingPortal(args: any): Promise<any>;
    setupPayment(args: any): Promise<any>;
    query(args: any): Promise<any>;
    entities: {
        create(args: any): Promise<any>;
        get(entityId: string, args: any): Promise<any>;
        delete(args: any): Promise<any>;
    };
    referrals: {
        createCode(args: any): Promise<any>;
        redeemCode(args: any): Promise<any>;
    };
    products: {
        list(): AutumnPromise<{
            list: Product[];
        }>;
    };
    events: {
        list(params: EventsListParams): AutumnPromise<EventsListResponse>;
        aggregate(params: EventAggregationParams): AutumnPromise<EventAggregationResponse>;
    };
}
declare class AutumnClient implements IAutumnClient {
    readonly backendUrl?: string;
    protected readonly getBearerToken?: () => Promise<string | null | undefined>;
    readonly customerData?: CustomerData;
    protected includeCredentials?: boolean;
    readonly prefix: string;
    readonly camelCase: boolean;
    readonly headers?: Record<string, string>;
    readonly framework?: string;
    readonly defaultReturnUrl?: string;
    readonly suppressLogs: boolean;
    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, betterAuthUrl, headers, pathPrefix, defaultReturnUrl, suppressLogs, }: AutumnClientConfig);
    /**
     * Detects if the backend supports CORS credentials by making an OPTIONS request
     */
    detectCors(): Promise<{
        valid: boolean;
        includeCredentials: boolean;
    } | {
        valid: boolean;
        includeCredentials: undefined;
    }>;
    /**
     * Automatically determines whether to include credentials based on CORS detection
     */
    shouldIncludeCredentials(): Promise<boolean>;
    getHeaders(): Promise<Record<string, string>>;
    handleFetch({ path, method, body, }: {
        path: string;
        method: string;
        body?: Record<string, unknown> | Record<string, unknown>[];
    }): Promise<Result<any, AutumnError>>;
    post(path: string, body: Record<string, unknown> | Record<string, unknown>[]): Promise<Result<any, AutumnError>>;
    get(path: string): Promise<Result<any, AutumnError>>;
    delete(path: string): Promise<Result<any, AutumnError>>;
    createCustomer<const T extends readonly CustomerExpandOption[] = readonly []>(params: Omit<CreateCustomerParams<T>, "id" | "data"> & {
        errorOnNotFound?: boolean;
    }): AutumnPromise<ExpandedCustomer<T>>;
    attach: (params: {
        productId?: string | undefined;
        entityId?: string | undefined;
        options?: {
            featureId: string;
            quantity: number;
        }[] | undefined;
        productIds?: string[] | undefined;
        freeTrial?: boolean | undefined;
        successUrl?: string | undefined;
        metadata?: Record<string, string> | undefined;
        forceCheckout?: boolean | undefined;
        dialog?: any;
        entityData?: any;
        openInNewTab?: boolean | undefined;
        reward?: string | undefined;
        checkoutSessionParams?: Record<string, any> | undefined;
        newBillingSubscription?: boolean | undefined;
    }) => AutumnPromise<{
        customer_id: string;
        product_ids: string[];
        code: string;
        message: string;
        checkout_url?: string | undefined;
        customer_data?: any;
        invoice?: {
            status: string;
            stripe_id: string;
            hosted_invoice_url: string | null;
            total: number;
            currency: string;
        } | undefined;
    }>;
    checkout: (params: {
        productId?: string | undefined;
        productIds?: string[] | undefined;
        entityId?: string | undefined;
        entityData?: any;
        options?: {
            featureId: string;
            quantity: number;
        }[] | undefined;
        successUrl?: string | undefined;
        openInNewTab?: boolean | undefined;
        dialog?: any;
        forceCheckout?: boolean | undefined;
        freeTrial?: boolean | undefined;
        checkoutSessionParams?: Record<string, any> | undefined;
        reward?: string | undefined;
        newBillingSubscription?: boolean | undefined;
    }) => AutumnPromise<CheckoutResult>;
    cancel: (params: {
        productId: string;
        entityId?: string | undefined;
        cancelImmediately?: boolean | undefined;
    }) => AutumnPromise<{
        success: boolean;
        customer_id: string;
        product_id: string;
    }>;
    check: (params: {
        featureId?: string | undefined;
        productId?: string | undefined;
        entityId?: string | undefined;
        requiredBalance?: number | undefined;
        sendEvent?: boolean | undefined;
        withPreview?: boolean | undefined;
        dialog?: any;
        entityData?: any;
        properties?: Record<string, any> | undefined;
    }) => AutumnPromise<CheckResult>;
    track: (params: {
        featureId?: string | undefined;
        eventName?: string | undefined;
        entityId?: string | undefined;
        value?: number | undefined;
        idempotencyKey?: string | undefined;
        entityData?: any;
    }) => AutumnPromise<{
        id: string;
        code: string;
        customer_id: string;
        feature_id?: string | undefined;
        event_name?: string | undefined;
    }>;
    openBillingPortal: (params?: {
        returnUrl?: string | undefined;
        openInNewTab?: boolean | undefined;
    } | undefined) => AutumnPromise<BillingPortalResult>;
    setupPayment: (params?: {
        successUrl?: string | undefined;
        checkoutSessionParams?: Record<string, any> | undefined;
        openInNewTab?: boolean | undefined;
    } | undefined) => AutumnPromise<SetupPaymentResult>;
    query: (params: {
        featureId: string | string[];
        range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | "1bc" | "3bc" | undefined;
    }) => AutumnPromise<QueryResult>;
    entities: {
        create: (params: {
            id: string;
            featureId: string;
            name?: string | undefined;
        } | {
            id: string;
            featureId: string;
            name?: string | undefined;
        }[]) => AutumnPromise<Entity | Entity[]>;
        get: (entityId: string, params?: {
            expand?: string[] | undefined;
        } | undefined) => AutumnPromise<Entity>;
        delete: (entityId: string) => AutumnPromise<DeleteEntityResult>;
    };
    referrals: {
        createCode: (params: {
            programId: string;
        }) => AutumnPromise<CreateReferralCodeResult>;
        redeemCode: (params: {
            code: string;
        }) => AutumnPromise<RedeemReferralCodeResult>;
    };
    products: {
        list: () => AutumnPromise<{
            list: Product[];
        }>;
    };
    events: {
        list: (params: {
            featureId: string | string[];
            offset?: number | undefined;
            limit?: number | undefined;
            customRange?: {
                start?: number | undefined;
                end?: number | undefined;
            } | undefined;
        }) => AutumnPromise<{
            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;
        }>;
        aggregate: (params: {
            featureId: string | string[];
            groupBy?: string | undefined;
            range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | "1bc" | "3bc" | undefined;
            binSize?: "day" | "hour" | undefined;
            customRange?: {
                start: number;
                end: number;
            } | undefined;
        }) => AutumnPromise<EventAggregationResponse>;
    };
}

export { AutumnClient as A, type CreateReferralCodeResult as C, type ErrorResponse as E, type IAutumnClient as I, type OmitCustomerType as O, type RedeemReferralCodeResult as R, type Success as S, type AutumnPromise as a, type AutumnClientConfig as b };