@polar-sh/better-auth/dist/index.d.ts

Polar integration for better-auth

import * as _polar_sh_sdk_models_operations_customerportalorderslist_js from '@polar-sh/sdk/models/operations/customerportalorderslist.js';
import * as _polar_sh_sdk_models_operations_customerportalsubscriptionslist_js from '@polar-sh/sdk/models/operations/customerportalsubscriptionslist.js';
import * as _polar_sh_sdk_models_operations_subscriptionslist_js from '@polar-sh/sdk/models/operations/subscriptionslist.js';
import * as _polar_sh_sdk_models_operations_customerportalbenefitgrantslist_js from '@polar-sh/sdk/models/operations/customerportalbenefitgrantslist.js';
import * as _polar_sh_sdk_models_components_customerstate_js from '@polar-sh/sdk/models/components/customerstate.js';
import * as _polar_sh_sdk_models_components_eventsingestresponse_js from '@polar-sh/sdk/models/components/eventsingestresponse.js';
import * as _polar_sh_sdk_types_operations_js from '@polar-sh/sdk/types/operations.js';
import * as _polar_sh_sdk_models_operations_customerportalcustomermeterslist_js from '@polar-sh/sdk/models/operations/customerportalcustomermeterslist.js';
import * as zod from 'zod';
import { z } from 'zod';
import * as better_auth from 'better-auth';
import { User } from 'better-auth';
import { Polar } from '@polar-sh/sdk';
import { WebhookBenefitCreatedPayload } from '@polar-sh/sdk/models/components/webhookbenefitcreatedpayload.js';
import { WebhookBenefitGrantCreatedPayload } from '@polar-sh/sdk/models/components/webhookbenefitgrantcreatedpayload.js';
import { WebhookBenefitGrantRevokedPayload } from '@polar-sh/sdk/models/components/webhookbenefitgrantrevokedpayload.js';
import { WebhookBenefitGrantUpdatedPayload } from '@polar-sh/sdk/models/components/webhookbenefitgrantupdatedpayload.js';
import { WebhookBenefitUpdatedPayload } from '@polar-sh/sdk/models/components/webhookbenefitupdatedpayload.js';
import { WebhookCheckoutCreatedPayload } from '@polar-sh/sdk/models/components/webhookcheckoutcreatedpayload.js';
import { WebhookCheckoutUpdatedPayload } from '@polar-sh/sdk/models/components/webhookcheckoutupdatedpayload.js';
import { WebhookCustomerCreatedPayload } from '@polar-sh/sdk/models/components/webhookcustomercreatedpayload.js';
import { WebhookCustomerDeletedPayload } from '@polar-sh/sdk/models/components/webhookcustomerdeletedpayload.js';
import { WebhookCustomerStateChangedPayload } from '@polar-sh/sdk/models/components/webhookcustomerstatechangedpayload.js';
import { WebhookCustomerUpdatedPayload } from '@polar-sh/sdk/models/components/webhookcustomerupdatedpayload.js';
import { WebhookOrderCreatedPayload } from '@polar-sh/sdk/models/components/webhookordercreatedpayload.js';
import { WebhookOrderPaidPayload } from '@polar-sh/sdk/models/components/webhookorderpaidpayload.js';
import { WebhookOrderRefundedPayload } from '@polar-sh/sdk/models/components/webhookorderrefundedpayload.js';
import { WebhookOrganizationUpdatedPayload } from '@polar-sh/sdk/models/components/webhookorganizationupdatedpayload.js';
import { WebhookProductCreatedPayload } from '@polar-sh/sdk/models/components/webhookproductcreatedpayload.js';
import { WebhookProductUpdatedPayload } from '@polar-sh/sdk/models/components/webhookproductupdatedpayload.js';
import { WebhookRefundCreatedPayload } from '@polar-sh/sdk/models/components/webhookrefundcreatedpayload.js';
import { WebhookRefundUpdatedPayload } from '@polar-sh/sdk/models/components/webhookrefundupdatedpayload.js';
import { WebhookSubscriptionActivePayload } from '@polar-sh/sdk/models/components/webhooksubscriptionactivepayload.js';
import { WebhookSubscriptionCanceledPayload } from '@polar-sh/sdk/models/components/webhooksubscriptioncanceledpayload.js';
import { WebhookSubscriptionCreatedPayload } from '@polar-sh/sdk/models/components/webhooksubscriptioncreatedpayload.js';
import { WebhookSubscriptionRevokedPayload } from '@polar-sh/sdk/models/components/webhooksubscriptionrevokedpayload.js';
import { WebhookSubscriptionUncanceledPayload } from '@polar-sh/sdk/models/components/webhooksubscriptionuncanceledpayload.js';
import { WebhookSubscriptionUpdatedPayload } from '@polar-sh/sdk/models/components/webhooksubscriptionupdatedpayload.js';
import { validateEvent } from '@polar-sh/sdk/webhooks.js';

