@saas-support/react 0.2.0

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class b extends Error{constructor(t,e,s="unknown"){super(e),this.name="SaaSError",this.code=t,this.domain=s}get isNotFound(){return this.code===404}get isUnauthorized(){return this.code===401}get isForbidden(){return this.code===403}get isConflict(){return this.code===409}get isRateLimited(){return this.code===429}}class g{constructor(t,e){this.baseUrl=t,this.authMode=e}async request(t,e,s,r){const i={"Content-Type":"application/json",...this.getAuthHeaders(),...r},a=await(await fetch(`${this.baseUrl}${e}`,{method:t,headers:i,body:s?JSON.stringify(s):void 0})).json();if(a.code&&a.code>=400){const d=this.inferDomain(e);throw new b(a.code,a.message||"Request failed",d)}return a.data}async get(t,e){return this.request("GET",t,void 0,e)}async post(t,e,s){return this.request("POST",t,e,s)}async patch(t,e,s){return this.request("PATCH",t,e,s)}async del(t,e){return this.request("DELETE",t,void 0,e)}getAuthHeaders(){switch(this.authMode.type){case"publishableKey":case"apiKey":return{"X-API-Key":this.authMode.key};case"portalToken":case"embedToken":return{Authorization:`Bearer ${this.authMode.token}`}}}inferDomain(t){return t.startsWith("/auth")?"auth":t.startsWith("/billing")?"billing":t.startsWith("/report")?"report":"unknown"}}class R{constructor(t){this.accessToken=null,this.refreshToken=null,this.refreshTimer=null,this.onRefreshNeeded=null,this.storageKey=`ss_rt_${t.slice(0,12)}`,this.refreshToken=this.loadRefreshToken()}setRefreshCallback(t){this.onRefreshNeeded=t}getAccessToken(){return this.accessToken}getRefreshToken(){return this.refreshToken}hasRefreshToken(){return this.refreshToken!==null}setTokens(t,e){this.accessToken=t,this.refreshToken=e,this.saveRefreshToken(e),this.scheduleRefresh(t)}clearTokens(){this.accessToken=null,this.refreshToken=null,this.removeRefreshToken(),this.refreshTimer&&(clearTimeout(this.refreshTimer),this.refreshTimer=null)}destroy(){this.refreshTimer&&(clearTimeout(this.refreshTimer),this.refreshTimer=null)}scheduleRefresh(t){var r;this.refreshTimer&&clearTimeout(this.refreshTimer);const e=this.getTokenExpiry(t);if(!e)return;const s=e*1e3-Date.now()-6e4;if(s<=0){(r=this.onRefreshNeeded)==null||r.call(this);return}this.refreshTimer=setTimeout(()=>{var i;(i=this.onRefreshNeeded)==null||i.call(this)},s)}getTokenExpiry(t){try{const e=t.split(".")[1];return JSON.parse(atob(e)).exp??null}catch{return null}}loadRefreshToken(){try{return localStorage.getItem(this.storageKey)}catch{return null}}saveRefreshToken(t){try{localStorage.setItem(this.storageKey,t)}catch{}}removeRefreshToken(){try{localStorage.removeItem(this.storageKey)}catch{}}}class M{constructor(){this.listeners=new Map}on(t,e){return this.listeners.has(t)||this.listeners.set(t,new Set),this.listeners.get(t).add(e),()=>{var s;(s=this.listeners.get(t))==null||s.delete(e)}}emit(t,e){var s;(s=this.listeners.get(t))==null||s.forEach(r=>r(e))}removeAll(){this.listeners.clear()}}const k=500,T=600,U=5*60*1e3;class w{constructor(t,e,s,r){this.cachedUser=null,this.cachedSettings=null,this.loaded=!1,this.transport=t,this.tokenManager=e,this.emitter=s,this.baseUrl=r}async load(){var t,e;if(!this.loaded){try{this.cachedSettings=await this.transport.get("/auth/settings")}catch{}if((t=this.tokenManager)!=null&&t.hasRefreshToken())try{await this.performRefresh()}catch{(e=this.tokenManager)==null||e.clearTokens()}this.loaded=!0}}async signIn(t,e){const s=await this.transport.post("/auth/login",{email:t,password:e});if("mfaRequired"in s&&s.mfaRequired)return s;const r=s;return this.setSession(r),r}async signUp(t,e){const s=await this.transport.post("/auth/register",{email:t,password:e});return this.setSession(s),s}async signOut(){var e;const t=(e=this.tokenManager)==null?void 0:e.getRefreshToken();if(t)try{await this.transport.post("/auth/logout",{refreshToken:t})}catch{}this.clearSession()}async signInWithOAuth(t){const e=`${this.baseUrl}/auth/oauth/${t}/popup-callback`,{authUrl:s,state:r}=await this.transport.get(`/auth/oauth/${t}?redirect_uri=${encodeURIComponent(e)}`),i=window.screenX+(window.innerWidth-k)/2,y=window.screenY+(window.innerHeight-T)/2,a=window.open(s,"saas-support-oauth",`width=${k},height=${T},left=${i},top=${y},toolbar=no,menubar=no`);return new Promise((d,u)=>{let o=!1;const c=async h=>{var m;if(((m=h.data)==null?void 0:m.type)==="saas-support:oauth-callback"&&!o){if(o=!0,window.removeEventListener("message",c),clearTimeout(f),clearInterval(p),a==null||a.close(),h.data.error){u(new Error(`OAuth error: ${h.data.error}`));return}try{const l=await this.transport.post(`/auth/oauth/${t}/callback`,{code:h.data.code,state:h.data.state||r});this.setSession(l),d(l)}catch(l){u(l)}}};window.addEventListener("message",c);const f=setTimeout(()=>{o||(o=!0,window.removeEventListener("message",c),clearInterval(p),a==null||a.close(),u(new Error("OAuth popup timed out")))},U),p=setInterval(()=>{a!=null&&a.closed&&!o&&(o=!0,clearInterval(p),clearTimeout(f),window.removeEventListener("message",c),u(new Error("OAuth popup was closed")))},500)})}async submitMfaCode(t,e){const s=await this.transport.post("/auth/login/mfa",{mfaToken:t,code:e});return this.setSession(s),s}async sendMagicLink(t,e){await this.transport.post("/auth/magic-link/send",{email:t,redirectUrl:e})}async verifyMagicLink(t){const e=await this.transport.post("/auth/magic-link/verify",{token:t});return this.setSession(e),e}async sendPasswordReset(t,e){await this.transport.post("/auth/password-reset/send",{email:t,redirectUrl:e})}async resetPassword(t,e){await this.transport.post("/auth/password-reset/verify",{token:t,newPassword:e})}async setupMfa(){return this.transport.post("/auth/mfa/setup",void 0,this.authHeaders())}async verifyMfa(t){return this.transport.post("/auth/mfa/verify",{code:t},this.authHeaders())}async disableMfa(t){await this.transport.post("/auth/mfa/disable",{code:t},this.authHeaders())}async getToken(){var e,s,r;const t=((e=this.tokenManager)==null?void 0:e.getAccessToken())??null;if(t)return t;if((s=this.tokenManager)!=null&&s.hasRefreshToken())try{return await this.performRefresh(),((r=this.tokenManager)==null?void 0:r.getAccessToken())??null}catch{return this.clearSession(),null}return null}async getUser(){if(this.cachedUser)return this.cachedUser;const t=await this.getToken();if(!t)return null;try{return this.cachedUser=await this.transport.get("/auth/me",{Authorization:`Bearer ${t}`}),this.cachedUser}catch{return null}}getUserSync(){return this.cachedUser}isLoaded(){return this.loaded}async getSettings(){if(this.cachedSettings)return this.cachedSettings;try{return this.cachedSettings=await this.transport.get("/auth/settings"),this.cachedSettings}catch{return null}}onAuthStateChange(t){return this.emitter.on("authStateChange",t)}async updateProfile(t){const e=await this.transport.patch("/auth/me",{metadata:t},this.authHeaders());return this.cachedUser=e,this.emitter.emit("authStateChange",e),e}async listOrgs(){return this.transport.get("/auth/orgs",this.authHeaders())}async createOrg(t,e){return this.transport.post("/auth/orgs",{name:t,slug:e},this.authHeaders())}async getOrg(t){return this.transport.get(`/auth/orgs/${t}`,this.authHeaders())}async updateOrg(t,e){return this.transport.patch(`/auth/orgs/${t}`,e,this.authHeaders())}async deleteOrg(t){await this.transport.del(`/auth/orgs/${t}`,this.authHeaders())}async listMembers(t){return this.transport.get(`/auth/orgs/${t}/members`,this.authHeaders())}async sendInvite(t,e,s){return this.transport.post(`/auth/orgs/${t}/invites`,{email:e,role:s},this.authHeaders())}async updateMemberRole(t,e,s){await this.transport.patch(`/auth/orgs/${t}/members/${e}`,{role:s},this.authHeaders())}async removeMember(t,e){await this.transport.del(`/auth/orgs/${t}/members/${e}`,this.authHeaders())}async acceptInvite(t){return this.transport.post(`/auth/invites/${t}/accept`,void 0,this.authHeaders())}async performRefresh(){var s;const t=(s=this.tokenManager)==null?void 0:s.getRefreshToken();if(!t)throw new Error("No refresh token");const e=await this.transport.post("/auth/refresh",{refreshToken:t});if(this.tokenManager.setTokens(e.accessToken,e.refreshToken),!this.cachedUser)try{this.cachedUser=await this.transport.get("/auth/me",{Authorization:`Bearer ${e.accessToken}`}),this.emitter.emit("authStateChange",this.cachedUser)}catch{}}setSession(t){var e;(e=this.tokenManager)==null||e.setTokens(t.accessToken,t.refreshToken),this.cachedUser=t.user,this.emitter.emit("authStateChange",t.user)}clearSession(){var t;(t=this.tokenManager)==null||t.clearTokens(),this.cachedUser=null,this.emitter.emit("authStateChange",null)}authHeaders(){var e;const t=(e=this.tokenManager)==null?void 0:e.getAccessToken();return t?{Authorization:`Bearer ${t}`}:{}}}class S{constructor(t){this.transport=t}async createCustomer(t){return this.transport.post("/billing/customers",t)}async getCustomer(t){return this.transport.get(`/billing/customers/${t}`)}async updateCustomer(t,e){return this.transport.patch(`/billing/customers/${t}`,e)}async subscribe(t,e){return this.transport.post(`/billing/customers/${t}/subscribe`,{planId:e})}async changePlan(t,e){return this.transport.patch(`/billing/customers/${t}/subscription`,{planId:e})}async cancelSubscription(t){return this.transport.del(`/billing/customers/${t}/subscription`)}async getInvoices(t){return this.transport.get(`/billing/customers/${t}/invoices`)}async ingestUsageEvent(t){return this.transport.post("/billing/events",t)}async getCurrentUsage(t){return this.transport.get(`/billing/customers/${t}/usage`)}async createPortalToken(t,e){return this.transport.post("/billing/portal-tokens",{customerId:t,expiresIn:e})}async applyCoupon(t,e){return this.transport.post(`/billing/customers/${t}/coupon`,{code:e})}}class ${constructor(t){this.transport=t}async executeQuery(t){return this.transport.post("/report/query",t)}async listQueries(t){const e=t?this.toQueryString(t):"";return this.transport.get(`/report/queries${e}`)}async saveQuery(t){return this.transport.post("/report/queries",t)}async updateQuery(t,e){return this.transport.patch(`/report/queries/${t}`,e)}async deleteQuery(t){await this.transport.del(`/report/queries/${t}`)}async listDashboards(t){const e=t?this.toQueryString(t):"";return this.transport.get(`/report/dashboards${e}`)}async createDashboard(t){return this.transport.post("/report/dashboards",t)}async getDashboard(t){return this.transport.get(`/report/dashboards/${t}`)}async updateDashboard(t,e){return this.transport.patch(`/report/dashboards/${t}`,e)}async deleteDashboard(t){await this.transport.del(`/report/dashboards/${t}`)}async createEmbedToken(t){return this.transport.post("/report/embed-tokens",t)}async listEmbedTokens(){return this.transport.get("/report/embed-tokens")}async revokeEmbedToken(t){await this.transport.del(`/report/embed-tokens/${t}`)}toQueryString(t){const e=Object.entries(t).filter(([,s])=>s!=null&&s!=="");return e.length===0?"":"?"+e.map(([s,r])=>`${s}=${encodeURIComponent(String(r))}`).join("&")}}const v="https://api.saas-support.com/v1";class E{constructor(t){if(this.tokenManager=null,this.loaded=!1,!t.publishableKey&&!t.apiKey)throw new Error("SaaSSupport: either publishableKey or apiKey is required");const e=t.baseUrl??v;this.emitter=new M;const s=t.publishableKey?new g(e,{type:"publishableKey",key:t.publishableKey}):null,r=t.apiKey?new g(e,{type:"apiKey",key:t.apiKey}):null;t.publishableKey&&(this.tokenManager=new R(t.publishableKey)),this.auth=new w(s??r,this.tokenManager,this.emitter,e),this.billing=new S(r??s),this.report=new $(r??s),this.tokenManager&&this.tokenManager.setRefreshCallback(()=>this.auth.performRefresh())}async load(){this.loaded||(await this.auth.load(),this.loaded=!0)}isLoaded(){return this.loaded}onError(t){return this.emitter.on("error",t)}destroy(){var t;(t=this.tokenManager)==null||t.destroy(),this.emitter.removeAll()}}function C(n){return"mfaRequired"in n&&n.mfaRequired===!0}exports.AuthClient=w;exports.BillingClient=S;exports.ReportClient=$;exports.SaaSError=b;exports.SaaSSupport=E;exports.Transport=g;exports.isMfaRequired=C;

