autumn-js 0.0.66 → 0.0.72

package/dist/next/index.d.mts

@@ -1,291 +1,430 @@
-import * as React$1 from 'react';
-import React__default from 'react';
-import * as swr from 'swr';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import { C as CustomerProduct, a as CustomerFeature, b as CustomerInvoice, I as Infinite, P as ProductItemIntervalType, U as UsageModel, A as AppEnv, F as FreeTrialDuration, c as CoreCustomerFeature, d as UsageModelType, e as CustomerData, f as CreateCustomerParams, g as Customer, B as BillingPortalResult, h as CustomerExpandOption } from './AutumnProvider-BdIwgk_j.mjs';
+export { i as AutumnProvider } from './AutumnProvider-BdIwgk_j.mjs';
+import * as swr from 'swr';
+import * as React$1 from 'react';
 import { NextRequest, NextResponse } from 'next/server';
 
-interface EntityDataParams {
-    name?: string;
-    featureId: string;
-}
-
-interface AttachParams {
-    productId: string;
-    entityId?: string;
-    options?: {
-        featureId: string;
-        quantity: number;
-    }[];
-    successUrl?: string;
-    forceCheckout?: boolean;
-    metadata?: Record<string, string>;
-    dialog?: () => JSX.Element | React__default.ReactNode;
-    callback?: () => Promise<void>;
-    withPreview?: "formatted" | "raw";
-    entityData?: EntityDataParams;
-    openInNewTab?: boolean;
-    reward?: string;
-}
-interface CreateEntityParams {
-    id: string;
-    name: string;
-    featureId: string;
-}
-
-interface CancelParams {
-    productId: string;
-    entityId?: string;
-    cancelImmediately?: boolean;
+interface ErrorResponse {
+    message: string;
+    code: string;
 }
-interface TrackParams {
-    featureId?: string;
-    eventName?: string;
-    entityId?: string;
-    value?: number;
-    idempotencyKey?: string;
-    entityData?: EntityDataParams;
+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;
+    };
 }
 
-declare const useAutumn: () => {
-    attach: ({ productId, entityId, options, successUrl, forceCheckout, metadata, dialog, callback, entityData, openInNewTab, }: AttachParams) => Promise<any>;
-    check: ({ featureId, productId, entityId, requiredBalance, sendEvent, withPreview, dialog, entityData, }: {
-        featureId?: string;
-        productId?: string;
-        entityId?: string;
-        requiredBalance?: number;
-        sendEvent?: boolean;
-        withPreview?: "formatted" | "raw";
-        dialog?: (data: any) => JSX.Element | React.ReactNode;
-        entityData?: EntityDataParams;
-    }) => Promise<any>;
-    track: (params: TrackParams) => Promise<any>;
-    cancel: (params: CancelParams) => Promise<any>;
-    openBillingPortal: (options?: {
-        returnUrl?: string;
-    }) => Promise<any>;
-};
+type EntityExpandOption = "invoices";
 