interface CheckoutOptions {
    /**
     * Optional list of slug -> productId mappings for easy slug checkouts
     */
    products?: Product[] | (() => Promise<Product[]>);
    /**
     * Checkout Success URL
     */
    successUrl?: string;
    /**
     * Only allow authenticated customers to checkout
     */
    authenticatedUsersOnly?: boolean;
}
declare const checkout: (checkoutOptions?: CheckoutOptions) => (polar: Polar) => {
    checkout: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
            body: {
                products?: string | string[] | undefined;
                slug?: string | undefined;
                referenceId?: string | undefined;
                customFieldData?: Record<string, string | number | boolean> | undefined;
                metadata?: Record<string, string | number | boolean> | undefined;
            };
        } & {
            method?: "POST" | undefined;
        } & {
            query?: Record<string, any> | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: {
                url: string;
                redirect: boolean;
            };
        } : {
            url: string;
            redirect: boolean;
        }>;
        options: {
            method: "POST";
            body: z.ZodObject<{
                products: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
                slug: z.ZodOptional<z.ZodString>;
                referenceId: z.ZodOptional<z.ZodString>;
                customFieldData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
            }, "strip", z.ZodTypeAny, {
                products?: string | string[] | undefined;
                slug?: string | undefined;
                referenceId?: string | undefined;
                customFieldData?: Record<string, string | number | boolean> | undefined;
                metadata?: Record<string, string | number | boolean> | undefined;
            }, {
                products?: string | string[] | undefined;
                slug?: string | undefined;
                referenceId?: string | undefined;
                customFieldData?: Record<string, string | number | boolean> | undefined;
                metadata?: Record<string, string | number | boolean> | undefined;
            }>;
        } & {
            use: any[];
        };
        path: "/checkout";
    };
};