package/dist/index.d.ts

@@ -0,0 +1,491 @@
+export declare interface Appearance {
+    baseTheme?: 'light' | 'dark';
+    variables?: ThemeVariables;
+    elements?: ElementOverrides;
+}
+
+export declare interface ApplyCouponResult {
+    applied: boolean;
+    discountType: string;
+    amount: number;
+    duration: string;
+}
+
+export 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;
+}
+
+export 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;
+
+export declare type AuthStateCallback = (user: User | null) => void;
+
+export 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 interface Customer {
+    id: string;
+    projectId: string;
+    email: string;
+    name?: string;
+    stripeCustomerId?: string;
+    balanceCents: number;
+    metadata?: string;
+    taxExempt: boolean;
+    taxId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare interface Dashboard {
+    id: string;
+    projectId: string;
+    name: string;
+    layoutJson: string;
+    isPublic: boolean;
+    refreshIntervalSeconds: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export 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;
+}
+
+export declare interface EmbedToken {
+    id: string;
+    projectId: string;
+    dashboardId?: string;
+    customerId?: string;
+    filterRules?: FilterRule[];
+    expiresAt: string;
+    createdAt: string;
+    revokedAt?: string;
+}
+
+export 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;
+}
+
+export declare interface FilterRule {
+    table?: string;
+    column: string;
+    op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'between';
+    value: string;
+}
+
+export declare interface Invite {
+    inviteId: string;
+    email: string;
+    role: string;
+    token: string;
+    expiresAt: string;
+}
+
+export 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 isMfaRequired(result: AuthResult): result is MfaRequiredResult;
+
+declare type Listener<T> = (data: T) => void;
+
+export declare interface ListParams {
+    page?: number;
+    perPage?: number;
+    sort?: string;
+    order?: string;
+    search?: string;
+}
+
+export declare interface Member {
+    userId: string;
+    email: string;
+    role: string;
+}
+
+export declare interface MfaRequiredResult {
+    mfaRequired: true;
+    mfaToken: string;
+}
+
+export declare interface MfaSetupResult {
+    secret: string;
+    uri: string;
+}
+
+export declare interface MfaVerifyResult {
+    backupCodes: string[];
+}
+
+export declare type OAuthProvider = 'google' | 'github';
+
+export declare interface OffsetPage<T> {
+    data: T[];
+    meta: {
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+    };
+}
+
+export declare interface Org {
+    id: string;
+    projectId: string;
+    name: string;
+    slug: string;
+    avatarUrl?: string;
+    metadata?: string;
+}
+
+export declare interface Plan {
+    id: string;
+    name: string;
+    description?: string;
+    amountCents: number;
+    interval: 'month' | 'year';
+    currency: string;
+    trialDays: number;
+    isFree: boolean;
+    features: string[];
+    isActive: boolean;
+}
+
+export declare interface PortalTokenResult {
+    portalToken: string;
+    expiresAt: string;
+}
+
+export declare interface ProjectSettings {
+    googleEnabled: boolean;
+    githubEnabled: boolean;
+    emailEnabled: boolean;
+    mfaEnforced: boolean;
+    passwordMinLength: number;
+    emailVerification: boolean;
+}
+
+export declare interface QueryParams {
+    naturalLanguage?: string;
+    sql?: string;
+    filterRules?: FilterRule[];
+}
+
+export declare interface QueryResult {
+    sql: string;
+    columns: string[];
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    executionMs: number;
+    chartType: string;
+    cached: boolean;
+}
+
+export 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;
+}
+
+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;
+}
+
+export 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 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;
+}
+
+export declare interface SavedQuery {
+    id: string;
+    projectId: string;
+    name: string;
+    naturalLanguage?: string;
+    generatedSql?: string;
+    chartType: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare interface SignInResult {
+    user: User;
+    accessToken: string;
+    refreshToken: string;
+}
+
+export declare interface SignUpResult {
+    user: User;
+    accessToken: string;
+    refreshToken: string;
+}
+
+export 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 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;
+}
+
+export 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 interface UsageSummary {
+    metric: string;
+    total: number;
+}
+
+export declare interface User {
+    id: string;
+    email: string;
+    provider: string;
+    emailVerified: boolean;
+    metadata: Record<string, unknown>;
+    mfaEnabled?: boolean;
+}
+
+export { }