@afribase/afribase-js 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1113 @@
+interface AfribaseClientOptions {
+    /**
+     * The base URL of your Afribase project (e.g. https://your-project.useafribase.app)
+     */
+    baseUrl: string;
+    /**
+     * The anonymous/public API key for your project
+     */
+    anonKey: string;
+    /**
+     * Custom auth URL override
+     */
+    authUrl?: string;
+    /**
+     * Custom REST API URL override
+     */
+    restUrl?: string;
+    /**
+     * Custom realtime URL override
+     */
+    realtimeUrl?: string;
+    /**
+     * Custom storage URL override
+     */
+    storageUrl?: string;
+    /**
+     * Custom functions URL override
+     */
+    functionsUrl?: string;
+    /**
+     * Auto-refresh token when it's about to expire
+     * @default true
+     */
+    autoRefreshToken?: boolean;
+    /**
+     * Persist the session to storage (localStorage in browser)
+     * @default true
+     */
+    persistSession?: boolean;
+    /**
+     * Custom fetch implementation
+     */
+    fetch?: typeof fetch;
+}
+interface Session {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    expires_at?: number;
+    token_type: string;
+    user: User;
+}
+interface User {
+    id: string;
+    email?: string;
+    phone?: string;
+    app_metadata: Record<string, any>;
+    user_metadata: Record<string, any>;
+    aud: string;
+    created_at: string;
+    updated_at?: string;
+    is_anonymous?: boolean;
+    role?: string;
+    confirmed_at?: string;
+    last_sign_in_at?: string;
+    identities?: UserIdentity[];
+    factors?: Factor[];
+}
+interface UserIdentity {
+    id: string;
+    user_id: string;
+    identity_data: Record<string, any>;
+    provider: string;
+    created_at: string;
+    updated_at: string;
+}
+interface Factor {
+    id: string;
+    friendly_name?: string;
+    factor_type: 'totp' | 'phone' | 'webauthn';
+    status: 'verified' | 'unverified';
+    created_at: string;
+    updated_at: string;
+}
+interface SignUpCredentials {
+    email?: string;
+    phone?: string;
+    password: string;
+    options?: {
+        data?: Record<string, any>;
+        emailRedirectTo?: string;
+        captchaToken?: string;
+    };
+}
+interface SignInWithPasswordCredentials {
+    email?: string;
+    phone?: string;
+    password: string;
+    options?: {
+        captchaToken?: string;
+    };
+}
+interface SignInWithOAuthCredentials {
+    provider: OAuthProvider;
+    options?: {
+        redirectTo?: string;
+        scopes?: string;
+        queryParams?: Record<string, string>;
+    };
+}
+interface SignInWithOtpCredentials {
+    email?: string;
+    phone?: string;
+    options?: {
+        emailRedirectTo?: string;
+        shouldCreateUser?: boolean;
+        data?: Record<string, any>;
+        captchaToken?: string;
+    };
+}
+interface VerifyOtpParams {
+    email?: string;
+    phone?: string;
+    token: string;
+    type: 'sms' | 'email' | 'signup' | 'magiclink' | 'recovery';
+}
+interface ResetPasswordCredentials {
+    email: string;
+    options?: {
+        redirectTo?: string;
+        captchaToken?: string;
+    };
+}
+interface UserAttributes {
+    email?: string;
+    phone?: string;
+    password?: string;
+    data?: Record<string, any>;
+}
+type OAuthProvider = 'apple' | 'azure' | 'bitbucket' | 'discord' | 'facebook' | 'figma' | 'fly' | 'github' | 'gitlab' | 'google' | 'kakao' | 'keycloak' | 'linkedin' | 'linkedin_oidc' | 'notion' | 'slack' | 'slack_oidc' | 'snapchat' | 'spotify' | 'twitch' | 'twitter' | 'workos' | 'x' | 'zoom';
+type AuthChangeEvent = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED' | 'PASSWORD_RECOVERY' | 'INITIAL_SESSION';
+interface AuthChangeCallback {
+    (event: AuthChangeEvent, session: Session | null): void;
+}
+interface Subscription {
+    id: string;
+    unsubscribe: () => void;
+}
+type RealtimeChannelEvent = 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+interface RealtimePostgresChangesPayload<T = any> {
+    eventType: 'INSERT' | 'UPDATE' | 'DELETE';
+    new: T;
+    old: Partial<T>;
+    schema: string;
+    table: string;
+    commit_timestamp: string;
+    errors: string[] | null;
+}
+interface RealtimePresenceState {
+    [key: string]: PresenceEntry[];
+}
+interface PresenceEntry {
+    presence_ref: string;
+    [key: string]: any;
+}
+type RealtimeListenTypes = 'postgres_changes' | 'broadcast' | 'presence';
+interface RealtimeChannelOptions {
+    /** Channel config (e.g. for Postgres changes) */
+    config?: {
+        broadcast?: {
+            self?: boolean;
+            ack?: boolean;
+        };
+        presence?: {
+            key?: string;
+        };
+        postgres_changes?: Array<{
+            event: RealtimeChannelEvent;
+            schema: string;
+            table?: string;
+            filter?: string;
+        }>;
+    };
+}
+interface StorageBucket {
+    id: string;
+    name: string;
+    public: boolean;
+    file_size_limit?: number;
+    allowed_mime_types?: string[];
+    created_at: string;
+    updated_at: string;
+}
+interface StorageObject {
+    id: string;
+    bucket_id: string;
+    name: string;
+    mime_type: string;
+    size: number;
+    etag?: string;
+    created_at: string;
+    updated_at: string;
+    metadata?: Record<string, any>;
+}
+interface UploadOptions {
+    contentType?: string;
+    cacheControl?: string;
+    upsert?: boolean;
+    duplex?: string;
+}
+interface TransformOptions {
+    width?: number;
+    height?: number;
+    resize?: 'cover' | 'contain' | 'fill';
+    quality?: number;
+    format?: 'origin' | 'avif' | 'webp';
+}
+interface SignedUrlOptions {
+    download?: string | boolean;
+    transform?: TransformOptions;
+}
+interface CreateSignedUrlResponse {
+    signedUrl: string;
+    path: string;
+    token: string;
+}
+interface FunctionInvokeOptions {
+    body?: any;
+    headers?: Record<string, string>;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    region?: string;
+}
+interface FunctionInvokeResponse<T = any> {
+    data: T | null;
+    error: Error | null;
+}
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'sl' | 'sr' | 'nxl' | 'nxr' | 'adj' | 'ov' | 'fts' | 'plfts' | 'phfts' | 'wfts';
+interface PostgrestError {
+    message: string;
+    details: string;
+    hint: string;
+    code: string;
+}
+interface PostgrestResponse<T> {
+    data: T | null;
+    error: PostgrestError | null;
+    count: number | null;
+    status: number;
+    statusText: string;
+}
+interface PostgrestSingleResponse<T> extends PostgrestResponse<T> {
+    data: T;
+}
+
+/**
+ * AfribaseAuthClient handles authentication state, token refresh,
+ * OAuth sign-in, OTP, anonymous auth, and auth state change listeners.
+ */
+declare class AfribaseAuthClient {
+    private url;
+    private apiKey;
+    private currentSession;
+    private refreshTimer;
+    private listeners;
+    private autoRefresh;
+    private persistSession;
+    private customFetch?;
+    private listenerIdCounter;
+    constructor(options: {
+        url: string;
+        apiKey: string;
+        autoRefreshToken?: boolean;
+        persistSession?: boolean;
+        customFetch?: typeof fetch;
+    });
+    /**
+     * Initialize the auth client — restores persisted session and emits INITIAL_SESSION.
+     * Call this once after creating the client.
+     */
+    initialize(): Promise<{
+        data: {
+            session: Session | null;
+        };
+        error: any;
+    }>;
+    /**
+     * Returns the current session if it exists.
+     */
+    getSession(): Promise<{
+        data: {
+            session: Session | null;
+        };
+        error: null;
+    }>;
+    /**
+     * Returns the current user if authenticated.
+     */
+    getUser(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: any;
+    }>;
+    /**
+     * Create a new user with email/phone and password.
+     */
+    signUp(credentials: SignUpCredentials): Promise<{
+        data: {
+            user: User | null;
+            session: Session | null;
+        };
+        error: any;
+    }>;
+    /**
+     * Sign in with email/phone and password.
+     */
+    signInWithPassword(credentials: SignInWithPasswordCredentials): Promise<{
+        data: {
+            user: User;
+            session: Session;
+        };
+        error: any;
+    }>;
+    /**
+     * Sign in with a third-party OAuth provider.
+     * Returns a URL to redirect the user to.
+     */
+    signInWithOAuth(credentials: SignInWithOAuthCredentials): Promise<{
+        data: {
+            provider: string;
+            url: string;
+        };
+        error: null;
+    }>;
+    /**
+     * Sign in with a one-time password (magic link or SMS OTP).
+     */
+    signInWithOtp(credentials: SignInWithOtpCredentials): Promise<{
+        data: {
+            messageId?: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Verify an OTP or magic link token.
+     */
+    verifyOtp(params: VerifyOtpParams): Promise<{
+        data: {
+            user: User;
+            session: Session;
+        };
+        error: any;
+    }>;
+    /**
+     * Sign in anonymously — creates an anonymous user.
+     */
+    signInAnonymously(options?: {
+        data?: Record<string, any>;
+        captchaToken?: string;
+    }): Promise<{
+        data: {
+            user: User;
+            session: Session;
+        };
+        error: any;
+    }>;
+    /**
+     * Sends a password reset email.
+     */
+    resetPasswordForEmail(email: string, options?: ResetPasswordCredentials['options']): Promise<{
+        data: {} | null;
+        error: any;
+    }>;
+    /**
+     * Update the current user (email, phone, password, metadata).
+     */
+    updateUser(attributes: UserAttributes): Promise<{
+        data: {
+            user: User;
+        };
+        error: any;
+    }>;
+    /**
+     * Sign out the current user.
+     */
+    signOut(): Promise<{
+        error: any;
+    }>;
+    /**
+     * Listen for auth state changes.
+     * Returns a subscription object with an unsubscribe method.
+     */
+    onAuthStateChange(callback: AuthChangeCallback): {
+        data: {
+            subscription: Subscription;
+        };
+    };
+    /**
+     * Manually refresh the session token.
+     */
+    refreshSession(): Promise<{
+        data: {
+            session: Session | null;
+        };
+        error: any;
+    }>;
+    /**
+     * Set the session manually (useful for server-side auth).
+     */
+    setSession(params: {
+        access_token: string;
+        refresh_token: string;
+    }): Promise<{
+        data: {
+            session: Session;
+        };
+        error: any;
+    }>;
+    /** @internal */
+    get accessToken(): string | null;
+    private _makeSession;
+    private _setSession;
+    private _removeSession;
+    private _refreshSession;
+    private _scheduleRefresh;
+    private _isSessionExpired;
+    private _notifyListeners;
+    private _persistSession;
+    private _getStoredSession;
+    private _clearStoredSession;
+}
+
+type ChannelStatus = 'SUBSCRIBED' | 'TIMED_OUT' | 'CLOSED' | 'CHANNEL_ERROR';
+/**
+ * A Realtime Channel — subscribe to postgres_changes, broadcast, and presence events.
+ */
+declare class RealtimeChannel {
+    private params;
+    private sendMessage;
+    private removeChannel;
+    private bindings;
+    private presenceState;
+    private presenceKey;
+    private _status;
+    /** @internal */
+    readonly topic: string;
+    constructor(topic: string, params: RealtimeChannelOptions, sendMessage: (msg: any) => void, removeChannel: (topic: string) => void);
+    /**
+     * Listen for events on this channel.
+     *
+     * @example
+     * channel.on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, (payload) => { ... })
+     * channel.on('broadcast', { event: 'cursor-pos' }, (payload) => { ... })
+     * channel.on('presence', { event: 'sync' }, () => { ... })
+     */
+    on(type: 'postgres_changes', filter: {
+        event: RealtimeChannelEvent;
+        schema: string;
+        table?: string;
+        filter?: string;
+    }, callback: (payload: RealtimePostgresChangesPayload) => void): this;
+    on(type: 'broadcast', filter: {
+        event: string;
+    }, callback: (payload: {
+        type: string;
+        event: string;
+        payload: any;
+    }) => void): this;
+    on(type: 'presence', filter: {
+        event: 'sync' | 'join' | 'leave';
+    }, callback: (payload: any) => void): this;
+    /**
+     * Subscribe to the channel — starts receiving events.
+     */
+    subscribe(callback?: (status: ChannelStatus, err?: Error) => void): this;
+    /**
+     * Send a broadcast message to all subscribers.
+     */
+    send(payload: {
+        type: 'broadcast';
+        event: string;
+        payload: any;
+    }): this;
+    /**
+     * Track presence for the current user.
+     */
+    track(payload: Record<string, any>): this;
+    /**
+     * Untrack presence for the current user.
+     */
+    untrack(): this;
+    /**
+     * Get current presence state.
+     */
+    presenceState_(): RealtimePresenceState;
+    /**
+     * Unsubscribe from this channel.
+     */
+    unsubscribe(): void;
+    get status(): ChannelStatus;
+    /** @internal — called by the RealtimeClient when a message arrives */
+    _handleMessage(msg: {
+        event: string;
+        payload: any;
+    }): void;
+}
+interface RealtimeClientOptions {
+    url: string;
+    apiKey: string;
+    accessToken?: string | null;
+}
+/**
+ * AfribaseRealtimeClient — manages the WebSocket connection to the
+ * Supabase-compatible Realtime service and multiplexes channels.
+ */
+declare class AfribaseRealtimeClient {
+    private url;
+    private apiKey;
+    private accessToken;
+    private ws;
+    private channels;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectBaseDelay;
+    private connected;
+    constructor(options: RealtimeClientOptions);
+    /**
+     * Set the access token (called by AfribaseClient when auth state changes).
+     */
+    setAuth(token: string | null): void;
+    /**
+     * Create a channel for a given topic.
+     */
+    channel(topic: string, options?: RealtimeChannelOptions): RealtimeChannel;
+    /**
+     * Remove all channels and disconnect.
+     */
+    removeAllChannels(): void;
+    /**
+     * Disconnect the WebSocket.
+     */
+    disconnect(): void;
+    private _connect;
+    private _disconnect;
+    private _send;
+    private _handleMessage;
+    private _startHeartbeat;
+    private _stopHeartbeat;
+    private _scheduleReconnect;
+}
+
+/**
+ * AfribaseStorageClient — upload, download, list, and manage files
+ * in Afribase Storage buckets.
+ */
+declare class AfribaseStorageClient {
+    private url;
+    private apiKey;
+    private getAccessToken;
+    private customFetch?;
+    constructor(options: {
+        url: string;
+        apiKey: string;
+        getAccessToken: () => string | null;
+        customFetch?: typeof fetch;
+    });
+    /**
+     * Get a reference to a specific bucket for file operations.
+     */
+    from(bucketId: string): StorageFileApi;
+    /**
+     * List all buckets.
+     */
+    listBuckets(): Promise<{
+        data: StorageBucket[] | null;
+        error: any;
+    }>;
+    /**
+     * Get a bucket by ID.
+     */
+    getBucket(id: string): Promise<{
+        data: StorageBucket | null;
+        error: any;
+    }>;
+    /**
+     * Create a new bucket.
+     */
+    createBucket(id: string, options?: {
+        public?: boolean;
+        fileSizeLimit?: number;
+        allowedMimeTypes?: string[];
+    }): Promise<{
+        data: {
+            name: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Update a bucket.
+     */
+    updateBucket(id: string, options: {
+        public?: boolean;
+        fileSizeLimit?: number;
+        allowedMimeTypes?: string[];
+    }): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Delete a bucket (must be empty).
+     */
+    deleteBucket(id: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Empty a bucket (remove all files).
+     */
+    emptyBucket(id: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: any;
+    }>;
+}
+declare class StorageFileApi {
+    private storageUrl;
+    private bucketId;
+    private apiKey;
+    private getAccessToken;
+    private customFetch?;
+    constructor(storageUrl: string, bucketId: string, apiKey: string, getAccessToken: () => string | null, customFetch?: typeof fetch | undefined);
+    /**
+     * Upload a file to the bucket.
+     */
+    upload(path: string, fileBody: Blob | ArrayBuffer | ReadableStream | string | Buffer, options?: UploadOptions): Promise<{
+        data: {
+            path: string;
+            id?: string;
+            fullPath?: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Update (replace) an existing file.
+     */
+    update(path: string, fileBody: Blob | ArrayBuffer | ReadableStream | string | Buffer, options?: UploadOptions): Promise<{
+        data: {
+            path: string;
+            id?: string;
+            fullPath?: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Download a file from the bucket.
+     */
+    download(path: string, options?: {
+        transform?: TransformOptions;
+    }): Promise<{
+        data: Blob | null;
+        error: any;
+    }>;
+    /**
+     * List objects in the bucket.
+     */
+    list(path?: string, options?: {
+        limit?: number;
+        offset?: number;
+        sortBy?: {
+            column: string;
+            order: 'asc' | 'desc';
+        };
+    }): Promise<{
+        data: StorageObject[] | null;
+        error: any;
+    }>;
+    /**
+     * Move a file to a new path within the same bucket.
+     */
+    move(fromPath: string, toPath: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Copy a file to a new path within the same bucket.
+     */
+    copy(fromPath: string, toPath: string): Promise<{
+        data: {
+            path: string;
+        } | null;
+        error: any;
+    }>;
+    /**
+     * Remove one or more files from the bucket.
+     */
+    remove(paths: string[]): Promise<{
+        data: StorageObject[] | null;
+        error: any;
+    }>;
+    /**
+     * Create a signed URL for temporary access to a private file.
+     */
+    createSignedUrl(path: string, expiresIn: number, options?: SignedUrlOptions): Promise<{
+        data: CreateSignedUrlResponse | null;
+        error: any;
+    }>;
+    /**
+     * Create signed URLs for multiple files.
+     */
+    createSignedUrls(paths: string[], expiresIn: number): Promise<{
+        data: CreateSignedUrlResponse[] | null;
+        error: any;
+    }>;
+    /**
+     * Get the public URL for a file in a public bucket.
+     */
+    getPublicUrl(path: string, options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }): {
+        data: {
+            publicUrl: string;
+        };
+    };
+}
+
+/**
+ * AfribaseFunctionsClient — invoke Afribase Edge Functions.
+ */
+declare class AfribaseFunctionsClient {
+    private url;
+    private apiKey;
+    private getAccessToken;
+    private customFetch?;
+    constructor(options: {
+        url: string;
+        apiKey: string;
+        getAccessToken: () => string | null;
+        customFetch?: typeof fetch;
+    });
+    /**
+     * Invoke an edge function by name.
+     *
+     * @example
+     * const { data, error } = await client.functions.invoke('hello-world', {
+     *   body: { name: 'Afribase' },
+     * });
+     */
+    invoke<T = any>(functionName: string, options?: FunctionInvokeOptions): Promise<{
+        data: T | null;
+        error: any;
+    }>;
+}
+
+/**
+ * AfribaseQueryBuilder — a PostgREST-compatible query builder with
+ * full filter/modifier support matching the supabase-js API.
+ */
+declare class AfribaseQueryBuilder<T = any> {
+    private _url;
+    private _apiKey;
+    private _accessToken;
+    private _customFetch?;
+    private _query;
+    private _headers;
+    private _method;
+    private _body;
+    private _isSingle;
+    private _isMaybeSingle;
+    private _isHead;
+    private _countType;
+    constructor(url: string, options: {
+        apiKey: string;
+        accessToken: string | null;
+        customFetch?: typeof fetch;
+    });
+    /**
+     * Perform a SELECT query.
+     */
+    select(columns?: string, options?: {
+        count?: 'exact' | 'planned' | 'estimated';
+        head?: boolean;
+    }): this;
+    /**
+     * Perform an INSERT.
+     */
+    insert(values: Partial<T> | Partial<T>[], options?: {
+        count?: 'exact' | 'planned' | 'estimated';
+        defaultToNull?: boolean;
+    }): this;
+    /**
+     * Perform an UPSERT (insert or update on conflict).
+     */
+    upsert(values: Partial<T> | Partial<T>[], options?: {
+        onConflict?: string;
+        ignoreDuplicates?: boolean;
+        count?: 'exact' | 'planned' | 'estimated';
+        defaultToNull?: boolean;
+    }): this;
+    /**
+     * Perform an UPDATE (must be combined with filters).
+     */
+    update(values: Partial<T>, options?: {
+        count?: 'exact' | 'planned' | 'estimated';
+    }): this;
+    /**
+     * Perform a DELETE (must be combined with filters).
+     */
+    delete(options?: {
+        count?: 'exact' | 'planned' | 'estimated';
+    }): this;
+    eq(column: string, value: any): this;
+    neq(column: string, value: any): this;
+    gt(column: string, value: any): this;
+    gte(column: string, value: any): this;
+    lt(column: string, value: any): this;
+    lte(column: string, value: any): this;
+    like(column: string, pattern: string): this;
+    ilike(column: string, pattern: string): this;
+    is(column: string, value: 'null' | 'true' | 'false' | null | boolean): this;
+    in(column: string, values: any[]): this;
+    contains(column: string, value: any): this;
+    containedBy(column: string, value: any): this;
+    /**
+     * Full text search using to_tsquery.
+     */
+    textSearch(column: string, query: string, options?: {
+        type?: 'plain' | 'phrase' | 'websearch';
+        config?: string;
+    }): this;
+    /**
+     * Negate a filter.
+     */
+    not(column: string, operator: string, value: any): this;
+    /**
+     * Combine filters with OR.
+     */
+    or(filters: string, options?: {
+        foreignTable?: string;
+    }): this;
+    /**
+     * Generic filter — any PostgREST operator.
+     */
+    filter(column: string, operator: string, value: any): this;
+    /**
+     * Match multiple column values (shorthand for multiple .eq).
+     */
+    match(query: Record<string, any>): this;
+    /**
+     * Order results.
+     */
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+        foreignTable?: string;
+    }): this;
+    /**
+     * Limit the number of results.
+     */
+    limit(count: number, options?: {
+        foreignTable?: string;
+    }): this;
+    /**
+     * Paginate with offset.
+     */
+    range(from: number, to: number, options?: {
+        foreignTable?: string;
+    }): this;
+    /**
+     * Return a single row (throws if 0 or 2+ rows).
+     */
+    single(): this;
+    /**
+     * Return at most one row (returns null if 0 rows).
+     */
+    maybeSingle(): this;
+    /**
+     * Return as CSV.
+     */
+    csv(): this;
+    /**
+     * Return a GeoJSON response.
+     */
+    geojson(): this;
+    /**
+     * Limit the fields returned (PostgREST explain).
+     */
+    explain(options?: {
+        analyze?: boolean;
+        verbose?: boolean;
+        settings?: boolean;
+        buffers?: boolean;
+        format?: 'json' | 'text';
+    }): this;
+    /**
+     * Execute the query and return the results.
+     */
+    then<TResult1 = PostgrestResponse<T[]>, TResult2 = never>(onfulfilled?: ((value: PostgrestResponse<T[]>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    private _execute;
+}
+/**
+ * Call a Postgres function (RPC).
+ */
+declare class AfribaseRpcBuilder<T = any> {
+    private _url;
+    private _apiKey;
+    private _accessToken;
+    private _customFetch?;
+    private _params;
+    private _query;
+    private _headers;
+    private _isSingle;
+    private _countType;
+    private _method;
+    constructor(url: string, fnName: string, params: Record<string, any>, options: {
+        apiKey: string;
+        accessToken: string | null;
+        customFetch?: typeof fetch;
+        head?: boolean;
+        count?: 'exact' | 'planned' | 'estimated';
+        get?: boolean;
+    });
+    single(): this;
+    maybeSingle(): this;
+    select(columns?: string): this;
+    order(column: string, options?: {
+        ascending?: boolean;
+    }): this;
+    limit(count: number): this;
+    range(from: number, to: number): this;
+    eq(column: string, value: any): this;
+    filter(column: string, operator: string, value: any): this;
+    then<TResult1 = PostgrestResponse<T>, TResult2 = never>(onfulfilled?: ((value: PostgrestResponse<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    private _execute;
+}
+
+/**
+ * Functional-Fluent Query Operations for Afribase.
+ * This enables tree-shakable, modular query building.
+ */
+type QueryOp<T = any> = (builder: AfribaseQueryBuilder<T>) => AfribaseQueryBuilder<T>;
+/**
+ * The 'db' orchestrator allows piping multiple operations.
+ */
+declare function db<T = any>(builder: AfribaseQueryBuilder<T>, ...ops: QueryOp<T>[]): Promise<any>;
+declare const select: (columns?: string, options?: {
+    count?: "exact" | "planned" | "estimated";
+    head?: boolean;
+}) => QueryOp;
+declare const insert: <T>(values: Partial<T> | Partial<T>[], options?: {
+    count?: "exact" | "planned" | "estimated";
+    defaultToNull?: boolean;
+}) => QueryOp<T>;
+declare const update: <T>(values: Partial<T>, options?: {
+    count?: "exact" | "planned" | "estimated";
+}) => QueryOp<T>;
+declare const upsert: <T>(values: Partial<T> | Partial<T>[], options?: {
+    onConflict?: string;
+    ignoreDuplicates?: boolean;
+    count?: "exact" | "planned" | "estimated";
+    defaultToNull?: boolean;
+}) => QueryOp<T>;
+declare const del: (options?: {
+    count?: "exact" | "planned" | "estimated";
+}) => QueryOp;
+declare const eq: (column: string, value: any) => QueryOp;
+declare const neq: (column: string, value: any) => QueryOp;
+declare const gt: (column: string, value: any) => QueryOp;
+declare const gte: (column: string, value: any) => QueryOp;
+declare const lt: (column: string, value: any) => QueryOp;
+declare const lte: (column: string, value: any) => QueryOp;
+declare const like: (column: string, pattern: string) => QueryOp;
+declare const ilike: (column: string, pattern: string) => QueryOp;
+declare const is: (column: string, value: "null" | "true" | "false" | null | boolean) => QueryOp;
+declare const isIn: (column: string, values: any[]) => QueryOp;
+declare const contains: (column: string, value: any) => QueryOp;
+declare const containedBy: (column: string, value: any) => QueryOp;
+declare const textSearch: (column: string, query: string, options?: {
+    type?: "plain" | "phrase" | "websearch";
+    config?: string;
+}) => QueryOp;
+declare const not: (column: string, operator: string, value: any) => QueryOp;
+declare const or: (filters: string, options?: {
+    foreignTable?: string;
+}) => QueryOp;
+declare const match: (query: Record<string, any>) => QueryOp;
+declare const order: (column: string, options?: {
+    ascending?: boolean;
+    nullsFirst?: boolean;
+    foreignTable?: string;
+}) => QueryOp;
+declare const limit: (count: number, options?: {
+    foreignTable?: string;
+}) => QueryOp;
+declare const range: (from: number, to: number, options?: {
+    foreignTable?: string;
+}) => QueryOp;
+declare const single: () => QueryOp;
+declare const maybeSingle: () => QueryOp;
+declare const csv: () => QueryOp;
+declare const geojson: () => QueryOp;
+declare const explain: (options?: {
+    analyze?: boolean;
+    verbose?: boolean;
+    settings?: boolean;
+    buffers?: boolean;
+    format?: "json" | "text";
+}) => QueryOp;
+
+/**
+ * The main Afribase client. Provides access to Auth, Database, Realtime,
+ * Storage, and Edge Functions — matching the supabase-js API surface.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from '@afribase/afribase-js';
+ *
+ * const afribase = createClient('https://your-project.useafribase.app', 'your-anon-key');
+ *
+ * // Auth
+ * const { data } = await afribase.auth.signInWithPassword({ email: '...', password: '...' });
+ *
+ * // Database
+ * const { data: rows } = await afribase.from('posts').select('*').eq('published', true);
+ *
+ * // Realtime
+ * afribase.channel('room1')
+ *   .on('broadcast', { event: 'message' }, (payload) => console.log(payload))
+ *   .subscribe();
+ *
+ * // Storage
+ * const { data: url } = afribase.storage.from('avatars').getPublicUrl('avatar.png');
+ *
+ * // Functions
+ * const { data: result } = await afribase.functions.invoke('my-function', { body: { foo: 'bar' } });
+ *
+ * // RPC
+ * const { data: total } = await afribase.rpc('get_total_count', { table_name: 'users' });
+ * ```
+ */
+declare class AfribaseClient {
+    /**
+     * The auth client for authentication and user management.
+     */
+    readonly auth: AfribaseAuthClient;
+    /**
+     * The storage client for file uploads, downloads, and bucket management.
+     */
+    readonly storage: AfribaseStorageClient;
+    /**
+     * The functions client for invoking Afribase Edge Functions.
+     */
+    readonly functions: AfribaseFunctionsClient;
+    private readonly realtimeClient;
+    private readonly baseUrl;
+    private readonly anonKey;
+    private readonly restUrl;
+    private readonly customFetch?;
+    constructor(baseUrl: string, anonKey: string, options?: Partial<AfribaseClientOptions>);
+    /**
+     * Query a table via PostgREST.
+     *
+     * @example
+     * const { data } = await afribase.from('users').select('*').eq('id', 1);
+     * const { data } = await afribase.from('posts').select('*, comments(*)').order('created_at', { ascending: false }).limit(10);
+     */
+    from<T = any>(table: string): AfribaseQueryBuilder<T>;
+    /**
+     * Call a Postgres function (RPC).
+     *
+     * @example
+     * const { data } = await afribase.rpc('get_top_users', { limit_count: 10 });
+     */
+    rpc<T = any>(fn: string, params?: Record<string, any>, options?: {
+        count?: 'exact' | 'planned' | 'estimated';
+        head?: boolean;
+        get?: boolean;
+    }): AfribaseRpcBuilder<T>;
+    /**
+     * Create a realtime channel.
+     *
+     * @example
+     * const channel = afribase.channel('room:lobby');
+     * channel.on('broadcast', { event: 'message' }, (payload) => console.log(payload)).subscribe();
+     */
+    channel(name: string, options?: RealtimeChannelOptions): RealtimeChannel;
+    /**
+     * Remove all realtime channels and disconnect.
+     */
+    removeAllChannels(): void;
+    /**
+     * Get the underlying realtime client.
+     */
+    get realtime(): AfribaseRealtimeClient;
+}
+/**
+ * Create a new AfribaseClient instance.
+ *
+ * @example
+ * const afribase = createClient('https://your-project.useafribase.app', 'your-anon-key');
+ */
+declare const createClient: (baseUrl: string, anonKey: string, options?: Partial<AfribaseClientOptions>) => AfribaseClient;
+
+export { AfribaseAuthClient, AfribaseClient, type AfribaseClientOptions, AfribaseFunctionsClient, AfribaseQueryBuilder, AfribaseRealtimeClient, AfribaseRpcBuilder, AfribaseStorageClient, type AuthChangeCallback, type AuthChangeEvent, type CreateSignedUrlResponse, type Factor, type FilterOperator, type FunctionInvokeOptions, type FunctionInvokeResponse, type OAuthProvider, type PostgrestError, type PostgrestResponse, type PostgrestSingleResponse, type PresenceEntry, type QueryOp, RealtimeChannel, type RealtimeChannelEvent, type RealtimeChannelOptions, type RealtimeListenTypes, type RealtimePostgresChangesPayload, type RealtimePresenceState, type ResetPasswordCredentials, type Session, type SignInWithOAuthCredentials, type SignInWithOtpCredentials, type SignInWithPasswordCredentials, type SignUpCredentials, type SignedUrlOptions, type StorageBucket, StorageFileApi, type StorageObject, type Subscription, type TransformOptions, type UploadOptions, type User, type UserAttributes, type UserIdentity, type VerifyOtpParams, containedBy, contains, createClient, csv, db, del, eq, explain, geojson, gt, gte, ilike, insert, is, isIn, like, limit, lt, lte, match, maybeSingle, neq, not, or, order, range, select, single, textSearch, update, upsert };