declare const portal: () => (polar: Polar) => {
    portal: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
            body?: undefined;
        } & {
            method?: "GET" | undefined;
        } & {
            query?: Record<string, any> | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: {
                url: string;
                redirect: boolean;
            };
        } : {
            url: string;
            redirect: boolean;
        }>;
        options: {
            method: "GET";
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        } & {
            use: any[];
        };
        path: "/customer/portal";
    };
    state: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
            body?: undefined;
        } & {
            method?: "GET" | undefined;
        } & {
            query?: Record<string, any> | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: _polar_sh_sdk_models_components_customerstate_js.CustomerState;
        } : _polar_sh_sdk_models_components_customerstate_js.CustomerState>;
        options: {
            method: "GET";
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        } & {
            use: any[];
        };
        path: "/customer/state";
    };
    benefits: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
            body?: undefined;
        } & {
            method?: "GET" | undefined;
        } & {
            query?: {
                page?: number | undefined;
                limit?: number | undefined;
            } | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalbenefitgrantslist_js.CustomerPortalBenefitGrantsListResponse, {
                page: number;
            }>;
        } : _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalbenefitgrantslist_js.CustomerPortalBenefitGrantsListResponse, {
            page: number;
        }>>;
        options: {
            method: "GET";
            query: z.ZodOptional<z.ZodObject<{
                page: z.ZodOptional<z.ZodNumber>;
                limit: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                page?: number | undefined;
                limit?: number | undefined;
            }, {
                page?: number | undefined;
                limit?: number | undefined;
            }>>;
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        } & {
            use: any[];
        };
        path: "/customer/benefits/list";
    };
    subscriptions: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
            body?: undefined;
        } & {
            method?: "GET" | undefined;
        } & {
            query?: {
                referenceId?: string | undefined;
                page?: number | undefined;
                limit?: number | undefined;
                active?: boolean | undefined;
            } | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_subscriptionslist_js.SubscriptionsListResponse, {
                page: number;
            }> | _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalsubscriptionslist_js.CustomerPortalSubscriptionsListResponse, {
                page: number;
            }>;
        } : _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_subscriptionslist_js.SubscriptionsListResponse, {
            page: number;
        }> | _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalsubscriptionslist_js.CustomerPortalSubscriptionsListResponse, {
            page: number;
        }>>;
        options: {
            method: "GET";
            query: z.ZodOptional<z.ZodObject<{
                referenceId: z.ZodOptional<z.ZodString>;
                page: z.ZodOptional<z.ZodNumber>;
                limit: z.ZodOptional<z.ZodNumber>;
                active: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                referenceId?: string | undefined;
                page?: number | undefined;
                limit?: number | undefined;
                active?: boolean | undefined;
            }, {
                referenceId?: string | undefined;
                page?: number | undefined;
                limit?: number | undefined;
                active?: boolean | undefined;
            }>>;
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        } & {
            use: any[];
        };
        path: "/customer/subscriptions/list";
    };
    orders: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
            body?: undefined;
        } & {
            method?: "GET" | undefined;
        } & {
            query?: {
                page?: number | undefined;
                limit?: number | undefined;
                productBillingType?: "recurring" | "one_time" | undefined;
            } | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalorderslist_js.CustomerPortalOrdersListResponse, {
                page: number;
            }>;
        } : _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalorderslist_js.CustomerPortalOrdersListResponse, {
            page: number;
        }>>;
        options: {
            method: "GET";
            query: z.ZodOptional<z.ZodObject<{
                page: z.ZodOptional<z.ZodNumber>;
                limit: z.ZodOptional<z.ZodNumber>;
                productBillingType: z.ZodOptional<z.ZodEnum<["recurring", "one_time"]>>;
            }, "strip", z.ZodTypeAny, {
                page?: number | undefined;
                limit?: number | undefined;
                productBillingType?: "recurring" | "one_time" | undefined;
            }, {
                page?: number | undefined;
                limit?: number | undefined;
                productBillingType?: "recurring" | "one_time" | undefined;
            }>>;
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        } & {
            use: any[];
        };
        path: "/customer/orders/list";
    };
};

interface UsageOptions {
    /**
     * Products to use for topping up credits
     */
    creditProducts?: Product[] | (() => Promise<Product[]>);
}
declare const usage: (_usageOptions?: UsageOptions) => (polar: Polar) => {
    meters: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
            body?: undefined;
        } & {
            method?: "GET" | undefined;
        } & {
            query: {
                page?: number | undefined;
                limit?: number | undefined;
            };
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalcustomermeterslist_js.CustomerPortalCustomerMetersListResponse, {
                page: number;
            }>;
        } : _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalcustomermeterslist_js.CustomerPortalCustomerMetersListResponse, {
            page: number;
        }>>;
        options: {
            method: "GET";
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
            query: z.ZodObject<{
                page: z.ZodOptional<z.ZodNumber>;
                limit: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                page?: number | undefined;
                limit?: number | undefined;
            }, {
                page?: number | undefined;
                limit?: number | undefined;
            }>;
        } & {
            use: any[];
        };
        path: "/usage/meters/list";
    };
    ingestion: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
            body: {
                metadata: Record<string, string | number | boolean>;
                event: string;
            };
        } & {
            method?: "POST" | undefined;
        } & {
            query?: Record<string, any> | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: _polar_sh_sdk_models_components_eventsingestresponse_js.EventsIngestResponse;
        } : _polar_sh_sdk_models_components_eventsingestresponse_js.EventsIngestResponse>;
        options: {
            method: "POST";
            body: z.ZodObject<{
                event: z.ZodString;
                metadata: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
            }, "strip", z.ZodTypeAny, {
                metadata: Record<string, string | number | boolean>;
                event: string;
            }, {
                metadata: Record<string, string | number | boolean>;
                event: string;
            }>;
            use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        userId: string;
                        expiresAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        name: string;
                        email: string;
                        emailVerified: boolean;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        } & {
            use: any[];
        };
        path: "/usage/ingest";
    };
};

