autumn-js 0.0.84 → 0.0.92

package/dist/libraries/react/hooks/useProductsBase.js

@@ -529,6 +529,63 @@ var Autumn = class {
   }
 };
 
+// src/sdk/general/genTypes.ts
+var import_zod = require("zod");
+var AttachParamsSchema = import_zod.z.object({
+  customer_id: import_zod.z.string(),
+  product_id: import_zod.z.string().optional(),
+  entity_id: import_zod.z.string().optional(),
+  options: import_zod.z.array(import_zod.z.object({
+    feature_id: import_zod.z.string(),
+    quantity: import_zod.z.number()
+  })).optional(),
+  product_ids: import_zod.z.array(import_zod.z.string()).optional(),
+  // If set, will attach multiple products to the customer (cannot be used with product_id)
+  free_trial: import_zod.z.boolean().optional(),
+  // Default is true -- if set to false, will bypass product free trial
+  success_url: import_zod.z.string().optional(),
+  // Passed to Stripe
+  metadata: import_zod.z.record(import_zod.z.string()).optional(),
+  // Passed to Stripe
+  force_checkout: import_zod.z.boolean().optional(),
+  // Default is false -- if set to true, will force the customer to checkout (not allowed for upgrades / downgrades)
+  customer_data: import_zod.z.any().optional(),
+  entity_data: import_zod.z.any().optional(),
+  checkout_session_params: import_zod.z.record(import_zod.z.any()).optional(),
+  // Passed to Stripe
+  reward: import_zod.z.string().optional()
+});
+var AttachResultSchema = import_zod.z.object({
+  checkout_url: import_zod.z.string().optional(),
+  customer_id: import_zod.z.string(),
+  product_ids: import_zod.z.array(import_zod.z.string()),
+  code: import_zod.z.string(),
+  message: import_zod.z.string(),
+  customer_data: import_zod.z.any().optional()
+});
+
+// src/sdk/customers/cusEnums.ts
+var import_zod2 = require("zod");
+var CustomerExpandEnum = import_zod2.z.enum([
+  "invoices",
+  "rewards",
+  "trials_used",
+  "entities",
+  "referrals",
+  "payment_method"
+]);
+
+// src/sdk/customers/cusTypes.ts
+var import_zod3 = require("zod");
+var CreateCustomerParamsSchema = import_zod3.z.object({
+  id: import_zod3.z.string().nullish(),
+  email: import_zod3.z.string().nullish(),
+  name: import_zod3.z.string().nullish(),
+  fingerprint: import_zod3.z.string().nullish(),
+  metadata: import_zod3.z.record(import_zod3.z.any()).optional(),
+  expand: import_zod3.z.array(CustomerExpandEnum).optional()
+});
+
 // src/libraries/react/errorUtils/logFetchError.ts
 var logFetchError = ({
   method,
@@ -853,12 +910,10 @@ var AutumnContext = (0, import_react.createContext)({
 });
 var useAutumnContext = ({
   AutumnContext: AutumnContext2,
-  name
+  name,
+  errorIfNotInitialized = true
 }) => {
   const context = (0, import_react.useContext)(AutumnContext2);
-  if (!context.initialized) {
-    throw new Error(`${name} must be used within <AutumnProvider />`);
-  }
   return context;
 };
 

package/dist/libraries/react/hooks/useProductsBase.mjs

@@ -3,17 +3,17 @@
 import {
   AutumnContext,
   useAutumnContext
-} from "../chunk-MH2YTNJL.mjs";
-import "../chunk-UDRQNZZS.mjs";
+} from "../chunk-HL4JNKWK.mjs";
+import "../chunk-NCPXL3J2.mjs";
+import "../chunk-V5PKOA5A.mjs";
+import "../chunk-JNM4BLTM.mjs";
 import "../chunk-YUV2Y2RW.mjs";
 import "../chunk-3EYF7OI5.mjs";
+import "../chunk-KQT5G3HT.mjs";
 import "../chunk-JVCOY7ZL.mjs";
 import "../chunk-CIBQ4BJU.mjs";
 import "../chunk-NZ5PEXT2.mjs";
 import "../chunk-TGX6UKKS.mjs";
-import "../chunk-V5PKOA5A.mjs";
-import "../chunk-JNM4BLTM.mjs";
-import "../chunk-KQT5G3HT.mjs";
 
 // src/libraries/react/hooks/useProductsBase.tsx
 var useProductsBase = () => {

package/dist/libraries/react/index.d.mts

@@ -0,0 +1,611 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
+import * as swr from 'swr';
+import { SWRConfiguration } from 'swr';
+import * as React$1 from 'react';
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+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 Infinite = "inf";
+declare enum FreeTrialDuration {
+    Day = "day"
+}
+declare enum UsageModel {
+    Prepaid = "prepaid",
+    PayPerUse = "pay_per_use"
+}
+type UsageModelType = "prepaid" | "pay_per_use";
+declare enum ProductItemInterval {
+    Minute = "minute",
+    Hour = "hour",
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Quarter = "quarter",
+    SemiAnnual = "semi_annual",
+    Year = "year",
+    Multiple = "multiple"
+}
+type ProductItemIntervalType = "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | "multiple";
+
+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;
+    usage_limit?: number;
+    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;
+    };
+}
+
+declare enum AppEnv {
+    Sandbox = "sandbox",
+    Live = "live"
+}
+
+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_when_enabled?: boolean;
+    quantity?: number;
+    next_cycle_quantity?: number;
+    display?: {
+        primary_text?: string;
+        secondary_text?: 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;
+    base_variant_id: string | null;
+    properties?: {
+        is_free?: boolean;
+        is_one_off?: boolean;
+        interval_group?: string;
+    };
+    display?: {
+        name?: string;
+        description?: string;
+        button_text?: string;
+        recommend_text?: string;
+        everything_from?: string;
+        button_url?: string;
+    };
+}
+
+declare enum ProductStatus {
+    Active = "active",
+    Expired = "expired",
+    Trialing = "trialing",
+    Scheduled = "scheduled",
+    PastDue = "past_due"
+}
+type CustomerExpandOption = "invoices" | "rewards" | "trials_used" | "entities" | "referrals" | "payment_method";
+
+interface CoreCustomerFeature {
+    unlimited?: boolean;
+    interval?: ProductItemInterval | null;
+    balance?: number;
+    usage?: number;
+    included_usage?: number;
+    next_reset_at?: number | null;
+    overage_allowed?: boolean;
+    usage_limit?: number;
+    breakdown?: {
+        interval: ProductItemInterval;
+        balance?: number;
+        usage?: number;
+        included_usage?: number;
+        next_reset_at?: number;
+    }[];
+    credit_schema?: {
+        feature_id: string;
+        credit_amount: number;
+    }[];
+}
+interface CustomerFeature extends CoreCustomerFeature {
+    id: string;
+    name: string;
+    type: "static" | "single_use" | "continuous_use";
+}
+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;
+    items: ProductItem[];
+}
+interface Customer {
+    id: string | null;
+    created_at: number;
+    name: string | null;
+    email: string | null;
+    fingerprint: string | null;
+    stripe_id: string | null;
+    env: AppEnv;
+    metadata: Record<string, any>;
+    products: CustomerProduct[];
+    features: Record<string, CustomerFeature>;
+    invoices?: CustomerInvoice[];
+}
+interface CustomerData {
+    name?: string;
+    email?: string;
+    fingerprint?: string;
+}
+interface BillingPortalResult {
+    customer_id: string;
+    url: string;
+}
+interface CustomerInvoice {
+    product_ids: string[];
+    stripe_id: string;
+    status: string;
+    total: number;
+    currency: string;
+    created_at: number;
+    hosted_invoice_url: string;
+}
+
+interface Entity {
+    id: string;
+    name: string;
+    customer_id: string;
+    created_at: number;
+    env: string;
+    products: CustomerProduct[];
+    features: Record<string, CustomerFeature>;
+    invoices?: CustomerInvoice[];
+}
+
+interface CancelResult {
+    success: boolean;
+    customer_id: string;
+    product_id: string;
+}
+declare const AttachResultSchema: z.ZodObject<{
+    checkout_url: z.ZodOptional<z.ZodString>;
+    customer_id: z.ZodString;
+    product_ids: z.ZodArray<z.ZodString, "many">;
+    code: z.ZodString;
+    message: z.ZodString;
+    customer_data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    customer_id: string;
+    code: string;
+    message: string;
+    product_ids: string[];
+    customer_data?: any;
+    checkout_url?: string | undefined;
+}, {
+    customer_id: string;
+    code: string;
+    message: string;
+    product_ids: string[];
+    customer_data?: any;
+    checkout_url?: string | undefined;
+}>;
+type AttachResult = z.infer<typeof AttachResultSchema>;
+interface TrackResult {
+    id: string;
+    code: string;
+    customer_id: string;
+    feature_id?: string;
+    event_name?: string;
+}
+type CheckResult = CheckFeatureResult & CheckProductResult;
+interface SetupPaymentResult {
+    customer_id: string;
+    url: string;
+}
+
+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;
+    description?: string;
+    button_text?: string;
+    recommend_text?: string;
+    everything_from?: string;
+    price: {
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem;
+    items: ({
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem)[];
+    scenario: ProductScenario;
+}
+
+interface CreateReferralCodeResult {
+    code: string;
+    customer_id: string;
+    created_at: number;
+}
+interface RedeemReferralCodeResult {
+    id: string;
+    customer_id: string;
+    reward_id: string;
+    applied: boolean;
+}
+
+declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, authClient, }: {
+    children: React.ReactNode;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    backendUrl?: string;
+    customerData?: CustomerData;
+    includeCredentials?: boolean;
+    authClient?: any;
+}) => react_jsx_runtime.JSX.Element;
+
+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;
+    }[];
+}
+
+interface CreateEntityParams {
+    id: string;
+    name?: string;
+    featureId: string;
+}
+interface GetEntityParams {
+    expand?: string[];
+}
+
+declare const CreateReferralCodeParamsSchema: z.ZodObject<{
+    programId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    programId: string;
+}, {
+    programId: string;
+}>;
+type CreateReferralCodeParams = z.infer<typeof CreateReferralCodeParamsSchema>;
+declare const RedeemReferralCodeParamsSchema: z.ZodObject<{
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+}, {
+    code: string;
+}>;
+type RedeemReferralCodeParams = z.infer<typeof RedeemReferralCodeParamsSchema>;
+
+declare const AttachParamsSchema: z.ZodObject<{
+    productId: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        featureId: z.ZodString;
+        quantity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        quantity: number;
+        featureId: string;
+    }, {
+        quantity: number;
+        featureId: string;
+    }>, "many">>;
+    productIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    freeTrial: z.ZodOptional<z.ZodBoolean>;
+    successUrl: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    forceCheckout: z.ZodOptional<z.ZodBoolean>;
+    dialog: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodType<JSX.Element, z.ZodTypeDef, JSX.Element>, z.ZodType<React$1.ReactNode, z.ZodTypeDef, React$1.ReactNode>]>>>;
+    entityData: z.ZodOptional<z.ZodAny>;
+    openInNewTab: z.ZodOptional<z.ZodBoolean>;
+    reward: z.ZodOptional<z.ZodString>;
+    checkoutSessionParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        quantity: number;
+        featureId: string;
+    }[] | undefined;
+    metadata?: Record<string, string> | undefined;
+    reward?: string | undefined;
+    productId?: string | undefined;
+    entityId?: string | undefined;
+    productIds?: string[] | undefined;
+    freeTrial?: boolean | undefined;
+    successUrl?: string | undefined;
+    forceCheckout?: boolean | undefined;
+    dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React$1.ReactNode) | undefined;
+    entityData?: any;
+    openInNewTab?: boolean | undefined;
+    checkoutSessionParams?: Record<string, any> | undefined;
+}, {
+    options?: {
+        quantity: number;
+        featureId: string;
+    }[] | undefined;
+    metadata?: Record<string, string> | undefined;
+    reward?: string | undefined;
+    productId?: string | undefined;
+    entityId?: string | undefined;
+    productIds?: string[] | undefined;
+    freeTrial?: boolean | undefined;
+    successUrl?: string | undefined;
+    forceCheckout?: boolean | undefined;
+    dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React$1.ReactNode) | undefined;
+    entityData?: any;
+    openInNewTab?: boolean | undefined;
+    checkoutSessionParams?: Record<string, any> | undefined;
+}>;
+type AttachParams = z.infer<typeof AttachParamsSchema>;
+declare const CancelParamsSchema: z.ZodObject<{
+    productId: z.ZodString;
+    entityId: z.ZodOptional<z.ZodString>;
+    cancelImmediately: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    productId: string;
+    entityId?: string | undefined;
+    cancelImmediately?: boolean | undefined;
+}, {
+    productId: string;
+    entityId?: string | undefined;
+    cancelImmediately?: boolean | undefined;
+}>;
+type CancelParams = z.infer<typeof CancelParamsSchema>;
+declare const CheckParamsSchema: z.ZodObject<{
+    featureId: z.ZodOptional<z.ZodString>;
+    productId: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    requiredBalance: z.ZodOptional<z.ZodNumber>;
+    sendEvent: z.ZodOptional<z.ZodBoolean>;
+    withPreview: z.ZodOptional<z.ZodBoolean>;
+    dialog: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodType<JSX.Element, z.ZodTypeDef, JSX.Element>, z.ZodType<React$1.ReactNode, z.ZodTypeDef, React$1.ReactNode>]>>>;
+    entityData: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    featureId?: string | undefined;
+    productId?: string | undefined;
+    entityId?: string | undefined;
+    dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React$1.ReactNode) | undefined;
+    entityData?: any;
+    requiredBalance?: number | undefined;
+    sendEvent?: boolean | undefined;
+    withPreview?: boolean | undefined;
+}, {
+    featureId?: string | undefined;
+    productId?: string | undefined;
+    entityId?: string | undefined;
+    dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React$1.ReactNode) | undefined;
+    entityData?: any;
+    requiredBalance?: number | undefined;
+    sendEvent?: boolean | undefined;
+    withPreview?: boolean | undefined;
+}>;
+type CheckParams = z.infer<typeof CheckParamsSchema>;
+declare const TrackParamsSchema: z.ZodObject<{
+    featureId: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodNumber>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    entityData: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    value?: number | undefined;
+    featureId?: string | undefined;
+    entityId?: string | undefined;
+    entityData?: any;
+    eventName?: string | undefined;
+    idempotencyKey?: string | undefined;
+}, {
+    value?: number | undefined;
+    featureId?: string | undefined;
+    entityId?: string | undefined;
+    entityData?: any;
+    eventName?: string | undefined;
+    idempotencyKey?: string | undefined;
+}>;
+type TrackParams = z.infer<typeof TrackParamsSchema>;
+interface OpenBillingPortalParams {
+    returnUrl?: string;
+    openInNewTab?: boolean;
+}
+interface SetupPaymentParams {
+    successUrl?: string;
+    checkoutSessionParams?: Record<string, any>;
+    openInNewTab?: boolean;
+}
+
+interface AllowedParams {
+    featureId?: string;
+    productId?: string;
+    requiredBalance?: number;
+}
+
+interface UseCustomerResult {
+    customer: Customer | null;
+    isLoading: boolean;
+    error: AutumnError | null;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    setupPayment: (params: SetupPaymentParams) => AutumnPromise<SetupPaymentResult>;
+    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[];
+    swrConfig?: SWRConfiguration;
+    authClient?: any;
+}
+
+declare const useCustomer: (params?: UseCustomerParams) => UseCustomerResult;
+
+declare const usePricingTable: (params?: {
+    productDetails?: ProductDetails[];
+}) => {
+    products: Product[] | null;
+    isLoading: boolean;
+    error: AutumnError | undefined;
+    refetch: swr.KeyedMutator<Product[]>;
+};
+
+declare const useEntity: (entityId: string | null, params?: GetEntityParams) => {
+    entity: Entity | null;
+    isLoading: boolean;
+    error: any;
+    refetch: swr.KeyedMutator<Entity | null>;
+    allowed: (params: AllowedParams) => boolean;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    attach: (params: AttachParams) => Promise<any>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+};
+
+/**
+ * @deprecated The functions exported from this hook can now be found in useCustomer
+ */
+declare const useAutumn: () => {
+    attach: (params: AttachParams) => Promise<any>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams) => AutumnPromise<BillingPortalResult>;
+    setupPayment: (params?: SetupPaymentParams) => AutumnPromise<SetupPaymentResult>;
+};
+
+interface AttachDialogProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    preview: CheckProductPreview;
+    onClick: (options?: any) => Promise<void>;
+}
+declare function AttachDialog(params?: AttachDialogProps): react_jsx_runtime.JSX.Element;
+
+interface CheckDialogProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    preview: CheckFeaturePreview;
+}
+declare function CheckDialog(params?: CheckDialogProps): react_jsx_runtime.JSX.Element;
+
+declare function PricingTable({ productDetails, }: {
+    productDetails?: any;
+}): react_jsx_runtime.JSX.Element;
+
+export { AttachDialog, ReactAutumnProvider as AutumnProvider, CheckDialog, PricingTable, type PricingTableProduct, type ProductDetails, useAutumn, useCustomer, useEntity, usePricingTable };