-declare enum AppEnv {
-    Sandbox = "sandbox",
-    Live = "live"
+interface DeleteEntityResult {
+    success: boolean;
 }
-
-declare enum ProductItemInterval {
-    Minute = "minute",
-    Hour = "hour",
-    Day = "day",
-    Week = "week",
-    Month = "month",
-    Quarter = "quarter",
-    SemiAnnual = "semi_annual",
-    Year = "year",
-    Multiple = "multiple"
+interface GetEntityParams$1 {
+    expand?: EntityExpandOption[];
 }
-
-declare enum ProductStatus {
-    Active = "active",
-    Expired = "expired",
-    Trialing = "trialing",
-    Scheduled = "scheduled",
-    PastDue = "past_due"
-}
-type CustomerExpandOption = "invoices" | "rewards" | "trials_used" | "entities";
-
-interface CustomerFeature {
+interface Entity {
     id: string;
     name: string;
-    unlimited?: boolean;
-    interval?: ProductItemInterval | null;
-    balance?: number;
-    usage?: number;
-    included_usage?: number;
-    next_reset_at?: number | null;
-    breakdown?: {
-        interval: ProductItemInterval;
-        balance?: number;
-        usage?: number;
-        included_usage?: number;
-        next_reset_at?: number;
-    }[];
-}
-interface CustomerProduct {
-    id: string;
-    name: string | null;
-    group: string | null;
-    status: ProductStatus;
-    started_at: number;
-    canceled_at: number | null;
-    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;
-}
-interface Customer {
-    id: string | null;
+    customer_id: string;
     created_at: number;
-    name: string | null;
-    email: string | null;
-    fingerprint: string | null;
-    stripe_id: string | null;
-    env: AppEnv;
-    metadata: Record<string, any>;
+    env: string;
     products: CustomerProduct[];
     features: Record<string, CustomerFeature>;
     invoices?: CustomerInvoice[];
 }
-interface CustomerData {
-    name?: string;
-    email?: string;
-    fingerprint?: string;
+
+interface ProductItem {
+    feature_id?: string;
+    included_usage?: number | typeof Infinite;
+    interval?: ProductItemIntervalType;
+    usage_model?: UsageModel;
+    price?: number;
+    billing_units?: number;
+    entity_feature_id?: string;
+    reset_usage_on_billing?: boolean;
+    reset_usage_when_enabled?: boolean;
+    display?: {
+        primary_text?: string;
+        secondary_text?: string;
+    };
 }
-interface CustomerInvoice {
-    product_ids: string[];
-    stripe_id: string;
-    status: string;
-    total: number;
-    currency: 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;
+    properties?: {
+        is_free?: boolean;
+        is_one_off?: boolean;
+        interval_group?: string;
+    };
+    display?: {
+        description?: string;
+        button_text?: string;
+        recommend_text?: string;
+        everything_from?: string;
+        button_url?: string;
+    };
 }
 
-type EntityExpandOption = "invoices";
+type CheckFeatureScenario = "usage_limit" | "feature_flag";
+interface CheckFeatureResult extends CoreCustomerFeature {
+    allowed: boolean;
+    feature_id: string;
+    customer_id: string;
+    entity_id?: string;
+    required_balance: number;
+    code: string;
+    preview?: CheckFeaturePreview;
+}
+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;
+    code: 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;
+    };
+}
 
-interface GetEntityParams {
-    expand?: EntityExpandOption[];
+interface CancelResult {
+    success: boolean;
+    customer_id: string;
+    product_id: string;
 }
-interface Entity {
+interface AttachResult {
+    checkout_url?: string;
+    customer_id: string;
+    product_ids: string[];
+    code: string;
+    message: string;
+    customer_data?: CustomerData;
+}
+interface TrackResult {
     id: string;
-    name: string;
+    code: string;
     customer_id: string;
-    created_at: number;
-    env: string;
-    products: CustomerProduct[];
-    features: Record<string, CustomerFeature>;
-    invoices?: CustomerInvoice[];
+    feature_id?: string;
+    event_name?: string;
 }
+type CheckResult = CheckFeatureResult & CheckProductResult;
+
+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 PricingTableProduct {
     id: string;
     name: string;
-    buttonText: string;
+    description?: string;
+    button_text?: string;
+    recommend_text?: string;
+    everything_from?: string;
     price: {
-        primaryText: string;
-        secondaryText?: string;
-    };
-    items: {
-        primaryText: string;
-        secondaryText?: string;
-    }[];
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem;
+    items: ({
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem)[];
+    scenario: ProductScenario;
 }
-declare class AutumnClientError extends Error {
+
+interface CreateReferralCodeResult {
     code: string;
-    constructor({ message, code }: {
-        message: string;
-        code: string;
-    });
-    toString(): string;
-    toJSON(): {
-        message: string;
-        code: string;
-    };
+    customer_id: string;
+    created_at: number;
 }
-interface AutumnContextParams {
+interface RedeemReferralCodeResult {
+    id: string;
+    customer_id: string;
+    reward_id: string;
+    applied: boolean;
+}
+
+declare const NextAutumnProvider: ({ encryptedCustomerId, customerData, children, }: {
     encryptedCustomerId?: string;
     customerData?: CustomerData;
-    authProvider?: "clerk" | "better-auth";
-    customer: Customer | null;
-    setCustomer: (customer: Customer | null) => void;
-    entity: Entity | null;
-    setEntity: (entity: Entity | null) => void;
+    children: React.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+interface CreateEntityParams {
+    id: string;
+    name?: string;
+    featureId: string;
+}
+interface GetEntityParams {
+    expand?: string[];
+}
+interface EntityDataParams {
+    name?: string;
+    featureId: string;
+}
+
+interface CreateReferralCodeParams {
+    programId: string;
+}
+interface RedeemReferralCodeParams {
+    code: string;
+}
+
+interface AttachFeatureOptions {
+    featureId: string;
+    quantity: number;
+}
+interface AttachParams {
+    productId?: string;
     entityId?: string;
-    prodChangeDialog: {
-        found: boolean;
-        setProps: (props: any) => void;
-        setOpen: (open: boolean) => void;
-        setComponent: (component: any) => void;
+    options?: AttachFeatureOptions[];
+    productIds?: string[];
+    freeTrial?: boolean;
+    successUrl?: string;
+    metadata?: Record<string, string>;
+    forceCheckout?: boolean;
+    dialog?: (data: any) => JSX.Element | React.ReactNode;
+    entityData?: EntityDataParams;
+    openInNewTab?: boolean;
+    reward?: string;
+}
+interface CancelParams {
+    productId: string;
+    entityId?: string;
+    cancelImmediately?: boolean;
+}
+interface CheckParams {
+    featureId?: string;
+    productId?: string;
+    entityId?: string;
+    requiredBalance?: number;
+    sendEvent?: boolean;
+    withPreview?: boolean;
+    dialog?: (data: any) => JSX.Element | React.ReactNode;
+    entityData?: EntityDataParams;
+}
+interface TrackParams {
+    featureId?: string;
+    eventName?: string;
+    entityId?: string;
+    value?: number;
+    idempotencyKey?: string;
+    entityData?: EntityDataParams;
+}
+interface OpenBillingPortalParams {
+    returnUrl?: string;
+    openInNewTab?: boolean;
+}
+
+interface AutumnClientConfig {
+    backendUrl?: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    customerData?: CustomerData;
+    includeCredentials?: boolean;
+}
+declare class AutumnClient {
+    protected readonly backendUrl?: string;
+    protected readonly getBearerToken?: () => Promise<string | null | undefined>;
+    protected readonly customerData?: CustomerData;
+    protected readonly includeCredentials?: boolean;
+    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, }: AutumnClientConfig);
+    getHeaders(): Promise<any>;
+    handleFetch({ path, method, body, }: {
+        path: string;
+        method: string;
+        body?: any;
+    }): Promise<Result<any, AutumnError>>;
+    post(path: string, body: any): Promise<Result<any, AutumnError>>;
+    get(path: string): Promise<Result<any, AutumnError>>;
+    delete(path: string): Promise<Result<any, AutumnError>>;
+    createCustomer(params: Omit<CreateCustomerParams, "id" | "data"> & {
+        errorOnNotFound?: boolean;
+    }): Promise<Result<Customer, AutumnError>>;
+    getPricingTable(): Promise<Result<{
+        list: PricingTableProduct[];
+    }, AutumnError>>;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResult>;
+    entities: {
+        create: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
+        get: (entityId: string, params?: GetEntityParams | undefined) => AutumnPromise<Entity>;
+        delete: (entityId: string) => AutumnPromise<DeleteEntityResult>;
     };
-    paywallDialog: {
-        found: boolean;
-        setProps: (props: any) => void;
-        setOpen: (open: boolean) => void;
-        setComponent: (component: any) => void;
+    referrals: {
+        createCode: (params: CreateReferralCodeParams) => AutumnPromise<CreateReferralCodeResult>;
+        redeemCode: (params: RedeemReferralCodeParams) => AutumnPromise<RedeemReferralCodeResult>;
+    };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
     };
-    pricingTableProducts: PricingTableProduct[] | null;
-    setPricingTableProducts: (products: PricingTableProduct[]) => void;
 }
 
-interface UseCustomerProps {
-    expand?: CustomerExpandOption[];
-    autoCreate?: boolean;
-    encryptedCustomerId?: string;
-    customerData?: CustomerData;
-    errorOnNotFound?: boolean;
+interface AllowedParams {
+    featureId?: string;
+    productId?: string;
+    requiredBalance?: number;
 }
-declare const useCustomer: (options?: UseCustomerProps) => {
+
+interface UseCustomerResult {
     customer: Customer | null;
     isLoading: boolean;
-    error: AutumnClientError | null;
-    refetch: () => Promise<void>;
-    createEntity: (params: CreateEntityParams | CreateEntityParams[]) => Promise<any>;
-    deleteEntity: (entityId: string) => Promise<any>;
-};
+    error: AutumnError | null;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams) => AutumnPromise<BillingPortalResult>;
+    refetch: () => Promise<Customer | null>;
+    createEntity: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
+    createReferralCode: (params: CreateReferralCodeParams) => AutumnPromise<CreateReferralCodeResult>;
+    redeemReferralCode: (params: RedeemReferralCodeParams) => AutumnPromise<RedeemReferralCodeResult>;
+    allowed: (params: AllowedParams) => boolean;
+}
+interface UseCustomerParams {
+    errorOnNotFound?: boolean;
+    expand?: CustomerExpandOption[];
+}
 
-declare const usePricingTable: (options?: {
-    productDetails: {
-        id: string;
-        description?: string;
-        buttonText?: string;
-        buttonUrl?: string;
-        recommendText?: string;
+declare const useCustomer: (params?: UseCustomerParams) => UseCustomerResult;
+
+interface ProductDetails {
+    id?: string;
+    name?: string;
+    description?: string;
+    buttonText?: string;
+    buttonUrl?: string;
+    recommendText?: string;
+    everythingFrom?: string;
+    price?: {
+        primaryText: string;
+        secondaryText?: string;
+    };
+    items?: {
+        featureId?: string;
+        primaryText?: string;
+        secondaryText?: string;
     }[];
+}
+
+declare const usePricingTable: (params?: {
+    productDetails?: ProductDetails[];
 }) => {
-    products: any[] | null;
+    products: Product[] | null;
     isLoading: boolean;
-    error: any;
-    refetch: () => Promise<PricingTableProduct[] | null>;
+    error: AutumnError | undefined;
+    refetch: swr.KeyedMutator<Product[]>;
 };
 
-declare const useEntity: (entityId?: string, params?: GetEntityParams) => {
-    entity: any;
+declare const useEntity: (entityId: string | null, params?: GetEntityParams$1) => {
+    entity: null;
+    isLoading: boolean;
+    error: null;
+    refetch: swr.KeyedMutator<Entity | null>;
+    allowed?: undefined;
+} | {
+    entity: Entity | null;
     isLoading: boolean;
     error: any;
-    refetch: swr.KeyedMutator<any>;
+    refetch: swr.KeyedMutator<Entity | null>;
+    allowed: (params: AllowedParams) => boolean;
 };
 
-declare const AutumnContext: React$1.Context<AutumnContextParams>;
-declare const useAutumnContext: () => AutumnContextParams;
-
-declare const withAuth: <T extends {
-    customerId?: string;
-    customerData?: CustomerData;
-    authProvider?: string;
-}>({ fn, withCustomerData, requireCustomer, }: {
-    fn: (args: T) => Promise<any>;
-    withCustomerData?: boolean;
-    requireCustomer?: boolean;
-}) => (args: Omit<T, "customerId"> & {
-    encryptedCustomerId?: string;
-}, request?: Request) => Promise<any>;
+declare const useAutumn: () => {
+    attach: (params: AttachParams) => Promise<Result<AttachResult | CheckResult, AutumnError>>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams) => AutumnPromise<BillingPortalResult>;
+};
 
-interface AuthPluginOptions {
-    provider: "better-auth" | "supabase" | "clerk";
-    instance?: any;
-    useOrg?: boolean;
-    useUser?: boolean;
+interface AutumnDialogContext {
+    props: any;
+    setProps: (props: any) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    setComponent: (component: any) => void;
 }
-declare global {
-    var __autumnAuth: AuthPluginOptions;
-}
-
-interface AutumnProviderProps {
-    customerId?: string;
-    customerData?: CustomerData;
-    authPlugin?: AuthPluginOptions;
-    children?: React.ReactNode;
+interface AutumnContextParams {
+    initialized: boolean;
+    disableDialogs: boolean;
+    client: AutumnClient;
+    paywallDialog: AutumnDialogContext;
+    attachDialog: AutumnDialogContext;
 }
-declare const AutumnProvider: ({ customerId, customerData, authPlugin, children, }: AutumnProviderProps) => react_jsx_runtime.JSX.Element;
+declare const AutumnContext: React$1.Context<AutumnContextParams>;
 
 type AuthResult = Promise<{
     customerId?: string;
@@ -304,4 +443,4 @@ declare function autumnHandler(options: {
     POST: (request: NextRequest) => Promise<NextResponse<any>>;
 };
 
-export { AutumnContext, AutumnProvider, type UseCustomerProps, autumnHandler, useAutumn, useAutumnContext, useCustomer, useEntity, usePricingTable, withAuth };
+export { AutumnContext, NextAutumnProvider, autumnHandler, useAutumn, useCustomer, useEntity, usePricingTable };