interface WebhooksOptions {
    /**
     * Webhook Secret
     */
    secret: string;
    /**
     * Generic handler for all webhooks
     */
    onPayload?: (payload: ReturnType<typeof validateEvent>) => Promise<void>;
    /**
     * Webhook for checkout created
     */
    onCheckoutCreated?: (payload: WebhookCheckoutCreatedPayload) => Promise<void>;
    /**
     * Webhook for checkout updated
     */
    onCheckoutUpdated?: (payload: WebhookCheckoutUpdatedPayload) => Promise<void>;
    /**
     * Webhook for order created
     */
    onOrderCreated?: (payload: WebhookOrderCreatedPayload) => Promise<void>;
    /**
     * Webhook for order refunded
     */
    onOrderRefunded?: (payload: WebhookOrderRefundedPayload) => Promise<void>;
    /**
     * Webhook for order paid
     */
    onOrderPaid?: (payload: WebhookOrderPaidPayload) => Promise<void>;
    /**
     * Webhook for refund created
     */
    onRefundCreated?: (payload: WebhookRefundCreatedPayload) => Promise<void>;
    /**
     * Webhook for refund updated
     */
    onRefundUpdated?: (payload: WebhookRefundUpdatedPayload) => Promise<void>;
    /**
     * Webhook for subscription created
     */
    onSubscriptionCreated?: (payload: WebhookSubscriptionCreatedPayload) => Promise<void>;
    /**
     * Webhook for subscription updated
     */
    onSubscriptionUpdated?: (payload: WebhookSubscriptionUpdatedPayload) => Promise<void>;
    /**
     * Webhook for subscription active
     */
    onSubscriptionActive?: (payload: WebhookSubscriptionActivePayload) => Promise<void>;
    /**
     * Webhook for subscription canceled
     */
    onSubscriptionCanceled?: (payload: WebhookSubscriptionCanceledPayload) => Promise<void>;
    /**
     * Webhook for subscription revoked
     */
    onSubscriptionRevoked?: (payload: WebhookSubscriptionRevokedPayload) => Promise<void>;
    /**
     * Webhook for subscription uncanceled
     */
    onSubscriptionUncanceled?: (payload: WebhookSubscriptionUncanceledPayload) => Promise<void>;
    /**
     * Webhook for product created
     */
    onProductCreated?: (payload: WebhookProductCreatedPayload) => Promise<void>;
    /**
     * Webhook for product updated
     */
    onProductUpdated?: (payload: WebhookProductUpdatedPayload) => Promise<void>;
    /**
     * Webhook for organization updated
     */
    onOrganizationUpdated?: (payload: WebhookOrganizationUpdatedPayload) => Promise<void>;
    /**
     * Webhook for benefit created
     */
    onBenefitCreated?: (payload: WebhookBenefitCreatedPayload) => Promise<void>;
    /**
     * Webhook for benefit updated
     */
    onBenefitUpdated?: (payload: WebhookBenefitUpdatedPayload) => Promise<void>;
    /**
     * Webhook for benefit grant created
     */
    onBenefitGrantCreated?: (payload: WebhookBenefitGrantCreatedPayload) => Promise<void>;
    /**
     * Webhook for benefit grant updated
     */
    onBenefitGrantUpdated?: (payload: WebhookBenefitGrantUpdatedPayload) => Promise<void>;
    /**
     * Webhook for benefit grant revoked
     */
    onBenefitGrantRevoked?: (payload: WebhookBenefitGrantRevokedPayload) => Promise<void>;
    /**
     * Webhook for customer created
     */
    onCustomerCreated?: (payload: WebhookCustomerCreatedPayload) => Promise<void>;
    /**
     * Webhook for customer updated
     */
    onCustomerUpdated?: (payload: WebhookCustomerUpdatedPayload) => Promise<void>;
    /**
     * Webhook for customer deleted
     */
    onCustomerDeleted?: (payload: WebhookCustomerDeletedPayload) => Promise<void>;
    /**
     * Webhook for customer state changed
     */
    onCustomerStateChanged?: (payload: WebhookCustomerStateChangedPayload) => Promise<void>;
}
declare const webhooks: (options: WebhooksOptions) => (_polar: Polar) => {
    polarWebhooks: {
        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
            body?: undefined;
        } & {
            method?: "POST" | undefined;
        } & {
            query?: Record<string, any> | undefined;
        } & {
            params?: Record<string, any>;
        } & {
            request?: Request;
        } & {
            headers?: HeadersInit;
        } & {
            asResponse?: boolean;
            returnHeaders?: boolean;
            use?: better_auth.Middleware[];
            path?: string;
        } & {
            asResponse?: AsResponse | undefined;
            returnHeaders?: ReturnHeaders | undefined;
        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
            headers: Headers;
            response: {
                received: boolean;
            };
        } : {
            received: boolean;
        }>;
        options: {
            method: "POST";
            metadata: {
                isAction: boolean;
            };
            cloneRequest: true;
        } & {
            use: any[];
        };
        path: "/polar/webhooks";
    };
};

