@fluxbase/sdk 0.0.1-rc.2 → 0.0.1-rc.20

package/dist/index.d.ts

@@ -1,13 +1,11 @@
 /**
  * Core types for the Fluxbase SDK
  */
+/**
+ * Client configuration options (Supabase-compatible)
+ * These options are passed as the third parameter to createClient()
+ */
 interface FluxbaseClientOptions {
-    /**
-     * Base URL of your Fluxbase instance
-     * @example 'https://api.myapp.com'
-     * @example 'http://localhost:8080'
-     */
-    url: string;
     /**
      * Authentication options
      */
@@ -149,24 +147,60 @@ interface PostgresChangesConfig {
     table: string;
     filter?: string;
 }
+/**
+ * Realtime postgres_changes payload structure
+ * Compatible with Supabase realtime payloads
+ */
+interface RealtimePostgresChangesPayload<T = any> {
+    /** Event type (Supabase-compatible field name) */
+    eventType: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+    /** Database schema */
+    schema: string;
+    /** Table name */
+    table: string;
+    /** Commit timestamp (Supabase-compatible field name) */
+    commit_timestamp: string;
+    /** New record data (Supabase-compatible field name) */
+    new: T;
+    /** Old record data (Supabase-compatible field name) */
+    old: T;
+    /** Error message if any */
+    errors: string | null;
+}
+/**
+ * @deprecated Use RealtimePostgresChangesPayload instead
+ */
 interface RealtimeChangePayload {
+    /** @deprecated Use eventType instead */
     type: 'INSERT' | 'UPDATE' | 'DELETE';
     schema: string;
     table: string;
+    /** @deprecated Use 'new' instead */
     new_record?: Record<string, unknown>;
+    /** @deprecated Use 'old' instead */
     old_record?: Record<string, unknown>;
+    /** @deprecated Use commit_timestamp instead */
     timestamp: string;
 }
-type RealtimeCallback = (payload: RealtimeChangePayload) => void;
-interface StorageObject {
-    key: string;
-    bucket: string;
-    size: number;
-    content_type: string;
-    last_modified: string;
-    etag?: string;
-    metadata?: Record<string, string>;
+type RealtimeCallback = (payload: RealtimePostgresChangesPayload) => void;
+/**
+ * File object returned by storage operations
+ * Compatible with Supabase FileObject structure
+ */
+interface FileObject {
+    name: string;
+    id?: string;
+    bucket_id?: string;
+    owner?: string;
+    created_at?: string;
+    updated_at?: string;
+    last_accessed_at?: string;
+    metadata?: Record<string, any>;
 }
+/**
+ * @deprecated Use FileObject instead. This alias is provided for backwards compatibility.
+ */
+type StorageObject = FileObject;
 interface UploadOptions {
     contentType?: string;
     metadata?: Record<string, string>;
@@ -181,6 +215,29 @@ interface ListOptions {
 interface SignedUrlOptions {
     expiresIn?: number;
 }
+interface ShareFileOptions {
+    userId: string;
+    permission: 'read' | 'write';
+}
+interface FileShare {
+    user_id: string;
+    permission: 'read' | 'write';
+    created_at: string;
+}
+interface BucketSettings {
+    public?: boolean;
+    allowed_mime_types?: string[];
+    max_file_size?: number;
+}
+interface Bucket {
+    id: string;
+    name: string;
+    public: boolean;
+    allowed_mime_types: string[];
+    max_file_size?: number;
+    created_at: string;
+    updated_at: string;
+}
 interface PasswordResetResponse {
     message: string;
 }
@@ -216,6 +273,7 @@ interface AdminSetupRequest {
     email: string;
     password: string;
     name: string;
+    setup_token: string;
 }
 interface AdminUser {
     id: string;
@@ -456,6 +514,48 @@ interface UpdateSystemSettingRequest {
 interface ListSystemSettingsResponse {
     settings: SystemSetting[];
 }
+/**
+ * Custom setting with flexible key-value storage and role-based editing permissions
+ */
+interface CustomSetting {
+    id: string;
+    key: string;
+    value: Record<string, unknown>;
+    value_type: 'string' | 'number' | 'boolean' | 'json';
+    description?: string;
+    editable_by: string[];
+    metadata?: Record<string, unknown>;
+    created_by?: string;
+    updated_by?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to create a custom setting
+ */
+interface CreateCustomSettingRequest {
+    key: string;
+    value: Record<string, unknown>;
+    value_type?: 'string' | 'number' | 'boolean' | 'json';
+    description?: string;
+    editable_by?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Request to update a custom setting
+ */
+interface UpdateCustomSettingRequest {
+    value: Record<string, unknown>;
+    description?: string;
+    editable_by?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Response containing all custom settings
+ */
+interface ListCustomSettingsResponse {
+    settings: CustomSetting[];
+}
 /**
  * Authentication settings for the application
  */
@@ -464,6 +564,12 @@ interface AuthenticationSettings {
     enable_magic_link: boolean;
     password_min_length: number;
     require_email_verification: boolean;
+    password_require_uppercase: boolean;
+    password_require_lowercase: boolean;
+    password_require_number: boolean;
+    password_require_special: boolean;
+    session_timeout_minutes: number;
+    max_sessions_per_user: number;
 }
 /**
  * Feature flags for the application
@@ -473,12 +579,51 @@ interface FeatureSettings {
     enable_storage: boolean;
     enable_functions: boolean;
 }
+/**
+ * SMTP email provider configuration
+ */
+interface SMTPSettings {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    use_tls: boolean;
+}
+/**
+ * SendGrid email provider configuration
+ */
+interface SendGridSettings {
+    api_key: string;
+}
+/**
+ * Mailgun email provider configuration
+ */
+interface MailgunSettings {
+    api_key: string;
+    domain: string;
+    eu_region: boolean;
+}
+/**
+ * AWS SES email provider configuration
+ */
+interface SESSettings {
+    access_key_id: string;
+    secret_access_key: string;
+    region: string;
+}
 /**
  * Email configuration settings
  */
 interface EmailSettings {
     enabled: boolean;
-    provider: string;
+    provider: 'smtp' | 'sendgrid' | 'mailgun' | 'ses';
+    from_address?: string;
+    from_name?: string;
+    reply_to_address?: string;
+    smtp?: SMTPSettings;
+    sendgrid?: SendGridSettings;
+    mailgun?: MailgunSettings;
+    ses?: SESSettings;
 }
 /**
  * Security settings for the application
@@ -505,6 +650,43 @@ interface UpdateAppSettingsRequest {
     email?: Partial<EmailSettings>;
     security?: Partial<SecuritySettings>;
 }
+/**
+ * Email template type
+ */
+type EmailTemplateType = 'magic_link' | 'verify_email' | 'reset_password' | 'invite_user';
+/**
+ * Email template structure
+ */
+interface EmailTemplate {
+    id: string;
+    template_type: EmailTemplateType;
+    subject: string;
+    html_body: string;
+    text_body?: string;
+    is_custom: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to update an email template
+ */
+interface UpdateEmailTemplateRequest {
+    subject: string;
+    html_body: string;
+    text_body?: string;
+}
+/**
+ * Request to test an email template
+ */
+interface TestEmailTemplateRequest {
+    recipient_email: string;
+}
+/**
+ * Response when listing email templates
+ */
+interface ListEmailTemplatesResponse {
+    templates: EmailTemplate[];
+}
 interface OAuthProvider {
     id: string;
     name: string;
@@ -816,85 +998,347 @@ interface AuthSubscription {
      */
     unsubscribe: () => void;
 }
-
 /**
- * HTTP client for making requests to the Fluxbase API
+ * Options for invoking an edge function
  */
-
-interface FetchOptions {
-    method: HttpMethod;
-    headers?: Record<string, string>;
-    body?: unknown;
-    timeout?: number;
-}
-declare class FluxbaseFetch {
-    private baseUrl;
-    private defaultHeaders;
-    private timeout;
-    private debug;
-    constructor(baseUrl: string, options?: {
-        headers?: Record<string, string>;
-        timeout?: number;
-        debug?: boolean;
-    });
+interface FunctionInvokeOptions {
     /**
-     * Update the authorization header
+     * Request body to send to the function
      */
-    setAuthToken(token: string | null): void;
+    body?: any;
     /**
-     * Make an HTTP request
+     * Custom headers to include in the request
      */
-    request<T = unknown>(path: string, options: FetchOptions): Promise<T>;
+    headers?: Record<string, string>;
     /**
-     * GET request
+     * HTTP method to use
+     * @default 'POST'
      */
-    get<T = unknown>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<T>;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+}
+/**
+ * Edge function metadata
+ */
+interface EdgeFunction {
+    id: string;
+    name: string;
+    description?: string;
+    code: string;
+    version: number;
+    enabled: boolean;
+    timeout_seconds: number;
+    memory_limit_mb: number;
+    allow_net: boolean;
+    allow_env: boolean;
+    allow_read: boolean;
+    allow_write: boolean;
+    allow_unauthenticated: boolean;
+    cron_schedule?: string;
+    created_at: string;
+    updated_at: string;
+    created_by?: string;
+}
+/**
+ * Request to create a new edge function
+ */
+interface CreateFunctionRequest {
+    name: string;
+    description?: string;
+    code: string;
+    enabled?: boolean;
+    timeout_seconds?: number;
+    memory_limit_mb?: number;
+    allow_net?: boolean;
+    allow_env?: boolean;
+    allow_read?: boolean;
+    allow_write?: boolean;
+    allow_unauthenticated?: boolean;
+    cron_schedule?: string;
+}
+/**
+ * Request to update an existing edge function
+ */
+interface UpdateFunctionRequest {
+    description?: string;
+    code?: string;
+    enabled?: boolean;
+    timeout_seconds?: number;
+    memory_limit_mb?: number;
+    allow_net?: boolean;
+    allow_env?: boolean;
+    allow_read?: boolean;
+    allow_write?: boolean;
+    allow_unauthenticated?: boolean;
+    cron_schedule?: string;
+}
+/**
+ * Edge function execution record
+ */
+interface EdgeFunctionExecution {
+    id: string;
+    function_id: string;
+    trigger_type: string;
+    status: 'success' | 'error';
+    status_code?: number;
+    duration_ms?: number;
+    result?: string;
+    logs?: string;
+    error_message?: string;
+    executed_at: string;
+    completed_at?: string;
+}
+/**
+ * Base Fluxbase response type (Supabase-compatible)
+ * Returns either `{ data, error: null }` on success or `{ data: null, error }` on failure
+ */
+type FluxbaseResponse<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: Error;
+};
+/**
+ * Response type for operations that don't return data (void operations)
+ */
+type VoidResponse = {
+    error: Error | null;
+};
+/**
+ * Auth response with user and session
+ */
+type AuthResponseData = {
+    user: User;
+    session: AuthSession;
+};
+/**
+ * Fluxbase auth response
+ */
+type FluxbaseAuthResponse = FluxbaseResponse<AuthResponseData>;
+/**
+ * User response
+ */
+type UserResponse = FluxbaseResponse<{
+    user: User;
+}>;
+/**
+ * Session response
+ */
+type SessionResponse = FluxbaseResponse<{
+    session: AuthSession;
+}>;
+/**
+ * Generic data response
+ */
+type DataResponse<T> = FluxbaseResponse<T>;
+/**
+ * @deprecated Use FluxbaseResponse instead
+ */
+type SupabaseResponse<T> = FluxbaseResponse<T>;
+/**
+ * @deprecated Use FluxbaseAuthResponse instead
+ */
+type SupabaseAuthResponse = FluxbaseAuthResponse;
+
+/**
+ * Realtime subscriptions using WebSockets
+ */
+
+declare class RealtimeChannel {
+    private ws;
+    private url;
+    private token;
+    private channelName;
+    private callbacks;
+    private subscriptionConfig;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private heartbeatInterval;
+    constructor(url: string, channelName: string, token?: string | null);
     /**
-     * POST request
+     * Listen to postgres_changes with optional row-level filtering
+     *
+     * @param event - 'postgres_changes'
+     * @param config - Configuration including optional filter
+     * @param callback - Function to call when changes occur
+     * @returns This channel for chaining
+     *
+     * @example
+     * ```typescript
+     * channel.on('postgres_changes', {
+     *   event: '*',
+     *   schema: 'public',
+     *   table: 'jobs',
+     *   filter: 'created_by=eq.user123'
+     * }, (payload) => {
+     *   console.log('Job updated:', payload)
+     * })
+     * ```
      */
-    post<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    on(event: "postgres_changes", config: PostgresChangesConfig, callback: RealtimeCallback): this;
     /**
-     * PUT request
+     * Listen to a specific event type (backwards compatibility)
+     *
+     * @param event - The event type (INSERT, UPDATE, DELETE, or '*' for all)
+     * @param callback - The callback function
+     * @returns This channel for chaining
+     *
+     * @example
+     * ```typescript
+     * channel.on('INSERT', (payload) => {
+     *   console.log('New record inserted:', payload.new_record)
+     * })
+     * ```
      */
-    put<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    on(event: "INSERT" | "UPDATE" | "DELETE" | "*", callback: RealtimeCallback): this;
     /**
-     * PATCH request
+     * Remove a callback
      */
-    patch<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    off(event: "INSERT" | "UPDATE" | "DELETE" | "*", callback: RealtimeCallback): this;
     /**
-     * DELETE request
+     * Subscribe to the channel
+     * @param callback - Optional status callback (Supabase-compatible)
+     * @param _timeout - Optional timeout in milliseconds (currently unused)
      */
-    delete<T = unknown>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<T>;
+    subscribe(callback?: (status: "SUBSCRIBED" | "CHANNEL_ERROR" | "TIMED_OUT" | "CLOSED", err?: Error) => void, _timeout?: number): this;
     /**
-     * HEAD request
+     * Unsubscribe from the channel
+     * @param timeout - Optional timeout in milliseconds
+     * @returns Promise resolving to status string (Supabase-compatible)
      */
-    head(path: string, options?: Omit<FetchOptions, 'method'>): Promise<Headers>;
-}
-
-/**
- * Authentication module for Fluxbase SDK
- */
-
-declare class FluxbaseAuth {
-    private fetch;
-    private session;
-    private persist;
-    private autoRefresh;
-    private refreshTimer;
-    private stateChangeListeners;
-    constructor(fetch: FluxbaseFetch, autoRefresh?: boolean, persist?: boolean);
+    unsubscribe(timeout?: number): Promise<"ok" | "timed out" | "error">;
     /**
-     * Get the current session
+     * Internal: Connect to WebSocket
      */
-    getSession(): AuthSession | null;
+    private connect;
     /**
-     * Get the current user
+     * Internal: Disconnect WebSocket
      */
-    getUser(): User | null;
+    private disconnect;
     /**
-     * Get the current access token
+     * Internal: Send a message
      */
-    getAccessToken(): string | null;
+    private send;
+    /**
+     * Internal: Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Internal: Handle broadcast message
+     */
+    private handleBroadcast;
+    /**
+     * Internal: Start heartbeat interval
+     */
+    private startHeartbeat;
+    /**
+     * Internal: Stop heartbeat interval
+     */
+    private stopHeartbeat;
+    /**
+     * Internal: Attempt to reconnect
+     */
+    private attemptReconnect;
+}
+declare class FluxbaseRealtime {
+    private url;
+    private token;
+    private channels;
+    constructor(url: string, token?: string | null);
+    /**
+     * Create or get a channel
+     * @param channelName - Channel name (e.g., 'table:public.products')
+     */
+    channel(channelName: string): RealtimeChannel;
+    /**
+     * Remove all channels
+     */
+    removeAllChannels(): void;
+    /**
+     * Update auth token for all channels
+     */
+    setToken(token: string | null): void;
+}
+
+/**
+ * HTTP client for making requests to the Fluxbase API
+ */
+
+interface FetchOptions {
+    method: HttpMethod;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+}
+declare class FluxbaseFetch {
+    private baseUrl;
+    private defaultHeaders;
+    private timeout;
+    private debug;
+    constructor(baseUrl: string, options?: {
+        headers?: Record<string, string>;
+        timeout?: number;
+        debug?: boolean;
+    });
+    /**
+     * Update the authorization header
+     */
+    setAuthToken(token: string | null): void;
+    /**
+     * Make an HTTP request
+     */
+    request<T = unknown>(path: string, options: FetchOptions): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T = unknown>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T = unknown>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<T>;
+    /**
+     * HEAD request
+     */
+    head(path: string, options?: Omit<FetchOptions, 'method'>): Promise<Headers>;
+}
+
+/**
+ * Authentication module for Fluxbase SDK
+ */
+
+declare class FluxbaseAuth {
+    private fetch;
+    private session;
+    private persist;
+    private autoRefresh;
+    private refreshTimer;
+    private stateChangeListeners;
+    constructor(fetch: FluxbaseFetch, autoRefresh?: boolean, persist?: boolean);
+    /**
+     * Get the current session
+     */
+    getSession(): AuthSession | null;
+    /**
+     * Get the current user
+     */
+    getUser(): User | null;
+    /**
+     * Get the current access token
+     */
+    getAccessToken(): string | null;
     /**
      * Listen to auth state changes
      * @param callback - Function called when auth state changes
@@ -915,27 +1359,33 @@ declare class FluxbaseAuth {
      * Sign in with email and password
      * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
      */
-    signIn(credentials: SignInCredentials): Promise<AuthSession | SignInWith2FAResponse>;
+    signIn(credentials: SignInCredentials): Promise<FluxbaseResponse<AuthSession | SignInWith2FAResponse>>;
+    /**
+     * Sign in with email and password
+     * Alias for signIn() to maintain compatibility with common authentication patterns
+     * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
+     */
+    signInWithPassword(credentials: SignInCredentials): Promise<FluxbaseResponse<AuthSession | SignInWith2FAResponse>>;
     /**
      * Sign up with email and password
      */
-    signUp(credentials: SignUpCredentials): Promise<AuthSession>;
+    signUp(credentials: SignUpCredentials): Promise<FluxbaseAuthResponse>;
     /**
      * Sign out the current user
      */
-    signOut(): Promise<void>;
+    signOut(): Promise<VoidResponse>;
     /**
      * Refresh the access token
      */
-    refreshToken(): Promise<AuthSession>;
+    refreshToken(): Promise<SessionResponse>;
     /**
      * Get the current user from the server
      */
-    getCurrentUser(): Promise<User>;
+    getCurrentUser(): Promise<UserResponse>;
     /**
      * Update the current user
      */
-    updateUser(data: Partial<Pick<User, 'email' | 'metadata'>>): Promise<User>;
+    updateUser(data: Partial<Pick<User, "email" | "metadata">>): Promise<UserResponse>;
     /**
      * Set the auth token manually
      */
@@ -944,87 +1394,98 @@ declare class FluxbaseAuth {
      * Setup 2FA for the current user
      * Returns TOTP secret and QR code URL
      */
-    setup2FA(): Promise<TwoFactorSetupResponse>;
+    setup2FA(): Promise<DataResponse<TwoFactorSetupResponse>>;
     /**
      * Enable 2FA after verifying the TOTP code
      * Returns backup codes that should be saved by the user
      */
-    enable2FA(code: string): Promise<TwoFactorEnableResponse>;
+    enable2FA(code: string): Promise<DataResponse<TwoFactorEnableResponse>>;
     /**
      * Disable 2FA for the current user
      * Requires password confirmation
      */
-    disable2FA(password: string): Promise<{
+    disable2FA(password: string): Promise<DataResponse<{
         success: boolean;
         message: string;
-    }>;
+    }>>;
     /**
      * Check 2FA status for the current user
      */
-    get2FAStatus(): Promise<TwoFactorStatusResponse>;
+    get2FAStatus(): Promise<DataResponse<TwoFactorStatusResponse>>;
     /**
      * Verify 2FA code during login
      * Call this after signIn returns requires_2fa: true
      */
-    verify2FA(request: TwoFactorVerifyRequest): Promise<AuthSession>;
+    verify2FA(request: TwoFactorVerifyRequest): Promise<FluxbaseAuthResponse>;
     /**
      * Send password reset email
      * Sends a password reset link to the provided email address
      * @param email - Email address to send reset link to
      */
-    sendPasswordReset(email: string): Promise<PasswordResetResponse>;
+    sendPasswordReset(email: string): Promise<DataResponse<PasswordResetResponse>>;
+    /**
+     * Supabase-compatible alias for sendPasswordReset()
+     * @param email - Email address to send reset link to
+     * @param _options - Optional redirect configuration (currently not used)
+     */
+    resetPasswordForEmail(email: string, _options?: {
+        redirectTo?: string;
+    }): Promise<DataResponse<PasswordResetResponse>>;
     /**
      * Verify password reset token
      * Check if a password reset token is valid before allowing password reset
      * @param token - Password reset token to verify
      */
-    verifyResetToken(token: string): Promise<VerifyResetTokenResponse>;
+    verifyResetToken(token: string): Promise<DataResponse<VerifyResetTokenResponse>>;
     /**
      * Reset password with token
      * Complete the password reset process with a valid token
      * @param token - Password reset token
      * @param newPassword - New password to set
      */
-    resetPassword(token: string, newPassword: string): Promise<ResetPasswordResponse>;
+    resetPassword(token: string, newPassword: string): Promise<DataResponse<ResetPasswordResponse>>;
     /**
      * Send magic link for passwordless authentication
      * @param email - Email address to send magic link to
      * @param options - Optional configuration for magic link
      */
-    sendMagicLink(email: string, options?: MagicLinkOptions): Promise<MagicLinkResponse>;
+    sendMagicLink(email: string, options?: MagicLinkOptions): Promise<DataResponse<MagicLinkResponse>>;
     /**
      * Verify magic link token and sign in
      * @param token - Magic link token from email
      */
-    verifyMagicLink(token: string): Promise<AuthSession>;
+    verifyMagicLink(token: string): Promise<FluxbaseAuthResponse>;
     /**
      * Sign in anonymously
      * Creates a temporary anonymous user session
      */
-    signInAnonymously(): Promise<AuthSession>;
+    signInAnonymously(): Promise<FluxbaseAuthResponse>;
     /**
      * Get list of enabled OAuth providers
      */
-    getOAuthProviders(): Promise<OAuthProvidersResponse>;
+    getOAuthProviders(): Promise<DataResponse<OAuthProvidersResponse>>;
     /**
      * Get OAuth authorization URL for a provider
      * @param provider - OAuth provider name (e.g., 'google', 'github')
      * @param options - Optional OAuth configuration
      */
-    getOAuthUrl(provider: string, options?: OAuthOptions): Promise<OAuthUrlResponse>;
+    getOAuthUrl(provider: string, options?: OAuthOptions): Promise<DataResponse<OAuthUrlResponse>>;
     /**
      * Exchange OAuth authorization code for session
      * This is typically called in your OAuth callback handler
      * @param code - Authorization code from OAuth callback
      */
-    exchangeCodeForSession(code: string): Promise<AuthSession>;
+    exchangeCodeForSession(code: string): Promise<FluxbaseAuthResponse>;
     /**
      * Convenience method to initiate OAuth sign-in
      * Redirects the user to the OAuth provider's authorization page
      * @param provider - OAuth provider name (e.g., 'google', 'github')
      * @param options - Optional OAuth configuration
      */
-    signInWithOAuth(provider: string, options?: OAuthOptions): Promise<void>;
+    signInWithOAuth(provider: string, options?: OAuthOptions): Promise<DataResponse<{
+        provider: string;
+        url: string;
+    }>>;
     /**
      * Internal: Set the session and persist it
      */
@@ -1047,123 +1508,6 @@ declare class FluxbaseAuth {
     private emitAuthChange;
 }
 
-/**
- * Realtime subscriptions using WebSockets
- */
-
-declare class RealtimeChannel {
-    private ws;
-    private url;
-    private token;
-    private channelName;
-    private callbacks;
-    private subscriptionConfig;
-    private reconnectAttempts;
-    private maxReconnectAttempts;
-    private reconnectDelay;
-    private heartbeatInterval;
-    constructor(url: string, channelName: string, token?: string | null);
-    /**
-     * Listen to postgres_changes with optional row-level filtering
-     *
-     * @param event - 'postgres_changes'
-     * @param config - Configuration including optional filter
-     * @param callback - Function to call when changes occur
-     * @returns This channel for chaining
-     *
-     * @example
-     * ```typescript
-     * channel.on('postgres_changes', {
-     *   event: '*',
-     *   schema: 'public',
-     *   table: 'jobs',
-     *   filter: 'created_by=eq.user123'
-     * }, (payload) => {
-     *   console.log('Job updated:', payload)
-     * })
-     * ```
-     */
-    on(event: 'postgres_changes', config: PostgresChangesConfig, callback: RealtimeCallback): this;
-    /**
-     * Listen to a specific event type (backwards compatibility)
-     *
-     * @param event - The event type (INSERT, UPDATE, DELETE, or '*' for all)
-     * @param callback - The callback function
-     * @returns This channel for chaining
-     *
-     * @example
-     * ```typescript
-     * channel.on('INSERT', (payload) => {
-     *   console.log('New record inserted:', payload.new_record)
-     * })
-     * ```
-     */
-    on(event: 'INSERT' | 'UPDATE' | 'DELETE' | '*', callback: RealtimeCallback): this;
-    /**
-     * Remove a callback
-     */
-    off(event: 'INSERT' | 'UPDATE' | 'DELETE' | '*', callback: RealtimeCallback): this;
-    /**
-     * Subscribe to the channel
-     */
-    subscribe(): this;
-    /**
-     * Unsubscribe from the channel
-     */
-    unsubscribe(): void;
-    /**
-     * Internal: Connect to WebSocket
-     */
-    private connect;
-    /**
-     * Internal: Disconnect WebSocket
-     */
-    private disconnect;
-    /**
-     * Internal: Send a message
-     */
-    private send;
-    /**
-     * Internal: Handle incoming message
-     */
-    private handleMessage;
-    /**
-     * Internal: Handle broadcast message
-     */
-    private handleBroadcast;
-    /**
-     * Internal: Start heartbeat interval
-     */
-    private startHeartbeat;
-    /**
-     * Internal: Stop heartbeat interval
-     */
-    private stopHeartbeat;
-    /**
-     * Internal: Attempt to reconnect
-     */
-    private attemptReconnect;
-}
-declare class FluxbaseRealtime {
-    private url;
-    private token;
-    private channels;
-    constructor(url: string, token?: string | null);
-    /**
-     * Create or get a channel
-     * @param channelName - Channel name (e.g., 'table:public.products')
-     */
-    channel(channelName: string): RealtimeChannel;
-    /**
-     * Remove all channels
-     */
-    removeAllChannels(): void;
-    /**
-     * Update auth token for all channels
-     */
-    setToken(token: string | null): void;
-}
-
 /**
  * Storage client for file operations
  */
@@ -1179,7 +1523,11 @@ declare class StorageBucket {
      * @param options - Upload options
      */
     upload(path: string, file: File | Blob | ArrayBuffer, options?: UploadOptions): Promise<{
-        data: StorageObject | null;
+        data: {
+            id: string;
+            path: string;
+            fullPath: string;
+        } | null;
         error: Error | null;
     }>;
     /**
@@ -1192,10 +1540,12 @@ declare class StorageBucket {
     }>;
     /**
      * List files in the bucket
-     * @param options - List options (prefix, limit, offset)
+     * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
+     * @param pathOrOptions - The folder path or list options
+     * @param maybeOptions - List options when first param is a path
      */
-    list(options?: ListOptions): Promise<{
-        data: StorageObject[] | null;
+    list(pathOrOptions?: string | ListOptions, maybeOptions?: ListOptions): Promise<{
+        data: FileObject[] | null;
         error: Error | null;
     }>;
     /**
@@ -1203,7 +1553,7 @@ declare class StorageBucket {
      * @param paths - Array of file paths to remove
      */
     remove(paths: string[]): Promise<{
-        data: null;
+        data: FileObject[] | null;
         error: Error | null;
     }>;
     /**
@@ -1232,7 +1582,9 @@ declare class StorageBucket {
      * @param toPath - New file path
      */
     move(fromPath: string, toPath: string): Promise<{
-        data: StorageObject | null;
+        data: {
+            message: string;
+        } | null;
         error: Error | null;
     }>;
     /**
@@ -1241,7 +1593,35 @@ declare class StorageBucket {
      * @param toPath - Destination file path
      */
     copy(fromPath: string, toPath: string): Promise<{
-        data: StorageObject | null;
+        data: {
+            path: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Share a file with another user (RLS)
+     * @param path - The file path
+     * @param options - Share options (userId and permission)
+     */
+    share(path: string, options: ShareFileOptions): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Revoke file access from a user (RLS)
+     * @param path - The file path
+     * @param userId - The user ID to revoke access from
+     */
+    revokeShare(path: string, userId: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * List users a file is shared with (RLS)
+     * @param path - The file path
+     */
+    listShares(path: string): Promise<{
+        data: FileShare[] | null;
         error: Error | null;
     }>;
 }
@@ -1267,24 +1647,220 @@ declare class FluxbaseStorage {
      * Create a new bucket
      * @param bucketName - The name of the bucket to create
      */
-    createBucket(bucketName: string): Promise<{
-        data: null;
+    createBucket(bucketName: string): Promise<{
+        data: {
+            name: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a bucket
+     * @param bucketName - The name of the bucket to delete
+     */
+    deleteBucket(bucketName: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Empty a bucket (delete all files)
+     * @param bucketName - The name of the bucket to empty
+     */
+    emptyBucket(bucketName: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update bucket settings (RLS - requires admin or service key)
+     * @param bucketName - The name of the bucket
+     * @param settings - Bucket settings to update
+     */
+    updateBucketSettings(bucketName: string, settings: BucketSettings): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Get bucket details
+     * @param bucketName - The name of the bucket
+     */
+    getBucket(bucketName: string): Promise<{
+        data: Bucket | null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * Edge Functions module for Fluxbase SDK
+ * Compatible with Supabase Functions API
+ *
+ * @example
+ * ```typescript
+ * // Invoke a function
+ * const { data, error } = await client.functions.invoke('hello-world', {
+ *   body: { name: 'Alice' }
+ * })
+ *
+ * // With custom headers
+ * const { data, error } = await client.functions.invoke('api-call', {
+ *   body: { query: 'data' },
+ *   headers: { 'X-Custom-Header': 'value' },
+ *   method: 'POST'
+ * })
+ * ```
+ */
+
+/**
+ * Edge Functions client for invoking and managing serverless functions
+ * API-compatible with Supabase Functions
+ *
+ * @category Functions
+ */
+declare class FluxbaseFunctions {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Invoke an edge function
+     *
+     * This method is fully compatible with Supabase's functions.invoke() API.
+     *
+     * @param functionName - The name of the function to invoke
+     * @param options - Invocation options including body, headers, and HTTP method
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * // Simple invocation
+     * const { data, error } = await client.functions.invoke('hello', {
+     *   body: { name: 'World' }
+     * })
+     *
+     * // With GET method
+     * const { data, error } = await client.functions.invoke('get-data', {
+     *   method: 'GET'
+     * })
+     *
+     * // With custom headers
+     * const { data, error } = await client.functions.invoke('api-proxy', {
+     *   body: { query: 'search' },
+     *   headers: { 'Authorization': 'Bearer token' },
+     *   method: 'POST'
+     * })
+     * ```
+     */
+    invoke<T = any>(functionName: string, options?: FunctionInvokeOptions): Promise<{
+        data: T | null;
+        error: Error | null;
+    }>;
+    /**
+     * Create a new edge function
+     *
+     * @param request - Function configuration and code
+     * @returns Promise resolving to { data, error } tuple with created function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.functions.create({
+     *   name: 'my-function',
+     *   code: 'export default async function handler(req) { return { hello: "world" } }',
+     *   enabled: true
+     * })
+     * ```
+     */
+    create(request: CreateFunctionRequest): Promise<{
+        data: EdgeFunction | null;
+        error: Error | null;
+    }>;
+    /**
+     * List all edge functions
+     *
+     * @returns Promise resolving to { data, error } tuple with array of functions
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.functions.list()
+     * if (data) {
+     *   console.log('Functions:', data.map(f => f.name))
+     * }
+     * ```
+     */
+    list(): Promise<{
+        data: EdgeFunction[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific edge function
+     *
+     * @param name - Function name
+     * @returns Promise resolving to { data, error } tuple with function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.functions.get('my-function')
+     * if (data) {
+     *   console.log('Function version:', data.version)
+     * }
+     * ```
+     */
+    get(name: string): Promise<{
+        data: EdgeFunction | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update an existing edge function
+     *
+     * @param name - Function name
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.functions.update('my-function', {
+     *   enabled: false,
+     *   description: 'Updated description'
+     * })
+     * ```
+     */
+    update(name: string, updates: UpdateFunctionRequest): Promise<{
+        data: EdgeFunction | null;
         error: Error | null;
     }>;
     /**
-     * Delete a bucket
-     * @param bucketName - The name of the bucket to delete
+     * Delete an edge function
+     *
+     * @param name - Function name
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.functions.delete('my-function')
+     * ```
      */
-    deleteBucket(bucketName: string): Promise<{
+    delete(name: string): Promise<{
         data: null;
         error: Error | null;
     }>;
     /**
-     * Empty a bucket (delete all files)
-     * @param bucketName - The name of the bucket to empty
+     * Get execution history for an edge function
+     *
+     * @param name - Function name
+     * @param limit - Maximum number of executions to return (optional)
+     * @returns Promise resolving to { data, error } tuple with execution records
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.functions.getExecutions('my-function', 10)
+     * if (data) {
+     *   data.forEach(exec => {
+     *     console.log(`${exec.executed_at}: ${exec.status} (${exec.duration_ms}ms)`)
+     *   })
+     * }
+     * ```
      */
-    emptyBucket(bucketName: string): Promise<{
-        data: null;
+    getExecutions(name: string, limit?: number): Promise<{
+        data: EdgeFunctionExecution[] | null;
         error: Error | null;
     }>;
 }
@@ -1517,7 +2093,7 @@ declare class AppSettingsManager {
      * await client.admin.settings.app.setFeature('storage', false)
      * ```
      */
-    setFeature(feature: 'realtime' | 'storage' | 'functions', enabled: boolean): Promise<AppSettings>;
+    setFeature(feature: "realtime" | "storage" | "functions", enabled: boolean): Promise<AppSettings>;
     /**
      * Enable or disable global rate limiting
      *
@@ -1532,11 +2108,410 @@ declare class AppSettingsManager {
      * ```
      */
     setRateLimiting(enabled: boolean): Promise<AppSettings>;
+    /**
+     * Configure SMTP email provider
+     *
+     * Convenience method to set up SMTP email delivery.
+     *
+     * @param config - SMTP configuration
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.configureSMTP({
+     *   host: 'smtp.gmail.com',
+     *   port: 587,
+     *   username: 'your-email@gmail.com',
+     *   password: 'your-app-password',
+     *   use_tls: true,
+     *   from_address: 'noreply@yourapp.com',
+     *   from_name: 'Your App'
+     * })
+     * ```
+     */
+    configureSMTP(config: {
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        use_tls: boolean;
+        from_address?: string;
+        from_name?: string;
+        reply_to_address?: string;
+    }): Promise<AppSettings>;
+    /**
+     * Configure SendGrid email provider
+     *
+     * Convenience method to set up SendGrid email delivery.
+     *
+     * @param apiKey - SendGrid API key
+     * @param options - Optional from address, name, and reply-to
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.configureSendGrid('SG.xxx', {
+     *   from_address: 'noreply@yourapp.com',
+     *   from_name: 'Your App'
+     * })
+     * ```
+     */
+    configureSendGrid(apiKey: string, options?: {
+        from_address?: string;
+        from_name?: string;
+        reply_to_address?: string;
+    }): Promise<AppSettings>;
+    /**
+     * Configure Mailgun email provider
+     *
+     * Convenience method to set up Mailgun email delivery.
+     *
+     * @param apiKey - Mailgun API key
+     * @param domain - Mailgun domain
+     * @param options - Optional EU region flag and email addresses
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.configureMailgun('key-xxx', 'mg.yourapp.com', {
+     *   eu_region: false,
+     *   from_address: 'noreply@yourapp.com',
+     *   from_name: 'Your App'
+     * })
+     * ```
+     */
+    configureMailgun(apiKey: string, domain: string, options?: {
+        eu_region?: boolean;
+        from_address?: string;
+        from_name?: string;
+        reply_to_address?: string;
+    }): Promise<AppSettings>;
+    /**
+     * Configure AWS SES email provider
+     *
+     * Convenience method to set up AWS SES email delivery.
+     *
+     * @param accessKeyId - AWS access key ID
+     * @param secretAccessKey - AWS secret access key
+     * @param region - AWS region (e.g., 'us-east-1')
+     * @param options - Optional email addresses
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.configureSES(
+     *   'AKIAIOSFODNN7EXAMPLE',
+     *   'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+     *   'us-east-1',
+     *   {
+     *     from_address: 'noreply@yourapp.com',
+     *     from_name: 'Your App'
+     *   }
+     * )
+     * ```
+     */
+    configureSES(accessKeyId: string, secretAccessKey: string, region: string, options?: {
+        from_address?: string;
+        from_name?: string;
+        reply_to_address?: string;
+    }): Promise<AppSettings>;
+    /**
+     * Enable or disable email functionality
+     *
+     * Convenience method to toggle email system on/off.
+     *
+     * @param enabled - Whether to enable email
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.setEmailEnabled(true)
+     * ```
+     */
+    setEmailEnabled(enabled: boolean): Promise<AppSettings>;
+    /**
+     * Configure password complexity requirements
+     *
+     * Convenience method to set password validation rules.
+     *
+     * @param requirements - Password complexity requirements
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.setPasswordComplexity({
+     *   min_length: 12,
+     *   require_uppercase: true,
+     *   require_lowercase: true,
+     *   require_number: true,
+     *   require_special: true
+     * })
+     * ```
+     */
+    setPasswordComplexity(requirements: {
+        min_length?: number;
+        require_uppercase?: boolean;
+        require_lowercase?: boolean;
+        require_number?: boolean;
+        require_special?: boolean;
+    }): Promise<AppSettings>;
+    /**
+     * Configure session settings
+     *
+     * Convenience method to set session timeout and limits.
+     *
+     * @param timeoutMinutes - Session timeout in minutes (0 for no timeout)
+     * @param maxSessionsPerUser - Maximum concurrent sessions per user (0 for unlimited)
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * // 30 minute sessions, max 3 devices per user
+     * await client.admin.settings.app.setSessionSettings(30, 3)
+     * ```
+     */
+    setSessionSettings(timeoutMinutes: number, maxSessionsPerUser: number): Promise<AppSettings>;
+    /**
+     * Enable or disable email verification requirement
+     *
+     * Convenience method to require email verification for new signups.
+     *
+     * @param required - Whether to require email verification
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.setEmailVerificationRequired(true)
+     * ```
+     */
+    setEmailVerificationRequired(required: boolean): Promise<AppSettings>;
+}
+/**
+ * Custom Settings Manager
+ *
+ * Manages custom admin-created settings with flexible key-value storage.
+ * Unlike system settings, custom settings allow admins to create arbitrary configuration entries
+ * with role-based editing permissions.
+ *
+ * @example
+ * ```typescript
+ * const custom = client.admin.settings.custom
+ *
+ * // Create a custom setting
+ * const setting = await custom.create({
+ *   key: 'feature.dark_mode',
+ *   value: { enabled: true, theme: 'dark' },
+ *   value_type: 'json',
+ *   description: 'Dark mode configuration',
+ *   editable_by: ['dashboard_admin', 'admin']
+ * })
+ *
+ * // List all custom settings
+ * const { settings } = await custom.list()
+ *
+ * // Get specific setting
+ * const darkMode = await custom.get('feature.dark_mode')
+ *
+ * // Update setting
+ * await custom.update('feature.dark_mode', {
+ *   value: { enabled: false, theme: 'light' }
+ * })
+ *
+ * // Delete setting
+ * await custom.delete('feature.dark_mode')
+ * ```
+ */
+declare class CustomSettingsManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Create a new custom setting
+     *
+     * @param request - Custom setting creation request
+     * @returns Promise resolving to CustomSetting
+     *
+     * @example
+     * ```typescript
+     * const setting = await client.admin.settings.custom.create({
+     *   key: 'api.quotas',
+     *   value: { free: 1000, pro: 10000, enterprise: 100000 },
+     *   value_type: 'json',
+     *   description: 'API request quotas by tier',
+     *   metadata: { category: 'billing' }
+     * })
+     * ```
+     */
+    create(request: CreateCustomSettingRequest): Promise<CustomSetting>;
+    /**
+     * List all custom settings
+     *
+     * @returns Promise resolving to ListCustomSettingsResponse
+     *
+     * @example
+     * ```typescript
+     * const response = await client.admin.settings.custom.list()
+     * console.log(response.settings)
+     * ```
+     */
+    list(): Promise<ListCustomSettingsResponse>;
+    /**
+     * Get a specific custom setting by key
+     *
+     * @param key - Setting key (e.g., 'feature.dark_mode')
+     * @returns Promise resolving to CustomSetting
+     *
+     * @example
+     * ```typescript
+     * const setting = await client.admin.settings.custom.get('feature.dark_mode')
+     * console.log(setting.value)
+     * ```
+     */
+    get(key: string): Promise<CustomSetting>;
+    /**
+     * Update an existing custom setting
+     *
+     * @param key - Setting key
+     * @param request - Update request with new values
+     * @returns Promise resolving to CustomSetting
+     *
+     * @example
+     * ```typescript
+     * const updated = await client.admin.settings.custom.update('feature.dark_mode', {
+     *   value: { enabled: false },
+     *   description: 'Updated description'
+     * })
+     * ```
+     */
+    update(key: string, request: UpdateCustomSettingRequest): Promise<CustomSetting>;
+    /**
+     * Delete a custom setting
+     *
+     * @param key - Setting key to delete
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.custom.delete('feature.dark_mode')
+     * ```
+     */
+    delete(key: string): Promise<void>;
+}
+/**
+ * Email Template Manager
+ *
+ * Manages email templates for authentication and user communication.
+ * Supports customizing templates for magic links, email verification, password resets, and user invitations.
+ *
+ * @example
+ * ```typescript
+ * const templates = client.admin.emailTemplates
+ *
+ * // List all templates
+ * const { templates: allTemplates } = await templates.list()
+ *
+ * // Get specific template
+ * const magicLink = await templates.get('magic_link')
+ *
+ * // Update template
+ * await templates.update('magic_link', {
+ *   subject: 'Sign in to ' + '{{.AppName}}',
+ *   html_body: '<html>Custom template with ' + '{{.MagicLink}}' + '</html>',
+ *   text_body: 'Click here: ' + '{{.MagicLink}}'
+ * })
+ *
+ * // Test template (sends to specified email)
+ * await templates.test('magic_link', 'test@example.com')
+ *
+ * // Reset to default
+ * await templates.reset('magic_link')
+ * ```
+ */
+declare class EmailTemplateManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * List all email templates
+     *
+     * @returns Promise resolving to ListEmailTemplatesResponse
+     *
+     * @example
+     * ```typescript
+     * const response = await client.admin.emailTemplates.list()
+     * console.log(response.templates)
+     * ```
+     */
+    list(): Promise<ListEmailTemplatesResponse>;
+    /**
+     * Get a specific email template by type
+     *
+     * @param type - Template type (magic_link | verify_email | reset_password | invite_user)
+     * @returns Promise resolving to EmailTemplate
+     *
+     * @example
+     * ```typescript
+     * const template = await client.admin.emailTemplates.get('magic_link')
+     * console.log(template.subject)
+     * console.log(template.html_body)
+     * ```
+     */
+    get(type: EmailTemplateType): Promise<EmailTemplate>;
+    /**
+     * Update an email template
+     *
+     * Available template variables:
+     * - magic_link: `{{.MagicLink}}`, `{{.AppName}}`, `{{.ExpiryMinutes}}`
+     * - verify_email: `{{.VerificationLink}}`, `{{.AppName}}`
+     * - reset_password: `{{.ResetLink}}`, `{{.AppName}}`, `{{.ExpiryMinutes}}`
+     * - invite_user: `{{.InviteLink}}`, `{{.AppName}}`, `{{.InviterName}}`
+     *
+     * @param type - Template type to update
+     * @param request - Update request with subject, html_body, and optional text_body
+     * @returns Promise resolving to EmailTemplate
+     *
+     * @example
+     * ```typescript
+     * const updated = await client.admin.emailTemplates.update('magic_link', {
+     *   subject: 'Your Magic Link - Sign in to ' + '{{.AppName}}',
+     *   html_body: '<html><body><h1>Welcome!</h1><a href="' + '{{.MagicLink}}' + '">Sign In</a></body></html>',
+     *   text_body: 'Click here to sign in: ' + '{{.MagicLink}}'
+     * })
+     * ```
+     */
+    update(type: EmailTemplateType, request: UpdateEmailTemplateRequest): Promise<EmailTemplate>;
+    /**
+     * Reset an email template to default
+     *
+     * Removes any customizations and restores the template to its original state.
+     *
+     * @param type - Template type to reset
+     * @returns Promise resolving to EmailTemplate - The default template
+     *
+     * @example
+     * ```typescript
+     * const defaultTemplate = await client.admin.emailTemplates.reset('magic_link')
+     * ```
+     */
+    reset(type: EmailTemplateType): Promise<EmailTemplate>;
+    /**
+     * Send a test email using the template
+     *
+     * Useful for previewing template changes before deploying to production.
+     *
+     * @param type - Template type to test
+     * @param recipientEmail - Email address to send test to
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await client.admin.emailTemplates.test('magic_link', 'test@example.com')
+     * ```
+     */
+    test(type: EmailTemplateType, recipientEmail: string): Promise<void>;
 }
 /**
  * Settings Manager
  *
- * Provides access to both system-level and application-level settings.
+ * Provides access to system-level, application-level, and custom settings.
  *
  * @example
  * ```typescript
@@ -1547,11 +2522,15 @@ declare class AppSettingsManager {
  *
  * // Access app settings
  * const appSettings = await settings.app.get()
+ *
+ * // Access custom settings
+ * const customSettings = await settings.custom.list()
  * ```
  */
 declare class FluxbaseSettings {
     system: SystemSettingsManager;
     app: AppSettingsManager;
+    custom: CustomSettingsManager;
     constructor(fetch: FluxbaseFetch);
 }
 
@@ -2672,6 +3651,10 @@ declare class FluxbaseAdmin {
      * Management namespace for API keys, webhooks, and invitations
      */
     management: FluxbaseManagement;
+    /**
+     * Email template manager for customizing authentication and notification emails
+     */
+    emailTemplates: EmailTemplateManager;
     constructor(fetch: FluxbaseFetch);
     /**
      * Set admin authentication token
@@ -2698,7 +3681,7 @@ declare class FluxbaseAdmin {
      * }
      * ```
      */
-    getSetupStatus(): Promise<AdminSetupStatusResponse>;
+    getSetupStatus(): Promise<DataResponse<AdminSetupStatusResponse>>;
     /**
      * Perform initial admin setup
      *
@@ -2722,7 +3705,7 @@ declare class FluxbaseAdmin {
      * localStorage.setItem('admin_token', response.access_token);
      * ```
      */
-    setup(request: AdminSetupRequest): Promise<AdminAuthResponse>;
+    setup(request: AdminSetupRequest): Promise<DataResponse<AdminAuthResponse>>;
     /**
      * Admin login
      *
@@ -2743,7 +3726,7 @@ declare class FluxbaseAdmin {
      * console.log('Logged in as:', response.user.email);
      * ```
      */
-    login(request: AdminLoginRequest): Promise<AdminAuthResponse>;
+    login(request: AdminLoginRequest): Promise<DataResponse<AdminAuthResponse>>;
     /**
      * Refresh admin access token
      *
@@ -2760,7 +3743,7 @@ declare class FluxbaseAdmin {
      * localStorage.setItem('admin_refresh_token', response.refresh_token);
      * ```
      */
-    refreshToken(request: AdminRefreshRequest): Promise<AdminRefreshResponse>;
+    refreshToken(request: AdminRefreshRequest): Promise<DataResponse<AdminRefreshResponse>>;
     /**
      * Admin logout
      *
@@ -2772,7 +3755,7 @@ declare class FluxbaseAdmin {
      * localStorage.removeItem('admin_token');
      * ```
      */
-    logout(): Promise<void>;
+    logout(): Promise<VoidResponse>;
     /**
      * Get current admin user information
      *
@@ -2785,7 +3768,7 @@ declare class FluxbaseAdmin {
      * console.log('Role:', user.role);
      * ```
      */
-    me(): Promise<AdminMeResponse>;
+    me(): Promise<DataResponse<AdminMeResponse>>;
     /**
      * List all users
      *
@@ -2806,7 +3789,7 @@ declare class FluxbaseAdmin {
      * });
      * ```
      */
-    listUsers(options?: ListUsersOptions): Promise<ListUsersResponse>;
+    listUsers(options?: ListUsersOptions): Promise<DataResponse<ListUsersResponse>>;
     /**
      * Get a user by ID
      *
@@ -2827,7 +3810,7 @@ declare class FluxbaseAdmin {
      * console.log('Last login:', dashboardUser.last_login_at);
      * ```
      */
-    getUserById(userId: string, type?: "app" | "dashboard"): Promise<EnrichedUser>;
+    getUserById(userId: string, type?: "app" | "dashboard"): Promise<DataResponse<EnrichedUser>>;
     /**
      * Invite a new user
      *
@@ -2849,7 +3832,7 @@ declare class FluxbaseAdmin {
      * console.log('Invitation link:', response.invitation_link);
      * ```
      */
-    inviteUser(request: InviteUserRequest, type?: "app" | "dashboard"): Promise<InviteUserResponse>;
+    inviteUser(request: InviteUserRequest, type?: "app" | "dashboard"): Promise<DataResponse<InviteUserResponse>>;
     /**
      * Delete a user
      *
@@ -2865,7 +3848,7 @@ declare class FluxbaseAdmin {
      * console.log('User deleted');
      * ```
      */
-    deleteUser(userId: string, type?: "app" | "dashboard"): Promise<DeleteUserResponse>;
+    deleteUser(userId: string, type?: "app" | "dashboard"): Promise<DataResponse<DeleteUserResponse>>;
     /**
      * Update user role
      *
@@ -2882,7 +3865,7 @@ declare class FluxbaseAdmin {
      * console.log('User role updated:', user.role);
      * ```
      */
-    updateUserRole(userId: string, role: string, type?: "app" | "dashboard"): Promise<EnrichedUser>;
+    updateUserRole(userId: string, role: string, type?: "app" | "dashboard"): Promise<DataResponse<EnrichedUser>>;
     /**
      * Reset user password
      *
@@ -2898,7 +3881,7 @@ declare class FluxbaseAdmin {
      * console.log(response.message);
      * ```
      */
-    resetUserPassword(userId: string, type?: "app" | "dashboard"): Promise<ResetUserPasswordResponse>;
+    resetUserPassword(userId: string, type?: "app" | "dashboard"): Promise<DataResponse<ResetUserPasswordResponse>>;
 }
 
 /**
@@ -3247,45 +4230,13 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
     private formatValue;
 }
 
-/**
- * Main Fluxbase client for interacting with the Fluxbase backend.
- *
- * This client provides access to all Fluxbase features including:
- * - Database operations via PostgREST-compatible API
- * - Authentication and user management
- * - Real-time subscriptions via WebSockets
- * - File storage and management
- * - PostgreSQL function calls (RPC)
- *
- * @example
- * ```typescript
- * import { createClient } from '@fluxbase/sdk'
- *
- * const client = createClient({
- *   url: 'http://localhost:8080',
- *   auth: {
- *     token: 'your-jwt-token',
- *     autoRefresh: true
- *   }
- * })
- *
- * // Query database
- * const { data } = await client.from('users').select('*').execute()
- *
- * // Subscribe to realtime changes
- * client.realtime.subscribe('users', (payload) => {
- *   console.log('Change:', payload)
- * })
- * ```
- *
- * @category Client
- */
-
 /**
  * Main Fluxbase client class
  * @category Client
  */
-declare class FluxbaseClient {
+declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof Database = any> {
+    protected fluxbaseUrl: string;
+    protected fluxbaseKey: string;
     /** Internal HTTP client for making requests */
     private fetch;
     /** Authentication module for user management */
@@ -3294,15 +4245,29 @@ declare class FluxbaseClient {
     realtime: FluxbaseRealtime;
     /** Storage module for file operations */
     storage: FluxbaseStorage;
+    /** Functions module for invoking and managing edge functions */
+    functions: FluxbaseFunctions;
     /** Admin module for instance management (requires admin authentication) */
     admin: FluxbaseAdmin;
     /** Management module for API keys, webhooks, and invitations */
     management: FluxbaseManagement;
     /**
      * Create a new Fluxbase client instance
-     * @param options - Client configuration options
+     *
+     * @param fluxbaseUrl - The URL of your Fluxbase instance
+     * @param fluxbaseKey - The anon key (JWT token with "anon" role). Generate using scripts/generate-keys.sh
+     * @param options - Additional client configuration options
+     *
+     * @example
+     * ```typescript
+     * const client = new FluxbaseClient(
+     *   'http://localhost:8080',
+     *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',  // Anon JWT token
+     *   { timeout: 30000 }
+     * )
+     * ```
      */
-    constructor(options: FluxbaseClientOptions);
+    constructor(fluxbaseUrl: string, fluxbaseKey: string, options?: FluxbaseClientOptions);
     /**
      * Create a query builder for a database table
      *
@@ -3376,6 +4341,34 @@ declare class FluxbaseClient {
      * @category Authentication
      */
     setAuthToken(token: string | null): void;
+    /**
+     * Create or get a realtime channel (Supabase-compatible alias)
+     *
+     * This is a convenience method that delegates to client.realtime.channel().
+     * Both patterns work identically:
+     * - client.channel('room-1') - Supabase-style
+     * - client.realtime.channel('room-1') - Fluxbase-style
+     *
+     * @param name - Channel name
+     * @returns RealtimeChannel instance
+     *
+     * @example
+     * ```typescript
+     * // Supabase-compatible usage
+     * const channel = client.channel('room-1')
+     *   .on('postgres_changes', {
+     *     event: '*',
+     *     schema: 'public',
+     *     table: 'messages'
+     *   }, (payload) => {
+     *     console.log('Change:', payload)
+     *   })
+     *   .subscribe()
+     * ```
+     *
+     * @category Realtime
+     */
+    channel(name: string): RealtimeChannel;
     /**
      * Get the internal HTTP client
      *
@@ -3394,31 +4387,41 @@ declare class FluxbaseClient {
     get http(): FluxbaseFetch;
 }
 /**
- * Create a new Fluxbase client instance
+ * Create a new Fluxbase client instance (Supabase-compatible)
  *
- * This is the recommended way to initialize the Fluxbase SDK.
+ * This function signature is identical to Supabase's createClient, making migration seamless.
  *
- * @param options - Client configuration options
- * @returns A configured Fluxbase client instance
+ * @param fluxbaseUrl - The URL of your Fluxbase instance
+ * @param fluxbaseKey - The anon key (JWT token with "anon" role). Generate using: `./scripts/generate-keys.sh` (option 3)
+ * @param options - Optional client configuration
+ * @returns A configured Fluxbase client instance with full TypeScript support
  *
  * @example
  * ```typescript
  * import { createClient } from '@fluxbase/sdk'
  *
- * const client = createClient({
- *   url: 'http://localhost:8080',
- *   auth: {
- *     token: 'your-jwt-token',
- *     autoRefresh: true,
- *     persist: true
- *   },
- *   timeout: 30000,
- *   debug: false
- * })
+ * // Initialize with anon key (identical to Supabase)
+ * const client = createClient(
+ *   'http://localhost:8080',
+ *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'  // Anon JWT token
+ * )
+ *
+ * // With additional options
+ * const client = createClient(
+ *   'http://localhost:8080',
+ *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+ *   { timeout: 30000, debug: true }
+ * )
+ *
+ * // With TypeScript database types
+ * const client = createClient<Database>(
+ *   'http://localhost:8080',
+ *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+ * )
  * ```
  *
  * @category Client
  */
-declare function createClient(options: FluxbaseClientOptions): FluxbaseClient;
+declare function createClient<Database = any, SchemaName extends string & keyof Database = any>(fluxbaseUrl: string, fluxbaseKey: string, options?: FluxbaseClientOptions): FluxbaseClient<Database, SchemaName>;
 
-export { type APIKey, APIKeysManager, type AcceptInvitationRequest, type AcceptInvitationResponse, type AdminAuthResponse, type AdminLoginRequest, type AdminMeResponse, type AdminRefreshRequest, type AdminRefreshResponse, type AdminSetupRequest, type AdminSetupStatusResponse, type AdminUser, type AppSettings, AppSettingsManager, type AuthResponse, type AuthSession, type AuthSettings, AuthSettingsManager, type AuthenticationSettings, type Column, type CreateAPIKeyRequest, type CreateAPIKeyResponse, type CreateColumnRequest, type CreateInvitationRequest, type CreateInvitationResponse, type CreateOAuthProviderRequest, type CreateOAuthProviderResponse, type CreateSchemaRequest, type CreateSchemaResponse, type CreateTableRequest, type CreateTableResponse, type CreateWebhookRequest, DDLManager, type DeleteAPIKeyResponse, type DeleteOAuthProviderResponse, type DeleteTableResponse, type DeleteUserResponse, type DeleteWebhookResponse, type EmailSettings, type EnrichedUser, type FeatureSettings, type FilterOperator, FluxbaseAdmin, FluxbaseAuth, FluxbaseClient, type FluxbaseClientOptions, type FluxbaseError, FluxbaseFetch, FluxbaseManagement, FluxbaseOAuth, FluxbaseRealtime, FluxbaseSettings, FluxbaseStorage, type GetImpersonationResponse, type HttpMethod, type ImpersonateAnonRequest, type ImpersonateServiceRequest, type ImpersonateUserRequest, ImpersonationManager, type ImpersonationSession, type ImpersonationTargetUser, type ImpersonationType, type Invitation, InvitationsManager, type InviteUserRequest, type InviteUserResponse, type ListAPIKeysResponse, type ListImpersonationSessionsOptions, type ListImpersonationSessionsResponse, type ListInvitationsOptions, type ListInvitationsResponse, type ListOAuthProvidersResponse, type ListOptions, type ListSchemasResponse, type ListSystemSettingsResponse, type ListTablesResponse, type ListUsersOptions, type ListUsersResponse, type ListWebhookDeliveriesResponse, type ListWebhooksResponse, type OAuthProvider, OAuthProviderManager, type OrderBy, type OrderDirection, type PostgrestError, type PostgrestResponse, QueryBuilder, type QueryFilter, type RealtimeCallback, type RealtimeChangePayload, RealtimeChannel, type RealtimeMessage, type RequestOptions, type ResetUserPasswordResponse, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type Schema, type SecuritySettings, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type StartImpersonationResponse, type StopImpersonationResponse, StorageBucket, type StorageObject, type SystemSetting, SystemSettingsManager, type Table, type TestWebhookResponse, type TwoFactorEnableResponse, type TwoFactorSetupResponse, type TwoFactorStatusResponse, type TwoFactorVerifyRequest, type UpdateAPIKeyRequest, type UpdateAppSettingsRequest, type UpdateAuthSettingsRequest, type UpdateAuthSettingsResponse, type UpdateOAuthProviderRequest, type UpdateOAuthProviderResponse, type UpdateSystemSettingRequest, type UpdateUserRoleRequest, type UpdateWebhookRequest, type UploadOptions, type User, type ValidateInvitationResponse, type Webhook, type WebhookDelivery, WebhooksManager, createClient };
+export { type APIKey, APIKeysManager, type AcceptInvitationRequest, type AcceptInvitationResponse, type AdminAuthResponse, type AdminLoginRequest, type AdminMeResponse, type AdminRefreshRequest, type AdminRefreshResponse, type AdminSetupRequest, type AdminSetupStatusResponse, type AdminUser, type AppSettings, AppSettingsManager, type AuthResponse, type AuthSession, type AuthSettings, AuthSettingsManager, type AuthenticationSettings, type Column, type CreateAPIKeyRequest, type CreateAPIKeyResponse, type CreateColumnRequest, type CreateFunctionRequest, type CreateInvitationRequest, type CreateInvitationResponse, type CreateOAuthProviderRequest, type CreateOAuthProviderResponse, type CreateSchemaRequest, type CreateSchemaResponse, type CreateTableRequest, type CreateTableResponse, type CreateWebhookRequest, DDLManager, type DataResponse, type DeleteAPIKeyResponse, type DeleteOAuthProviderResponse, type DeleteTableResponse, type DeleteUserResponse, type DeleteWebhookResponse, type EdgeFunction, type EdgeFunctionExecution, type EmailSettings, type EmailTemplate, EmailTemplateManager, type EmailTemplateType, type EnrichedUser, type FeatureSettings, type FileObject, type FilterOperator, FluxbaseAdmin, FluxbaseAuth, type FluxbaseAuthResponse, FluxbaseClient, type FluxbaseClientOptions, type FluxbaseError, FluxbaseFetch, FluxbaseFunctions, FluxbaseManagement, FluxbaseOAuth, FluxbaseRealtime, type FluxbaseResponse, FluxbaseSettings, FluxbaseStorage, type FunctionInvokeOptions, type GetImpersonationResponse, type HttpMethod, type ImpersonateAnonRequest, type ImpersonateServiceRequest, type ImpersonateUserRequest, ImpersonationManager, type ImpersonationSession, type ImpersonationTargetUser, type ImpersonationType, type Invitation, InvitationsManager, type InviteUserRequest, type InviteUserResponse, type ListAPIKeysResponse, type ListEmailTemplatesResponse, type ListImpersonationSessionsOptions, type ListImpersonationSessionsResponse, type ListInvitationsOptions, type ListInvitationsResponse, type ListOAuthProvidersResponse, type ListOptions, type ListSchemasResponse, type ListSystemSettingsResponse, type ListTablesResponse, type ListUsersOptions, type ListUsersResponse, type ListWebhookDeliveriesResponse, type ListWebhooksResponse, type MailgunSettings, type OAuthProvider, OAuthProviderManager, type OrderBy, type OrderDirection, type PostgresChangesConfig, type PostgrestError, type PostgrestResponse, QueryBuilder, type QueryFilter, type RealtimeCallback, type RealtimeChangePayload, RealtimeChannel, type RealtimeMessage, type RealtimePostgresChangesPayload, type RequestOptions, type ResetUserPasswordResponse, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type SESSettings, type SMTPSettings, type Schema, type SecuritySettings, type SendGridSettings, type SessionResponse, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type StartImpersonationResponse, type StopImpersonationResponse, StorageBucket, type StorageObject, type SupabaseAuthResponse, type SupabaseResponse, type SystemSetting, SystemSettingsManager, type Table, type TestEmailTemplateRequest, type TestWebhookResponse, type TwoFactorEnableResponse, type TwoFactorSetupResponse, type TwoFactorStatusResponse, type TwoFactorVerifyRequest, type UpdateAPIKeyRequest, type UpdateAppSettingsRequest, type UpdateAuthSettingsRequest, type UpdateAuthSettingsResponse, type UpdateEmailTemplateRequest, type UpdateFunctionRequest, type UpdateOAuthProviderRequest, type UpdateOAuthProviderResponse, type UpdateSystemSettingRequest, type UpdateUserRoleRequest, type UpdateWebhookRequest, type UploadOptions, type User, type UserResponse, type ValidateInvitationResponse, type VoidResponse, type Webhook, type WebhookDelivery, WebhooksManager, createClient };