@saas-support/react 0.2.0

package/dist/react.d.ts

@@ -0,0 +1,783 @@
+import { Context } from 'react';
+import { Dispatch } from 'react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { SetStateAction } from 'react';
+
+export declare interface Appearance {
+    baseTheme?: 'light' | 'dark';
+    variables?: ThemeVariables;
+    elements?: ElementOverrides;
+}
+
+declare interface ApplyCouponResult {
+    applied: boolean;
+    discountType: string;
+    amount: number;
+    duration: string;
+}
+
+declare class AuthClient {
+    private transport;
+    private tokenManager;
+    private emitter;
+    private baseUrl;
+    private cachedUser;
+    private cachedSettings;
+    private loaded;
+    constructor(transport: Transport, tokenManager: TokenManager | null, emitter: EventEmitter<SaaSEvents>, baseUrl: string);
+    load(): Promise<void>;
+    signIn(email: string, password: string): Promise<AuthResult>;
+    signUp(email: string, password: string): Promise<SignUpResult>;
+    signOut(): Promise<void>;
+    signInWithOAuth(provider: OAuthProvider): Promise<SignInResult>;
+    submitMfaCode(mfaToken: string, code: string): Promise<SignInResult>;
+    sendMagicLink(email: string, redirectUrl: string): Promise<void>;
+    verifyMagicLink(token: string): Promise<SignInResult>;
+    sendPasswordReset(email: string, redirectUrl: string): Promise<void>;
+    resetPassword(token: string, newPassword: string): Promise<void>;
+    setupMfa(): Promise<MfaSetupResult>;
+    verifyMfa(code: string): Promise<MfaVerifyResult>;
+    disableMfa(code: string): Promise<void>;
+    getToken(): Promise<string | null>;
+    getUser(): Promise<User | null>;
+    getUserSync(): User | null;
+    isLoaded(): boolean;
+    getSettings(): Promise<ProjectSettings | null>;
+    onAuthStateChange(callback: AuthStateCallback): () => void;
+    updateProfile(metadata: Record<string, unknown>): Promise<User>;
+    listOrgs(): Promise<Org[]>;
+    createOrg(name: string, slug: string): Promise<Org>;
+    getOrg(orgId: string): Promise<Org>;
+    updateOrg(orgId: string, params: {
+        name?: string;
+        avatarUrl?: string;
+    }): Promise<Org>;
+    deleteOrg(orgId: string): Promise<void>;
+    listMembers(orgId: string): Promise<Member[]>;
+    sendInvite(orgId: string, email: string, role: string): Promise<Invite>;
+    updateMemberRole(orgId: string, userId: string, role: string): Promise<void>;
+    removeMember(orgId: string, userId: string): Promise<void>;
+    acceptInvite(token: string): Promise<{
+        orgId: string;
+        role: string;
+    }>;
+    /* Excluded from this release type: performRefresh */
+    private setSession;
+    private clearSession;
+    private authHeaders;
+}
+
+declare type AuthMode = {
+    type: 'publishableKey';
+    key: string;
+} | {
+    type: 'apiKey';
+    key: string;
+} | {
+    type: 'portalToken';
+    token: string;
+} | {
+    type: 'embedToken';
+    token: string;
+};
+
+export declare type AuthResult = SignInResult | MfaRequiredResult;
+
+declare type AuthStateCallback = (user: User | null) => void;
+
+declare class BillingClient {
+    private transport;
+    constructor(transport: Transport);
+    createCustomer(params: {
+        email: string;
+        name?: string;
+        metadata?: string;
+    }): Promise<Customer>;
+    getCustomer(customerId: string): Promise<Customer>;
+    updateCustomer(customerId: string, params: {
+        email?: string;
+        name?: string;
+        metadata?: string;
+    }): Promise<Customer>;
+    subscribe(customerId: string, planId: string): Promise<Subscription>;
+    changePlan(customerId: string, planId: string): Promise<Subscription>;
+    cancelSubscription(customerId: string): Promise<{
+        canceledAtPeriodEnd: boolean;
+    }>;
+    getInvoices(customerId: string): Promise<Invoice[]>;
+    ingestUsageEvent(params: {
+        customerId: string;
+        metric: string;
+        quantity: number;
+        timestamp?: string;
+        idempotencyKey?: string;
+    }): Promise<{
+        id: string;
+        ingested: boolean;
+    }>;
+    getCurrentUsage(customerId: string): Promise<UsageSummary[]>;
+    createPortalToken(customerId: string, expiresIn?: number): Promise<PortalTokenResult>;
+    applyCoupon(customerId: string, code: string): Promise<ApplyCouponResult>;
+}
+
+export declare function Chart({ type, data, title, width, height, appearance: localAppearance }: ChartProps): JSX_2.Element;
+
+export declare interface ChartProps {
+    type: 'bar' | 'line' | 'pie';
+    data: {
+        labels: string[];
+        values: number[];
+    };
+    title?: string;
+    width?: number;
+    height?: number;
+    appearance?: Appearance;
+}
+
+export declare function CouponInput({ customerId, portalToken, onApplied, appearance: localAppearance }: CouponInputProps): JSX_2.Element;
+
+export declare interface CouponInputProps {
+    customerId: string;
+    portalToken?: string;
+    onApplied?: (result: ApplyCouponResult) => void;
+    appearance?: Appearance;
+}
+
+declare interface Customer {
+    id: string;
+    projectId: string;
+    email: string;
+    name?: string;
+    stripeCustomerId?: string;
+    balanceCents: number;
+    metadata?: string;
+    taxExempt: boolean;
+    taxId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+declare interface Dashboard {
+    id: string;
+    projectId: string;
+    name: string;
+    layoutJson: string;
+    isPublic: boolean;
+    refreshIntervalSeconds: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare function DashboardView({ dashboardId, embedToken, baseUrl, refreshInterval, appearance: localAppearance }: DashboardViewProps): JSX_2.Element;
+
+export declare interface DashboardViewProps {
+    dashboardId: string;
+    embedToken?: string;
+    baseUrl?: string;
+    refreshInterval?: number;
+    appearance?: Appearance;
+}
+
+export declare function DataTable({ columns, rows, sortable, maxRows, appearance: localAppearance }: DataTableProps): JSX_2.Element;
+
+export declare interface DataTableProps {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    sortable?: boolean;
+    maxRows?: number;
+    appearance?: Appearance;
+}
+
+declare interface ElementOverrides {
+    card?: React.CSSProperties;
+    headerTitle?: React.CSSProperties;
+    formField?: React.CSSProperties;
+    submitButton?: React.CSSProperties;
+    socialButton?: React.CSSProperties;
+    footerLink?: React.CSSProperties;
+    divider?: React.CSSProperties;
+    errorMessage?: React.CSSProperties;
+    pricingCard?: React.CSSProperties;
+    badge?: React.CSSProperties;
+    table?: React.CSSProperties;
+    tableHeader?: React.CSSProperties;
+    tableRow?: React.CSSProperties;
+    progressBar?: React.CSSProperties;
+    chartContainer?: React.CSSProperties;
+    queryInput?: React.CSSProperties;
+    dashboardGrid?: React.CSSProperties;
+}
+
+declare interface EmbedToken {
+    id: string;
+    projectId: string;
+    dashboardId?: string;
+    customerId?: string;
+    filterRules?: FilterRule[];
+    expiresAt: string;
+    createdAt: string;
+    revokedAt?: string;
+}
+
+declare interface EmbedTokenResult {
+    embedToken: string;
+    expiresAt: string;
+}
+
+declare class EventEmitter<Events extends Record<string, any>> {
+    private listeners;
+    on<K extends keyof Events>(event: K, listener: Listener<Events[K]>): () => void;
+    emit<K extends keyof Events>(event: K, data: Events[K]): void;
+    removeAll(): void;
+}
+
+declare interface FilterRule {
+    table?: string;
+    column: string;
+    op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'between';
+    value: string;
+}
+
+declare interface Invite {
+    inviteId: string;
+    email: string;
+    role: string;
+    token: string;
+    expiresAt: string;
+}
+
+declare interface Invoice {
+    id: string;
+    projectId: string;
+    customerId: string;
+    subscriptionId?: string;
+    amountCents: number;
+    status: 'draft' | 'open' | 'paid' | 'void' | 'uncollectible';
+    stripeInvoiceId?: string;
+    pdfUrl?: string;
+    dueDate?: string;
+    paidAt?: string;
+    createdAt: string;
+}
+
+export declare function InvoiceHistory({ customerId, portalToken, appearance: localAppearance }: InvoiceHistoryProps): JSX_2.Element;
+
+export declare interface InvoiceHistoryProps {
+    customerId: string;
+    portalToken?: string;
+    appearance?: Appearance;
+}
+
+export declare function isMfaRequired(result: AuthResult): result is MfaRequiredResult;
+
+declare type Listener<T> = (data: T) => void;
+
+declare interface ListParams {
+    page?: number;
+    perPage?: number;
+    sort?: string;
+    order?: string;
+    search?: string;
+}
+
+declare interface Member {
+    userId: string;
+    email: string;
+    role: string;
+}
+
+export declare interface MfaRequiredResult {
+    mfaRequired: true;
+    mfaToken: string;
+}
+
+declare interface MfaSetupResult {
+    secret: string;
+    uri: string;
+}
+
+declare interface MfaVerifyResult {
+    backupCodes: string[];
+}
+
+export declare type OAuthProvider = 'google' | 'github';
+
+declare interface OffsetPage<T> {
+    data: T[];
+    meta: {
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+    };
+}
+
+declare interface Org {
+    id: string;
+    projectId: string;
+    name: string;
+    slug: string;
+    avatarUrl?: string;
+    metadata?: string;
+}
+
+export declare function OrgSwitcher({ appearance: localAppearance, onOrgChange }: OrgSwitcherProps): JSX_2.Element | null;
+
+export declare interface OrgSwitcherProps {
+    appearance?: Appearance;
+    onOrgChange?: (org: Org) => void;
+}
+
+export declare function PaymentPortal({ customerId, portalToken, limits, onChangePlan, onCancel, appearance: localAppearance, }: PaymentPortalProps): JSX_2.Element;
+
+export declare interface PaymentPortalProps {
+    customerId: string;
+    portalToken?: string;
+    limits?: Record<string, number>;
+    onChangePlan?: () => void;
+    onCancel?: () => void;
+    appearance?: Appearance;
+}
+
+declare interface Plan {
+    id: string;
+    name: string;
+    description?: string;
+    amountCents: number;
+    interval: 'month' | 'year';
+    currency: string;
+    trialDays: number;
+    isFree: boolean;
+    features: string[];
+    isActive: boolean;
+}
+
+declare interface PortalTokenResult {
+    portalToken: string;
+    expiresAt: string;
+}
+
+export declare function PricingTable({ plans, currentPlanId, onSelectPlan, interval, appearance: localAppearance }: PricingTableProps): JSX_2.Element;
+
+export declare interface PricingTableProps {
+    plans: Plan[];
+    currentPlanId?: string;
+    onSelectPlan: (planId: string) => void;
+    interval?: 'month' | 'year';
+    appearance?: Appearance;
+}
+
+declare interface ProjectSettings {
+    googleEnabled: boolean;
+    githubEnabled: boolean;
+    emailEnabled: boolean;
+    mfaEnforced: boolean;
+    passwordMinLength: number;
+    emailVerification: boolean;
+}
+
+export declare function QueryInput({ onResult, mode, placeholder, appearance: localAppearance }: QueryInputProps): JSX_2.Element;
+
+export declare interface QueryInputProps {
+    onResult?: (result: QueryResult) => void;
+    mode?: 'nl' | 'sql' | 'both';
+    placeholder?: string;
+    appearance?: Appearance;
+}
+
+declare interface QueryParams {
+    naturalLanguage?: string;
+    sql?: string;
+    filterRules?: FilterRule[];
+}
+
+declare interface QueryResult {
+    sql: string;
+    columns: string[];
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    executionMs: number;
+    chartType: string;
+    cached: boolean;
+}
+
+declare class ReportClient {
+    private transport;
+    constructor(transport: Transport);
+    executeQuery(params: QueryParams): Promise<QueryResult>;
+    listQueries(params?: ListParams): Promise<OffsetPage<SavedQuery>>;
+    saveQuery(params: {
+        name: string;
+        naturalLanguage?: string;
+        generatedSql?: string;
+        chartType?: string;
+    }): Promise<SavedQuery>;
+    updateQuery(queryId: string, params: {
+        name?: string;
+        chartType?: string;
+    }): Promise<SavedQuery>;
+    deleteQuery(queryId: string): Promise<void>;
+    listDashboards(params?: ListParams): Promise<OffsetPage<Dashboard>>;
+    createDashboard(params: {
+        name: string;
+        layoutJson?: string;
+        isPublic?: boolean;
+        refreshIntervalSeconds?: number;
+    }): Promise<Dashboard>;
+    getDashboard(dashboardId: string): Promise<Dashboard>;
+    updateDashboard(dashboardId: string, params: {
+        name?: string;
+        layoutJson?: string;
+        isPublic?: boolean;
+        refreshIntervalSeconds?: number;
+    }): Promise<Dashboard>;
+    deleteDashboard(dashboardId: string): Promise<void>;
+    createEmbedToken(params: {
+        dashboardId?: string;
+        customerId?: string;
+        expiresIn?: number;
+        filterRules?: FilterRule[];
+    }): Promise<EmbedTokenResult>;
+    listEmbedTokens(): Promise<EmbedToken[]>;
+    revokeEmbedToken(tokenId: string): Promise<void>;
+    private toQueryString;
+}
+
+/**
+ * Standalone embeddable dashboard viewer.
+ * Does NOT require SaaSProvider — creates its own transport with embedToken.
+ */
+export declare function ReportEmbed({ embedToken, dashboardId, baseUrl, refreshInterval, appearance }: ReportEmbedProps): JSX_2.Element;
+
+export declare interface ReportEmbedProps {
+    embedToken: string;
+    dashboardId: string;
+    baseUrl?: string;
+    refreshInterval?: number;
+    appearance?: Appearance;
+}
+
+export declare const SaaSContext: Context<SaaSContextValue | null>;
+
+export declare interface SaaSContextValue {
+    client: SaaSSupport;
+    user: User | null;
+    isLoaded: boolean;
+    appearance?: Appearance;
+    settings: ProjectSettings | null;
+}
+
+export declare class SaaSError extends Error {
+    code: number;
+    domain: 'auth' | 'billing' | 'report' | 'unknown';
+    constructor(code: number, message: string, domain?: 'auth' | 'billing' | 'report' | 'unknown');
+    get isNotFound(): boolean;
+    get isUnauthorized(): boolean;
+    get isForbidden(): boolean;
+    get isConflict(): boolean;
+    get isRateLimited(): boolean;
+}
+
+declare interface SaaSEvents {
+    authStateChange: User | null;
+    error: SaaSError;
+}
+
+export declare interface SaaSOptions {
+    /** Publishable key for auth (end-user facing, pub_live_ prefix) */
+    publishableKey?: string;
+    /** API key for billing/report operations */
+    apiKey?: string;
+    /** Override the default API base URL */
+    baseUrl?: string;
+}
+
+export declare function SaaSProvider({ publishableKey, apiKey, baseUrl, appearance, children }: SaaSProviderProps): JSX_2.Element;
+
+export declare interface SaaSProviderProps {
+    publishableKey?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    appearance?: Appearance;
+    children: ReactNode;
+}
+
+export declare class SaaSSupport {
+    readonly auth: AuthClient;
+    readonly billing: BillingClient;
+    readonly report: ReportClient;
+    private tokenManager;
+    private emitter;
+    private loaded;
+    constructor(options: SaaSOptions);
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    onError(callback: (error: SaaSError) => void): () => void;
+    destroy(): void;
+}
+
+declare interface SavedQuery {
+    id: string;
+    projectId: string;
+    name: string;
+    naturalLanguage?: string;
+    generatedSql?: string;
+    chartType: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare function SavedQueryList({ onSelectQuery, onRunQuery, appearance: localAppearance }: SavedQueryListProps): JSX_2.Element;
+
+export declare interface SavedQueryListProps {
+    onSelectQuery?: (query: SavedQuery) => void;
+    onRunQuery?: (result: QueryResult) => void;
+    appearance?: Appearance;
+}
+
+export declare function SignIn({ appearance: localAppearance, signUpUrl, onSignUp }: SignInProps): JSX_2.Element;
+
+export declare interface SignInProps {
+    appearance?: Appearance;
+    signUpUrl?: string;
+    afterSignInUrl?: string;
+    onSignUp?: () => void;
+}
+
+export declare interface SignInResult {
+    user: User;
+    accessToken: string;
+    refreshToken: string;
+}
+
+export declare function SignUp({ appearance: localAppearance, signInUrl, onSignIn }: SignUpProps): JSX_2.Element;
+
+export declare interface SignUpProps {
+    appearance?: Appearance;
+    signInUrl?: string;
+    afterSignUpUrl?: string;
+    onSignIn?: () => void;
+}
+
+export declare interface SignUpResult {
+    user: User;
+    accessToken: string;
+    refreshToken: string;
+}
+
+declare interface Subscription {
+    id: string;
+    customerId: string;
+    planId: string;
+    projectId: string;
+    status: 'trialing' | 'active' | 'past_due' | 'paused' | 'canceled';
+    stripeSubscriptionId?: string;
+    cancelAtPeriodEnd: boolean;
+    trialEnd?: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    canceledAt?: string;
+    createdAt: string;
+}
+
+export declare function SubscriptionStatus({ customerId, portalToken, onChangePlan, onCancel, appearance: localAppearance, }: SubscriptionStatusProps): JSX_2.Element;
+
+export declare interface SubscriptionStatusProps {
+    customerId: string;
+    portalToken?: string;
+    onChangePlan?: () => void;
+    onCancel?: () => void;
+    appearance?: Appearance;
+}
+
+export declare interface ThemeVariables {
+    colorPrimary?: string;
+    colorBackground?: string;
+    colorText?: string;
+    colorInputBackground?: string;
+    colorInputBorder?: string;
+    colorError?: string;
+    colorSuccess?: string;
+    colorWarning?: string;
+    fontFamily?: string;
+    borderRadius?: string;
+}
+
+declare class TokenManager {
+    private accessToken;
+    private refreshToken;
+    private refreshTimer;
+    private storageKey;
+    private onRefreshNeeded;
+    constructor(keyPrefix: string);
+    setRefreshCallback(cb: () => Promise<void>): void;
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    hasRefreshToken(): boolean;
+    setTokens(accessToken: string, refreshToken: string): void;
+    clearTokens(): void;
+    destroy(): void;
+    private scheduleRefresh;
+    private getTokenExpiry;
+    private loadRefreshToken;
+    private saveRefreshToken;
+    private removeRefreshToken;
+}
+
+declare class Transport {
+    private baseUrl;
+    private authMode;
+    constructor(baseUrl: string, authMode: AuthMode);
+    request<T>(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    get<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    patch<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    del<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    private getAuthHeaders;
+    private inferDomain;
+}
+
+export declare function UsageDisplay({ customerId, limits, portalToken, appearance: localAppearance }: UsageDisplayProps): JSX_2.Element;
+
+export declare interface UsageDisplayProps {
+    customerId: string;
+    limits?: Record<string, number>;
+    portalToken?: string;
+    appearance?: Appearance;
+}
+
+declare interface UsageSummary {
+    metric: string;
+    total: number;
+}
+
+export declare function useAuth(): {
+    isLoaded: boolean;
+    isSignedIn: boolean;
+    user: User | null;
+    signOut: () => Promise<void>;
+    getToken: () => Promise<string | null>;
+};
+
+export declare function useBilling(): {
+    billing: BillingClient;
+};
+
+export declare function useDashboard(dashboardId: string): {
+    dashboard: Dashboard | null;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+export declare function useEmbedDashboard(embedToken: string, dashboardId: string, baseUrl?: string): {
+    dashboard: Dashboard | null;
+    reportClient: ReportClient;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+export declare function useInvoices(customerId: string, portalToken?: string): {
+    invoices: Invoice[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+export declare function useOrg(): {
+    orgs: Org[];
+    selectedOrg: Org | null;
+    members: Member[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    selectOrg: (orgId: string) => Promise<void>;
+    createOrg: (name: string, slug: string) => Promise<Org | null>;
+};
+
+export declare function useQuery(): {
+    result: QueryResult | null;
+    execute: (params: QueryParams) => Promise<QueryResult | null>;
+    isLoading: boolean;
+    error: string | null;
+};
+
+export declare interface User {
+    id: string;
+    email: string;
+    provider: string;
+    emailVerified: boolean;
+    metadata: Record<string, unknown>;
+    mfaEnabled?: boolean;
+}
+
+export declare function UserButton({ appearance: localAppearance }: UserButtonProps): JSX_2.Element | null;
+
+export declare interface UserButtonProps {
+    appearance?: Appearance;
+    afterSignOutUrl?: string;
+}
+
+export declare function useReport(): {
+    report: ReportClient;
+};
+
+export declare function UserProfile({ appearance: localAppearance }: UserProfileProps): JSX_2.Element | null;
+
+export declare interface UserProfileProps {
+    appearance?: Appearance;
+}
+
+export declare function useSaaSContext(): SaaSContextValue;
+
+export declare function useSavedQueries(params?: ListParams): {
+    queries: SavedQuery[];
+    meta: {
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+    } | undefined;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+export declare function useSignIn(): {
+    signIn: (email: string, password: string) => Promise<AuthResult | null>;
+    signInWithOAuth: (provider: OAuthProvider) => Promise<SignInResult | null>;
+    submitMfaCode: (mfaToken: string, code: string) => Promise<SignInResult | null>;
+    isLoading: boolean;
+    error: string | null;
+    setError: Dispatch<SetStateAction<string | null>>;
+};
+
+export declare function useSignUp(): {
+    signUp: (email: string, password: string) => Promise<SignUpResult | null>;
+    isLoading: boolean;
+    error: string | null;
+    setError: Dispatch<SetStateAction<string | null>>;
+};
+
+export declare function useSubscription(customerId: string, portalToken?: string): {
+    customer: Customer | null;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+export declare function useUsage(customerId: string, portalToken?: string): {
+    usage: UsageSummary[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+export declare function useUser(): {
+    user: User | null;
+    isLoaded: boolean;
+};
+
+export { }