type Product = {
    /**
     * Product Id from Polar Product
     */
    productId: string;
    /**
     * Easily identifiable slug for the product
     */
    slug: string;
};
type PolarPlugin = ReturnType<typeof checkout> | ReturnType<typeof usage> | ReturnType<typeof portal> | ReturnType<typeof webhooks>;
type PolarPlugins = [PolarPlugin, ...PolarPlugin[]];
interface PolarOptions {
    /**
     * Polar Client
     */
    client: Polar;
    /**
     * Enable customer creation when a user signs up
     */
    createCustomerOnSignUp?: boolean;
    /**
     * A custom function to get the customer create
     * params
     * @param data - data containing user and session
     * @returns
     */
    getCustomerCreateParams?: (data: {
        user: User;
    }, request?: Request) => Promise<{
        metadata?: Record<string, string>;
    }>;
    /**
     * Use Polar plugins
     */
    use: PolarPlugins;
}

declare const polarClient: () => {
    id: "polar-client";
    $InferServerPlugin: ReturnType<typeof polar>;
};

declare const polar: <O extends PolarOptions>(options: O) => {
    id: "polar";
    endpoints: {
        checkout: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    products?: string | string[] | undefined;
                    slug?: string | undefined;
                    referenceId?: string | undefined;
                    customFieldData?: Record<string, string | number | boolean> | undefined;
                    metadata?: Record<string, string | number | boolean> | undefined;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_auth.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    url: string;
                    redirect: boolean;
                };
            } : {
                url: string;
                redirect: boolean;
            }>;
            options: {
                method: "POST";
                body: zod.ZodObject<{
                    products: zod.ZodOptional<zod.ZodUnion<[zod.ZodArray<zod.ZodString, "many">, zod.ZodString]>>;
                    slug: zod.ZodOptional<zod.ZodString>;
                    referenceId: zod.ZodOptional<zod.ZodString>;
                    customFieldData: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<[zod.ZodString, zod.ZodNumber, zod.ZodBoolean]>>>;
                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<[zod.ZodString, zod.ZodNumber, zod.ZodBoolean]>>>;
                }, "strip", zod.ZodTypeAny, {
                    products?: string | string[] | undefined;
                    slug?: string | undefined;
                    referenceId?: string | undefined;
                    customFieldData?: Record<string, string | number | boolean> | undefined;
                    metadata?: Record<string, string | number | boolean> | undefined;
                }, {
                    products?: string | string[] | undefined;
                    slug?: string | undefined;
                    referenceId?: string | undefined;
                    customFieldData?: Record<string, string | number | boolean> | undefined;
                    metadata?: Record<string, string | number | boolean> | undefined;
                }>;
            } & {
                use: any[];
            };
            path: "/checkout";
        };
    } | {
        meters: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query: {
                    page?: number | undefined;
                    limit?: number | undefined;
                };
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_auth.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalcustomermeterslist_js.CustomerPortalCustomerMetersListResponse, {
                    page: number;
                }>;
            } : _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalcustomermeterslist_js.CustomerPortalCustomerMetersListResponse, {
                page: number;
            }>>;
            options: {
                method: "GET";
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            name: string;
                            email: string;
                            emailVerified: boolean;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
                query: zod.ZodObject<{
                    page: zod.ZodOptional<zod.ZodNumber>;
                    limit: zod.ZodOptional<zod.ZodNumber>;
                }, "strip", zod.ZodTypeAny, {
                    page?: number | undefined;
                    limit?: number | undefined;
                }, {
                    page?: number | undefined;
                    limit?: number | undefined;
                }>;
            } & {
                use: any[];
            };
            path: "/usage/meters/list";
        };
        ingestion: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    metadata: Record<string, string | number | boolean>;
                    event: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_auth.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: _polar_sh_sdk_models_components_eventsingestresponse_js.EventsIngestResponse;
            } : _polar_sh_sdk_models_components_eventsingestresponse_js.EventsIngestResponse>;
            options: {
                method: "POST";
                body: zod.ZodObject<{
                    event: zod.ZodString;
                    metadata: zod.ZodRecord<zod.ZodString, zod.ZodUnion<[zod.ZodString, zod.ZodNumber, zod.ZodBoolean]>>;
                }, "strip", zod.ZodTypeAny, {
                    metadata: Record<string, string | number | boolean>;
                    event: string;
                }, {
                    metadata: Record<string, string | number | boolean>;
                    event: string;
                }>;
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            name: string;
                            email: string;
                            emailVerified: boolean;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
            } & {
                use: any[];
            };
            path: "/usage/ingest";
        };
    } | {
        portal: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_auth.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    url: string;
                    redirect: boolean;
                };
            } : {
                url: string;
                redirect: boolean;
            }>;
            options: {
                method: "GET";
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            name: string;
                            email: string;
                            emailVerified: boolean;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
            } & {
                use: any[];
            };
            path: "/customer/portal";
        };
        state: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_auth.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: _polar_sh_sdk_models_components_customerstate_js.CustomerState;
            } : _polar_sh_sdk_models_components_customerstate_js.CustomerState>;
            options: {
                method: "GET";
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            name: string;
                            email: string;
                            emailVerified: boolean;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
            } & {
                use: any[];
            };
            path: "/customer/state";
        };
        benefits: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    page?: number | undefined;
                    limit?: number | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_auth.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalbenefitgrantslist_js.CustomerPortalBenefitGrantsListResponse, {
                    page: number;
                }>;
            } : _polar_sh_sdk_types_operations_js.PageIterator<_polar_sh_sdk_models_operations_customerportalbenefitgrantslist_js.CustomerPortalBenefitGrantsListResponse, {
                page: number;
            }>>;
            options: {
                method: "GET";
                query: zod.ZodOptional<zod.ZodObject<{
                    page: zod.ZodOptional<zod.ZodNumber>;
                    limit: zod.ZodOptional<zod.ZodNumber>;
                }, "strip", zod.ZodTypeAny, {
                    page?: number | undefined;
                    limit?: number | undefined;
                }, {
                    page?: number | undefined;
                    limit?: number | undefined;
                }>>;
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            name: string;
                            email: string;
                            emailVerified: boolean;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };