@fluxbase/sdk 0.0.1-rc.2

package/dist/index.d.cts

@@ -0,0 +1,3424 @@
+/**
+ * Core types for the Fluxbase SDK
+ */
+interface FluxbaseClientOptions {
+    /**
+     * Base URL of your Fluxbase instance
+     * @example 'https://api.myapp.com'
+     * @example 'http://localhost:8080'
+     */
+    url: string;
+    /**
+     * Authentication options
+     */
+    auth?: {
+        /**
+         * Access token for authentication
+         */
+        token?: string;
+        /**
+         * Auto-refresh token when it expires
+         * @default true
+         */
+        autoRefresh?: boolean;
+        /**
+         * Persist auth state in localStorage
+         * @default true
+         */
+        persist?: boolean;
+    };
+    /**
+     * Global headers to include in all requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+}
+interface AuthSession {
+    user: User;
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    expires_at?: number;
+}
+interface User {
+    id: string;
+    email: string;
+    email_verified: boolean;
+    role: string;
+    metadata?: Record<string, unknown> | null;
+    created_at: string;
+    updated_at: string;
+}
+interface SignInCredentials {
+    email: string;
+    password: string;
+}
+interface SignUpCredentials {
+    email: string;
+    password: string;
+    metadata?: Record<string, unknown>;
+}
+interface AuthResponse {
+    user: User;
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+}
+interface TwoFactorSetupResponse {
+    secret: string;
+    qr_code_url: string;
+    message: string;
+}
+interface TwoFactorEnableResponse {
+    success: boolean;
+    backup_codes: string[];
+    message: string;
+}
+interface TwoFactorStatusResponse {
+    totp_enabled: boolean;
+}
+interface TwoFactorVerifyRequest {
+    user_id: string;
+    code: string;
+}
+interface SignInWith2FAResponse {
+    requires_2fa: boolean;
+    user_id: string;
+    message: string;
+}
+interface FluxbaseError extends Error {
+    status?: number;
+    code?: string;
+    details?: unknown;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD';
+interface RequestOptions {
+    method: HttpMethod;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+}
+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;
+}
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'ov' | 'sl' | 'sr' | 'nxr' | 'nxl' | 'fts' | 'plfts' | 'wfts';
+interface QueryFilter {
+    column: string;
+    operator: FilterOperator;
+    value: unknown;
+}
+type OrderDirection = 'asc' | 'desc';
+interface OrderBy {
+    column: string;
+    direction: OrderDirection;
+    nulls?: 'first' | 'last';
+}
+interface RealtimeMessage {
+    type: 'subscribe' | 'unsubscribe' | 'heartbeat' | 'broadcast' | 'ack' | 'error';
+    channel?: string;
+    event?: string;
+    schema?: string;
+    table?: string;
+    filter?: string;
+    payload?: unknown;
+    error?: string;
+    config?: PostgresChangesConfig;
+}
+interface PostgresChangesConfig {
+    event: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+    schema: string;
+    table: string;
+    filter?: string;
+}
+interface RealtimeChangePayload {
+    type: 'INSERT' | 'UPDATE' | 'DELETE';
+    schema: string;
+    table: string;
+    new_record?: Record<string, unknown>;
+    old_record?: Record<string, unknown>;
+    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>;
+}
+interface UploadOptions {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    cacheControl?: string;
+    upsert?: boolean;
+}
+interface ListOptions {
+    prefix?: string;
+    limit?: number;
+    offset?: number;
+}
+interface SignedUrlOptions {
+    expiresIn?: number;
+}
+interface PasswordResetResponse {
+    message: string;
+}
+interface VerifyResetTokenResponse {
+    valid: boolean;
+    message: string;
+}
+interface ResetPasswordResponse {
+    message: string;
+}
+interface MagicLinkOptions {
+    redirect_to?: string;
+}
+interface MagicLinkResponse {
+    message: string;
+}
+interface OAuthProvidersResponse {
+    providers: OAuthProvider[];
+}
+interface OAuthOptions {
+    redirect_to?: string;
+    scopes?: string[];
+}
+interface OAuthUrlResponse {
+    url: string;
+    provider: string;
+}
+interface AdminSetupStatusResponse {
+    needs_setup: boolean;
+    has_admin: boolean;
+}
+interface AdminSetupRequest {
+    email: string;
+    password: string;
+    name: string;
+}
+interface AdminUser {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+    email_verified: boolean;
+    created_at: string;
+    updated_at: string;
+    last_login_at?: string;
+}
+interface AdminAuthResponse {
+    user: AdminUser;
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+}
+interface AdminLoginRequest {
+    email: string;
+    password: string;
+}
+interface AdminRefreshRequest {
+    refresh_token: string;
+}
+interface AdminRefreshResponse {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    user: AdminUser;
+}
+interface AdminMeResponse {
+    user: {
+        id: string;
+        email: string;
+        role: string;
+    };
+}
+interface EnrichedUser {
+    id: string;
+    email: string;
+    role?: string;
+    created_at: string;
+    updated_at?: string;
+    email_verified?: boolean;
+    last_login_at?: string;
+    session_count?: number;
+    is_anonymous?: boolean;
+    metadata?: Record<string, any>;
+}
+interface ListUsersResponse {
+    users: EnrichedUser[];
+    total: number;
+}
+interface ListUsersOptions {
+    exclude_admins?: boolean;
+    search?: string;
+    limit?: number;
+    type?: 'app' | 'dashboard';
+}
+interface InviteUserRequest {
+    email: string;
+    role?: string;
+    send_email?: boolean;
+}
+interface InviteUserResponse {
+    user: EnrichedUser;
+    invitation_link?: string;
+    message: string;
+}
+interface UpdateUserRoleRequest {
+    role: string;
+}
+interface ResetUserPasswordResponse {
+    message: string;
+}
+interface DeleteUserResponse {
+    message: string;
+}
+interface APIKey {
+    id: string;
+    name: string;
+    description?: string;
+    key_prefix: string;
+    scopes: string[];
+    rate_limit_per_minute: number;
+    created_at: string;
+    updated_at?: string;
+    expires_at?: string;
+    revoked_at?: string;
+    last_used_at?: string;
+    user_id: string;
+}
+interface CreateAPIKeyRequest {
+    name: string;
+    description?: string;
+    scopes: string[];
+    rate_limit_per_minute: number;
+    expires_at?: string;
+}
+interface CreateAPIKeyResponse {
+    api_key: APIKey;
+    key: string;
+}
+interface ListAPIKeysResponse {
+    api_keys: APIKey[];
+    total: number;
+}
+interface UpdateAPIKeyRequest {
+    name?: string;
+    description?: string;
+    scopes?: string[];
+    rate_limit_per_minute?: number;
+}
+interface RevokeAPIKeyResponse {
+    message: string;
+}
+interface DeleteAPIKeyResponse {
+    message: string;
+}
+interface Webhook {
+    id: string;
+    url: string;
+    events: string[];
+    secret?: string;
+    description?: string;
+    is_active: boolean;
+    created_at: string;
+    updated_at?: string;
+    user_id: string;
+}
+interface CreateWebhookRequest {
+    url: string;
+    events: string[];
+    description?: string;
+    secret?: string;
+}
+interface UpdateWebhookRequest {
+    url?: string;
+    events?: string[];
+    description?: string;
+    is_active?: boolean;
+}
+interface ListWebhooksResponse {
+    webhooks: Webhook[];
+    total: number;
+}
+interface TestWebhookResponse {
+    success: boolean;
+    status_code?: number;
+    response_body?: string;
+    error?: string;
+}
+interface WebhookDelivery {
+    id: string;
+    webhook_id: string;
+    event: string;
+    payload: Record<string, any>;
+    status_code?: number;
+    response_body?: string;
+    error?: string;
+    created_at: string;
+    delivered_at?: string;
+}
+interface ListWebhookDeliveriesResponse {
+    deliveries: WebhookDelivery[];
+}
+interface DeleteWebhookResponse {
+    message: string;
+}
+interface Invitation {
+    id: string;
+    email: string;
+    role: string;
+    token?: string;
+    invited_by: string;
+    accepted_at?: string;
+    expires_at: string;
+    created_at: string;
+    revoked_at?: string;
+}
+interface CreateInvitationRequest {
+    email: string;
+    role: 'dashboard_admin' | 'dashboard_user';
+    expiry_duration?: number;
+}
+interface CreateInvitationResponse {
+    invitation: Invitation;
+    invite_link: string;
+    email_sent: boolean;
+    email_status?: string;
+}
+interface ValidateInvitationResponse {
+    valid: boolean;
+    invitation?: Invitation;
+    error?: string;
+}
+interface AcceptInvitationRequest {
+    password: string;
+    name: string;
+}
+interface AcceptInvitationResponse {
+    user: AdminUser;
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+}
+interface ListInvitationsOptions {
+    include_accepted?: boolean;
+    include_expired?: boolean;
+}
+interface ListInvitationsResponse {
+    invitations: Invitation[];
+}
+interface RevokeInvitationResponse {
+    message: string;
+}
+/**
+ * System setting with key-value storage
+ */
+interface SystemSetting {
+    id: string;
+    key: string;
+    value: Record<string, unknown>;
+    description?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to update a system setting
+ */
+interface UpdateSystemSettingRequest {
+    value: Record<string, unknown>;
+    description?: string;
+}
+/**
+ * Response containing all system settings
+ */
+interface ListSystemSettingsResponse {
+    settings: SystemSetting[];
+}
+/**
+ * Authentication settings for the application
+ */
+interface AuthenticationSettings {
+    enable_signup: boolean;
+    enable_magic_link: boolean;
+    password_min_length: number;
+    require_email_verification: boolean;
+}
+/**
+ * Feature flags for the application
+ */
+interface FeatureSettings {
+    enable_realtime: boolean;
+    enable_storage: boolean;
+    enable_functions: boolean;
+}
+/**
+ * Email configuration settings
+ */
+interface EmailSettings {
+    enabled: boolean;
+    provider: string;
+}
+/**
+ * Security settings for the application
+ */
+interface SecuritySettings {
+    enable_global_rate_limit: boolean;
+}
+/**
+ * Complete application settings structure
+ */
+interface AppSettings {
+    authentication: AuthenticationSettings;
+    features: FeatureSettings;
+    email: EmailSettings;
+    security: SecuritySettings;
+}
+/**
+ * Request to update application settings
+ * All fields are optional for partial updates
+ */
+interface UpdateAppSettingsRequest {
+    authentication?: Partial<AuthenticationSettings>;
+    features?: Partial<FeatureSettings>;
+    email?: Partial<EmailSettings>;
+    security?: Partial<SecuritySettings>;
+}
+interface OAuthProvider {
+    id: string;
+    name: string;
+    enabled: boolean;
+    authorize_url?: string;
+}
+/**
+ * OAuth provider configuration
+ */
+interface OAuthProvider {
+    id: string;
+    provider_name: string;
+    display_name: string;
+    enabled: boolean;
+    client_id: string;
+    client_secret?: string;
+    redirect_url: string;
+    scopes: string[];
+    is_custom: boolean;
+    authorization_url?: string;
+    token_url?: string;
+    user_info_url?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to create a new OAuth provider
+ */
+interface CreateOAuthProviderRequest {
+    provider_name: string;
+    display_name: string;
+    enabled: boolean;
+    client_id: string;
+    client_secret: string;
+    redirect_url: string;
+    scopes: string[];
+    is_custom: boolean;
+    authorization_url?: string;
+    token_url?: string;
+    user_info_url?: string;
+}
+/**
+ * Response after creating an OAuth provider
+ */
+interface CreateOAuthProviderResponse {
+    success: boolean;
+    id: string;
+    provider: string;
+    message: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to update an OAuth provider
+ */
+interface UpdateOAuthProviderRequest {
+    display_name?: string;
+    enabled?: boolean;
+    client_id?: string;
+    client_secret?: string;
+    redirect_url?: string;
+    scopes?: string[];
+    authorization_url?: string;
+    token_url?: string;
+    user_info_url?: string;
+}
+/**
+ * Response after updating an OAuth provider
+ */
+interface UpdateOAuthProviderResponse {
+    success: boolean;
+    message: string;
+}
+/**
+ * Response after deleting an OAuth provider
+ */
+interface DeleteOAuthProviderResponse {
+    success: boolean;
+    message: string;
+}
+/**
+ * Response for listing OAuth providers
+ */
+interface ListOAuthProvidersResponse {
+    providers: OAuthProvider[];
+}
+/**
+ * Authentication settings configuration
+ */
+interface AuthSettings {
+    enable_signup: boolean;
+    require_email_verification: boolean;
+    enable_magic_link: boolean;
+    password_min_length: number;
+    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;
+}
+/**
+ * Request to update authentication settings
+ */
+interface UpdateAuthSettingsRequest {
+    enable_signup?: boolean;
+    require_email_verification?: boolean;
+    enable_magic_link?: boolean;
+    password_min_length?: number;
+    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;
+}
+/**
+ * Response after updating authentication settings
+ */
+interface UpdateAuthSettingsResponse {
+    success: boolean;
+    message: string;
+}
+/**
+ * Column definition for creating a table
+ */
+interface CreateColumnRequest {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    defaultValue?: string;
+}
+/**
+ * Request to create a new database schema
+ */
+interface CreateSchemaRequest {
+    name: string;
+}
+/**
+ * Response after creating a schema
+ */
+interface CreateSchemaResponse {
+    message: string;
+    schema: string;
+}
+/**
+ * Request to create a new table
+ */
+interface CreateTableRequest {
+    schema: string;
+    name: string;
+    columns: CreateColumnRequest[];
+}
+/**
+ * Response after creating a table
+ */
+interface CreateTableResponse {
+    message: string;
+    schema: string;
+    table: string;
+}
+/**
+ * Response after deleting a table
+ */
+interface DeleteTableResponse {
+    message: string;
+}
+/**
+ * Database schema information
+ */
+interface Schema {
+    name: string;
+    owner?: string;
+}
+/**
+ * Response for listing schemas
+ */
+interface ListSchemasResponse {
+    schemas: Schema[];
+}
+/**
+ * Table column information
+ */
+interface Column {
+    name: string;
+    type: string;
+    nullable: boolean;
+    default_value?: string;
+    is_primary_key?: boolean;
+}
+/**
+ * Database table information
+ */
+interface Table {
+    schema: string;
+    name: string;
+    columns?: Column[];
+}
+/**
+ * Response for listing tables
+ */
+interface ListTablesResponse {
+    tables: Table[];
+}
+/**
+ * Impersonation type
+ */
+type ImpersonationType = 'user' | 'anon' | 'service';
+/**
+ * Target user information for impersonation
+ */
+interface ImpersonationTargetUser {
+    id: string;
+    email: string;
+    role: string;
+}
+/**
+ * Impersonation session information
+ */
+interface ImpersonationSession {
+    id: string;
+    admin_user_id: string;
+    target_user_id: string | null;
+    impersonation_type: ImpersonationType;
+    target_role: string;
+    reason: string;
+    started_at: string;
+    ended_at: string | null;
+    is_active: boolean;
+    ip_address: string | null;
+    user_agent: string | null;
+}
+/**
+ * Request to start impersonating a specific user
+ */
+interface ImpersonateUserRequest {
+    target_user_id: string;
+    reason: string;
+}
+/**
+ * Request to start impersonating as anonymous user
+ */
+interface ImpersonateAnonRequest {
+    reason: string;
+}
+/**
+ * Request to start impersonating with service role
+ */
+interface ImpersonateServiceRequest {
+    reason: string;
+}
+/**
+ * Response after starting impersonation
+ */
+interface StartImpersonationResponse {
+    session: ImpersonationSession;
+    target_user: ImpersonationTargetUser | null;
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+}
+/**
+ * Response after stopping impersonation
+ */
+interface StopImpersonationResponse {
+    success: boolean;
+    message: string;
+}
+/**
+ * Response for getting current impersonation session
+ */
+interface GetImpersonationResponse {
+    session: ImpersonationSession | null;
+    target_user: ImpersonationTargetUser | null;
+}
+/**
+ * Options for listing impersonation sessions
+ */
+interface ListImpersonationSessionsOptions {
+    limit?: number;
+    offset?: number;
+    admin_user_id?: string;
+    target_user_id?: string;
+    impersonation_type?: ImpersonationType;
+    is_active?: boolean;
+}
+/**
+ * Response for listing impersonation sessions
+ */
+interface ListImpersonationSessionsResponse {
+    sessions: ImpersonationSession[];
+    total: number;
+}
+/**
+ * Auth state change events
+ */
+type AuthChangeEvent = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED' | 'PASSWORD_RECOVERY' | 'MFA_CHALLENGE_VERIFIED';
+/**
+ * Callback for auth state changes
+ */
+type AuthStateChangeCallback = (event: AuthChangeEvent, session: AuthSession | null) => void;
+/**
+ * Subscription object returned by onAuthStateChange
+ */
+interface AuthSubscription {
+    /**
+     * Unsubscribe from auth state changes
+     */
+    unsubscribe: () => 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
+     * @returns Subscription object with unsubscribe method
+     *
+     * @example
+     * ```typescript
+     * const { data: { subscription } } = client.auth.onAuthStateChange((event, session) => {
+     *   console.log('Auth event:', event, session)
+     * })
+     *
+     * // Later, to unsubscribe:
+     * subscription.unsubscribe()
+     * ```
+     */
+    onAuthStateChange(callback: AuthStateChangeCallback): AuthSubscription;
+    /**
+     * Sign in with email and password
+     * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
+     */
+    signIn(credentials: SignInCredentials): Promise<AuthSession | SignInWith2FAResponse>;
+    /**
+     * Sign up with email and password
+     */
+    signUp(credentials: SignUpCredentials): Promise<AuthSession>;
+    /**
+     * Sign out the current user
+     */
+    signOut(): Promise<void>;
+    /**
+     * Refresh the access token
+     */
+    refreshToken(): Promise<AuthSession>;
+    /**
+     * Get the current user from the server
+     */
+    getCurrentUser(): Promise<User>;
+    /**
+     * Update the current user
+     */
+    updateUser(data: Partial<Pick<User, 'email' | 'metadata'>>): Promise<User>;
+    /**
+     * Set the auth token manually
+     */
+    setToken(token: string): void;
+    /**
+     * Setup 2FA for the current user
+     * Returns TOTP secret and QR code URL
+     */
+    setup2FA(): Promise<TwoFactorSetupResponse>;
+    /**
+     * Enable 2FA after verifying the TOTP code
+     * Returns backup codes that should be saved by the user
+     */
+    enable2FA(code: string): Promise<TwoFactorEnableResponse>;
+    /**
+     * Disable 2FA for the current user
+     * Requires password confirmation
+     */
+    disable2FA(password: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Check 2FA status for the current user
+     */
+    get2FAStatus(): Promise<TwoFactorStatusResponse>;
+    /**
+     * Verify 2FA code during login
+     * Call this after signIn returns requires_2fa: true
+     */
+    verify2FA(request: TwoFactorVerifyRequest): Promise<AuthSession>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Verify magic link token and sign in
+     * @param token - Magic link token from email
+     */
+    verifyMagicLink(token: string): Promise<AuthSession>;
+    /**
+     * Sign in anonymously
+     * Creates a temporary anonymous user session
+     */
+    signInAnonymously(): Promise<AuthSession>;
+    /**
+     * Get list of enabled OAuth providers
+     */
+    getOAuthProviders(): Promise<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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Internal: Set the session and persist it
+     */
+    private setSession;
+    /**
+     * Internal: Clear the session
+     */
+    private clearSession;
+    /**
+     * Internal: Save session to storage
+     */
+    private saveSession;
+    /**
+     * Internal: Schedule automatic token refresh
+     */
+    private scheduleTokenRefresh;
+    /**
+     * Internal: Emit auth state change event to all listeners
+     */
+    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
+ */
+
+declare class StorageBucket {
+    private fetch;
+    private bucketName;
+    constructor(fetch: FluxbaseFetch, bucketName: string);
+    /**
+     * Upload a file to the bucket
+     * @param path - The path/key for the file
+     * @param file - The file to upload (File, Blob, or ArrayBuffer)
+     * @param options - Upload options
+     */
+    upload(path: string, file: File | Blob | ArrayBuffer, options?: UploadOptions): Promise<{
+        data: StorageObject | null;
+        error: Error | null;
+    }>;
+    /**
+     * Download a file from the bucket
+     * @param path - The path/key of the file
+     */
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: Error | null;
+    }>;
+    /**
+     * List files in the bucket
+     * @param options - List options (prefix, limit, offset)
+     */
+    list(options?: ListOptions): Promise<{
+        data: StorageObject[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Remove files from the bucket
+     * @param paths - Array of file paths to remove
+     */
+    remove(paths: string[]): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Get a public URL for a file
+     * @param path - The file path
+     */
+    getPublicUrl(path: string): {
+        data: {
+            publicUrl: string;
+        };
+    };
+    /**
+     * Create a signed URL for temporary access to a file
+     * @param path - The file path
+     * @param options - Signed URL options
+     */
+    createSignedUrl(path: string, options?: SignedUrlOptions): Promise<{
+        data: {
+            signedUrl: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Move a file to a new location
+     * @param fromPath - Current file path
+     * @param toPath - New file path
+     */
+    move(fromPath: string, toPath: string): Promise<{
+        data: StorageObject | null;
+        error: Error | null;
+    }>;
+    /**
+     * Copy a file to a new location
+     * @param fromPath - Source file path
+     * @param toPath - Destination file path
+     */
+    copy(fromPath: string, toPath: string): Promise<{
+        data: StorageObject | null;
+        error: Error | null;
+    }>;
+}
+declare class FluxbaseStorage {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Get a reference to a storage bucket
+     * @param bucketName - The name of the bucket
+     */
+    from(bucketName: string): StorageBucket;
+    /**
+     * List all buckets
+     */
+    listBuckets(): Promise<{
+        data: Array<{
+            name: string;
+            created_at: string;
+        }> | null;
+        error: Error | null;
+    }>;
+    /**
+     * Create a new bucket
+     * @param bucketName - The name of the bucket to create
+     */
+    createBucket(bucketName: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a bucket
+     * @param bucketName - The name of the bucket to delete
+     */
+    deleteBucket(bucketName: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Empty a bucket (delete all files)
+     * @param bucketName - The name of the bucket to empty
+     */
+    emptyBucket(bucketName: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * System Settings Manager
+ *
+ * Manages low-level system settings with key-value storage.
+ * For application-level settings, use AppSettingsManager instead.
+ *
+ * @example
+ * ```typescript
+ * const settings = client.admin.settings.system
+ *
+ * // List all system settings
+ * const { settings } = await settings.list()
+ *
+ * // Get specific setting
+ * const setting = await settings.get('app.auth.enable_signup')
+ *
+ * // Update setting
+ * await settings.update('app.auth.enable_signup', {
+ *   value: { value: true },
+ *   description: 'Enable user signup'
+ * })
+ *
+ * // Delete setting
+ * await settings.delete('app.auth.enable_signup')
+ * ```
+ */
+declare class SystemSettingsManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * List all system settings
+     *
+     * @returns Promise resolving to ListSystemSettingsResponse
+     *
+     * @example
+     * ```typescript
+     * const response = await client.admin.settings.system.list()
+     * console.log(response.settings)
+     * ```
+     */
+    list(): Promise<ListSystemSettingsResponse>;
+    /**
+     * Get a specific system setting by key
+     *
+     * @param key - Setting key (e.g., 'app.auth.enable_signup')
+     * @returns Promise resolving to SystemSetting
+     *
+     * @example
+     * ```typescript
+     * const setting = await client.admin.settings.system.get('app.auth.enable_signup')
+     * console.log(setting.value)
+     * ```
+     */
+    get(key: string): Promise<SystemSetting>;
+    /**
+     * Update or create a system setting
+     *
+     * @param key - Setting key
+     * @param request - Update request with value and optional description
+     * @returns Promise resolving to SystemSetting
+     *
+     * @example
+     * ```typescript
+     * const updated = await client.admin.settings.system.update('app.auth.enable_signup', {
+     *   value: { value: true },
+     *   description: 'Enable user signup'
+     * })
+     * ```
+     */
+    update(key: string, request: UpdateSystemSettingRequest): Promise<SystemSetting>;
+    /**
+     * Delete a system setting
+     *
+     * @param key - Setting key to delete
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.system.delete('app.auth.enable_signup')
+     * ```
+     */
+    delete(key: string): Promise<void>;
+}
+/**
+ * Application Settings Manager
+ *
+ * Manages high-level application settings with a structured API.
+ * Provides type-safe access to authentication, features, email, and security settings.
+ *
+ * @example
+ * ```typescript
+ * const settings = client.admin.settings.app
+ *
+ * // Get all app settings
+ * const appSettings = await settings.get()
+ * console.log(appSettings.authentication.enable_signup)
+ *
+ * // Update specific settings
+ * const updated = await settings.update({
+ *   authentication: {
+ *     enable_signup: true,
+ *     password_min_length: 12
+ *   }
+ * })
+ *
+ * // Reset to defaults
+ * await settings.reset()
+ * ```
+ */
+declare class AppSettingsManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Get all application settings
+     *
+     * Returns structured settings for authentication, features, email, and security.
+     *
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * const settings = await client.admin.settings.app.get()
+     *
+     * console.log('Signup enabled:', settings.authentication.enable_signup)
+     * console.log('Realtime enabled:', settings.features.enable_realtime)
+     * console.log('Email provider:', settings.email.provider)
+     * ```
+     */
+    get(): Promise<AppSettings>;
+    /**
+     * Update application settings
+     *
+     * Supports partial updates - only provide the fields you want to change.
+     *
+     * @param request - Settings to update (partial update supported)
+     * @returns Promise resolving to AppSettings - Updated settings
+     *
+     * @example
+     * ```typescript
+     * // Update authentication settings
+     * const updated = await client.admin.settings.app.update({
+     *   authentication: {
+     *     enable_signup: true,
+     *     password_min_length: 12
+     *   }
+     * })
+     *
+     * // Update multiple categories
+     * await client.admin.settings.app.update({
+     *   authentication: { enable_signup: false },
+     *   features: { enable_realtime: true },
+     *   security: { enable_global_rate_limit: true }
+     * })
+     * ```
+     */
+    update(request: UpdateAppSettingsRequest): Promise<AppSettings>;
+    /**
+     * Reset all application settings to defaults
+     *
+     * This will delete all custom settings and return to default values.
+     *
+     * @returns Promise resolving to AppSettings - Default settings
+     *
+     * @example
+     * ```typescript
+     * const defaults = await client.admin.settings.app.reset()
+     * console.log('Settings reset to defaults:', defaults)
+     * ```
+     */
+    reset(): Promise<AppSettings>;
+    /**
+     * Enable user signup
+     *
+     * Convenience method to enable user registration.
+     *
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.enableSignup()
+     * ```
+     */
+    enableSignup(): Promise<AppSettings>;
+    /**
+     * Disable user signup
+     *
+     * Convenience method to disable user registration.
+     *
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.disableSignup()
+     * ```
+     */
+    disableSignup(): Promise<AppSettings>;
+    /**
+     * Update password minimum length
+     *
+     * Convenience method to set password requirements.
+     *
+     * @param length - Minimum password length (8-128 characters)
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.setPasswordMinLength(12)
+     * ```
+     */
+    setPasswordMinLength(length: number): Promise<AppSettings>;
+    /**
+     * Enable or disable a feature
+     *
+     * Convenience method to toggle feature flags.
+     *
+     * @param feature - Feature name ('realtime' | 'storage' | 'functions')
+     * @param enabled - Whether to enable or disable the feature
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * // Enable realtime
+     * await client.admin.settings.app.setFeature('realtime', true)
+     *
+     * // Disable storage
+     * await client.admin.settings.app.setFeature('storage', false)
+     * ```
+     */
+    setFeature(feature: 'realtime' | 'storage' | 'functions', enabled: boolean): Promise<AppSettings>;
+    /**
+     * Enable or disable global rate limiting
+     *
+     * Convenience method to toggle global rate limiting.
+     *
+     * @param enabled - Whether to enable rate limiting
+     * @returns Promise resolving to AppSettings
+     *
+     * @example
+     * ```typescript
+     * await client.admin.settings.app.setRateLimiting(true)
+     * ```
+     */
+    setRateLimiting(enabled: boolean): Promise<AppSettings>;
+}
+/**
+ * Settings Manager
+ *
+ * Provides access to both system-level and application-level settings.
+ *
+ * @example
+ * ```typescript
+ * const settings = client.admin.settings
+ *
+ * // Access system settings
+ * const systemSettings = await settings.system.list()
+ *
+ * // Access app settings
+ * const appSettings = await settings.app.get()
+ * ```
+ */
+declare class FluxbaseSettings {
+    system: SystemSettingsManager;
+    app: AppSettingsManager;
+    constructor(fetch: FluxbaseFetch);
+}
+
+/**
+ * DDL (Data Definition Language) Manager
+ *
+ * Provides methods for managing database schemas and tables programmatically.
+ * This includes creating schemas, creating tables with custom columns, listing
+ * schemas and tables, and deleting tables.
+ *
+ * @example
+ * ```typescript
+ * const ddl = client.admin.ddl
+ *
+ * // Create a new schema
+ * await ddl.createSchema('analytics')
+ *
+ * // Create a table with columns
+ * await ddl.createTable('analytics', 'events', [
+ *   { name: 'id', type: 'UUID', primaryKey: true, defaultValue: 'gen_random_uuid()' },
+ *   { name: 'user_id', type: 'UUID', nullable: false },
+ *   { name: 'event_name', type: 'TEXT', nullable: false },
+ *   { name: 'event_data', type: 'JSONB' },
+ *   { name: 'created_at', type: 'TIMESTAMPTZ', defaultValue: 'NOW()' }
+ * ])
+ *
+ * // List all schemas
+ * const { schemas } = await ddl.listSchemas()
+ *
+ * // List all tables in a schema
+ * const { tables } = await ddl.listTables('analytics')
+ *
+ * // Delete a table
+ * await ddl.deleteTable('analytics', 'events')
+ * ```
+ */
+declare class DDLManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Create a new database schema
+     *
+     * Creates a new schema in the database. Schemas are used to organize tables
+     * into logical groups and provide namespace isolation.
+     *
+     * @param name - Schema name (must be valid PostgreSQL identifier)
+     * @returns Promise resolving to CreateSchemaResponse
+     *
+     * @example
+     * ```typescript
+     * // Create a schema for analytics data
+     * const result = await client.admin.ddl.createSchema('analytics')
+     * console.log(result.message) // "Schema created successfully"
+     * console.log(result.schema)  // "analytics"
+     * ```
+     */
+    createSchema(name: string): Promise<CreateSchemaResponse>;
+    /**
+     * List all database schemas
+     *
+     * Retrieves a list of all schemas in the database. This includes both
+     * system schemas (like 'public', 'pg_catalog') and user-created schemas.
+     *
+     * @returns Promise resolving to ListSchemasResponse
+     *
+     * @example
+     * ```typescript
+     * const { schemas } = await client.admin.ddl.listSchemas()
+     *
+     * schemas.forEach(schema => {
+     *   console.log(`Schema: ${schema.name}, Owner: ${schema.owner}`)
+     * })
+     * ```
+     */
+    listSchemas(): Promise<ListSchemasResponse>;
+    /**
+     * Create a new table in a schema
+     *
+     * Creates a new table with the specified columns. Supports various column
+     * options including primary keys, nullability, data types, and default values.
+     *
+     * @param schema - Schema name where the table will be created
+     * @param name - Table name (must be valid PostgreSQL identifier)
+     * @param columns - Array of column definitions
+     * @returns Promise resolving to CreateTableResponse
+     *
+     * @example
+     * ```typescript
+     * // Create a users table
+     * await client.admin.ddl.createTable('public', 'users', [
+     *   {
+     *     name: 'id',
+     *     type: 'UUID',
+     *     primaryKey: true,
+     *     defaultValue: 'gen_random_uuid()'
+     *   },
+     *   {
+     *     name: 'email',
+     *     type: 'TEXT',
+     *     nullable: false
+     *   },
+     *   {
+     *     name: 'name',
+     *     type: 'TEXT'
+     *   },
+     *   {
+     *     name: 'created_at',
+     *     type: 'TIMESTAMPTZ',
+     *     nullable: false,
+     *     defaultValue: 'NOW()'
+     *   }
+     * ])
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Create a products table with JSONB metadata
+     * await client.admin.ddl.createTable('public', 'products', [
+     *   { name: 'id', type: 'SERIAL', primaryKey: true },
+     *   { name: 'name', type: 'TEXT', nullable: false },
+     *   { name: 'price', type: 'DECIMAL(10,2)', nullable: false },
+     *   { name: 'metadata', type: 'JSONB' },
+     *   { name: 'in_stock', type: 'BOOLEAN', defaultValue: 'true' }
+     * ])
+     * ```
+     */
+    createTable(schema: string, name: string, columns: CreateColumnRequest[]): Promise<CreateTableResponse>;
+    /**
+     * List all tables in the database or a specific schema
+     *
+     * Retrieves a list of all tables. If a schema is specified, only tables
+     * from that schema are returned. Otherwise, all tables from all schemas
+     * are returned.
+     *
+     * @param schema - Optional schema name to filter tables
+     * @returns Promise resolving to ListTablesResponse
+     *
+     * @example
+     * ```typescript
+     * // List all tables in the public schema
+     * const { tables } = await client.admin.ddl.listTables('public')
+     *
+     * tables.forEach(table => {
+     *   console.log(`Table: ${table.schema}.${table.name}`)
+     *   table.columns?.forEach(col => {
+     *     console.log(`  - ${col.name}: ${col.type}`)
+     *   })
+     * })
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // List all tables across all schemas
+     * const { tables } = await client.admin.ddl.listTables()
+     *
+     * const tablesBySchema = tables.reduce((acc, table) => {
+     *   if (!acc[table.schema]) acc[table.schema] = []
+     *   acc[table.schema].push(table.name)
+     *   return acc
+     * }, {} as Record<string, string[]>)
+     *
+     * console.log(tablesBySchema)
+     * ```
+     */
+    listTables(schema?: string): Promise<ListTablesResponse>;
+    /**
+     * Delete a table from a schema
+     *
+     * Permanently deletes a table and all its data. This operation cannot be undone.
+     *
+     * @param schema - Schema name containing the table
+     * @param name - Table name to delete
+     * @returns Promise resolving to DeleteTableResponse
+     *
+     * @example
+     * ```typescript
+     * // Delete a table
+     * const result = await client.admin.ddl.deleteTable('public', 'old_data')
+     * console.log(result.message) // "Table deleted successfully"
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Safe deletion with confirmation
+     * const confirm = await askUser('Are you sure you want to delete this table?')
+     * if (confirm) {
+     *   await client.admin.ddl.deleteTable('analytics', 'events')
+     *   console.log('Table deleted')
+     * }
+     * ```
+     */
+    deleteTable(schema: string, name: string): Promise<DeleteTableResponse>;
+}
+
+/**
+ * OAuth Provider Manager
+ *
+ * Manages OAuth provider configurations for third-party authentication.
+ * Supports both built-in providers (Google, GitHub, etc.) and custom OAuth2 providers.
+ *
+ * @example
+ * ```typescript
+ * const oauth = client.admin.oauth
+ *
+ * // List all OAuth providers
+ * const { providers } = await oauth.listProviders()
+ *
+ * // Create a new provider
+ * await oauth.createProvider({
+ *   provider_name: 'github',
+ *   display_name: 'GitHub',
+ *   enabled: true,
+ *   client_id: 'your-client-id',
+ *   client_secret: 'your-client-secret',
+ *   redirect_url: 'https://yourapp.com/auth/callback',
+ *   scopes: ['user:email', 'read:user'],
+ *   is_custom: false
+ * })
+ *
+ * // Update a provider
+ * await oauth.updateProvider('provider-id', {
+ *   enabled: false
+ * })
+ *
+ * // Delete a provider
+ * await oauth.deleteProvider('provider-id')
+ * ```
+ */
+declare class OAuthProviderManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * List all OAuth providers
+     *
+     * Retrieves all configured OAuth providers including both enabled and disabled providers.
+     * Note: Client secrets are not included in the response for security reasons.
+     *
+     * @returns Promise resolving to ListOAuthProvidersResponse
+     *
+     * @example
+     * ```typescript
+     * const { providers } = await client.admin.oauth.listProviders()
+     *
+     * providers.forEach(provider => {
+     *   console.log(`${provider.display_name}: ${provider.enabled ? 'enabled' : 'disabled'}`)
+     * })
+     * ```
+     */
+    listProviders(): Promise<OAuthProvider[]>;
+    /**
+     * Get a specific OAuth provider by ID
+     *
+     * Retrieves detailed configuration for a single OAuth provider.
+     * Note: Client secret is not included in the response.
+     *
+     * @param providerId - Provider ID (UUID)
+     * @returns Promise resolving to OAuthProvider
+     *
+     * @example
+     * ```typescript
+     * const provider = await client.admin.oauth.getProvider('provider-uuid')
+     *
+     * console.log('Provider:', provider.display_name)
+     * console.log('Scopes:', provider.scopes.join(', '))
+     * console.log('Redirect URL:', provider.redirect_url)
+     * ```
+     */
+    getProvider(providerId: string): Promise<OAuthProvider>;
+    /**
+     * Create a new OAuth provider
+     *
+     * Creates a new OAuth provider configuration. For built-in providers (Google, GitHub, etc.),
+     * set `is_custom` to false. For custom OAuth2 providers, set `is_custom` to true and provide
+     * the authorization, token, and user info URLs.
+     *
+     * @param request - OAuth provider configuration
+     * @returns Promise resolving to CreateOAuthProviderResponse
+     *
+     * @example
+     * ```typescript
+     * // Create GitHub provider
+     * const result = await client.admin.oauth.createProvider({
+     *   provider_name: 'github',
+     *   display_name: 'GitHub',
+     *   enabled: true,
+     *   client_id: process.env.GITHUB_CLIENT_ID,
+     *   client_secret: process.env.GITHUB_CLIENT_SECRET,
+     *   redirect_url: 'https://yourapp.com/auth/callback',
+     *   scopes: ['user:email', 'read:user'],
+     *   is_custom: false
+     * })
+     *
+     * console.log('Provider created:', result.id)
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Create custom OAuth2 provider
+     * await client.admin.oauth.createProvider({
+     *   provider_name: 'custom_sso',
+     *   display_name: 'Custom SSO',
+     *   enabled: true,
+     *   client_id: 'client-id',
+     *   client_secret: 'client-secret',
+     *   redirect_url: 'https://yourapp.com/auth/callback',
+     *   scopes: ['openid', 'profile', 'email'],
+     *   is_custom: true,
+     *   authorization_url: 'https://sso.example.com/oauth/authorize',
+     *   token_url: 'https://sso.example.com/oauth/token',
+     *   user_info_url: 'https://sso.example.com/oauth/userinfo'
+     * })
+     * ```
+     */
+    createProvider(request: CreateOAuthProviderRequest): Promise<CreateOAuthProviderResponse>;
+    /**
+     * Update an existing OAuth provider
+     *
+     * Updates an OAuth provider configuration. All fields are optional - only provided fields
+     * will be updated. To update the client secret, provide a non-empty value.
+     *
+     * @param providerId - Provider ID (UUID)
+     * @param request - Fields to update
+     * @returns Promise resolving to UpdateOAuthProviderResponse
+     *
+     * @example
+     * ```typescript
+     * // Disable a provider
+     * await client.admin.oauth.updateProvider('provider-id', {
+     *   enabled: false
+     * })
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Update scopes and redirect URL
+     * await client.admin.oauth.updateProvider('provider-id', {
+     *   scopes: ['user:email', 'read:user', 'read:org'],
+     *   redirect_url: 'https://newdomain.com/auth/callback'
+     * })
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Rotate client secret
+     * await client.admin.oauth.updateProvider('provider-id', {
+     *   client_id: 'new-client-id',
+     *   client_secret: 'new-client-secret'
+     * })
+     * ```
+     */
+    updateProvider(providerId: string, request: UpdateOAuthProviderRequest): Promise<UpdateOAuthProviderResponse>;
+    /**
+     * Delete an OAuth provider
+     *
+     * Permanently deletes an OAuth provider configuration. This will prevent users from
+     * authenticating with this provider.
+     *
+     * @param providerId - Provider ID (UUID) to delete
+     * @returns Promise resolving to DeleteOAuthProviderResponse
+     *
+     * @example
+     * ```typescript
+     * await client.admin.oauth.deleteProvider('provider-id')
+     * console.log('Provider deleted')
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Safe deletion with confirmation
+     * const provider = await client.admin.oauth.getProvider('provider-id')
+     * const confirmed = await confirm(`Delete ${provider.display_name}?`)
+     *
+     * if (confirmed) {
+     *   await client.admin.oauth.deleteProvider('provider-id')
+     * }
+     * ```
+     */
+    deleteProvider(providerId: string): Promise<DeleteOAuthProviderResponse>;
+    /**
+     * Enable an OAuth provider
+     *
+     * Convenience method to enable a provider.
+     *
+     * @param providerId - Provider ID (UUID)
+     * @returns Promise resolving to UpdateOAuthProviderResponse
+     *
+     * @example
+     * ```typescript
+     * await client.admin.oauth.enableProvider('provider-id')
+     * ```
+     */
+    enableProvider(providerId: string): Promise<UpdateOAuthProviderResponse>;
+    /**
+     * Disable an OAuth provider
+     *
+     * Convenience method to disable a provider.
+     *
+     * @param providerId - Provider ID (UUID)
+     * @returns Promise resolving to UpdateOAuthProviderResponse
+     *
+     * @example
+     * ```typescript
+     * await client.admin.oauth.disableProvider('provider-id')
+     * ```
+     */
+    disableProvider(providerId: string): Promise<UpdateOAuthProviderResponse>;
+}
+/**
+ * Authentication Settings Manager
+ *
+ * Manages global authentication settings including password requirements, session timeouts,
+ * and signup configuration.
+ *
+ * @example
+ * ```typescript
+ * const authSettings = client.admin.authSettings
+ *
+ * // Get current settings
+ * const settings = await authSettings.get()
+ *
+ * // Update settings
+ * await authSettings.update({
+ *   password_min_length: 12,
+ *   password_require_uppercase: true,
+ *   session_timeout_minutes: 120
+ * })
+ * ```
+ */
+declare class AuthSettingsManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Get current authentication settings
+     *
+     * Retrieves all authentication configuration settings.
+     *
+     * @returns Promise resolving to AuthSettings
+     *
+     * @example
+     * ```typescript
+     * const settings = await client.admin.authSettings.get()
+     *
+     * console.log('Password min length:', settings.password_min_length)
+     * console.log('Signup enabled:', settings.enable_signup)
+     * console.log('Session timeout:', settings.session_timeout_minutes, 'minutes')
+     * ```
+     */
+    get(): Promise<AuthSettings>;
+    /**
+     * Update authentication settings
+     *
+     * Updates one or more authentication settings. All fields are optional - only provided
+     * fields will be updated.
+     *
+     * @param request - Settings to update
+     * @returns Promise resolving to UpdateAuthSettingsResponse
+     *
+     * @example
+     * ```typescript
+     * // Strengthen password requirements
+     * await client.admin.authSettings.update({
+     *   password_min_length: 16,
+     *   password_require_uppercase: true,
+     *   password_require_lowercase: true,
+     *   password_require_number: true,
+     *   password_require_special: true
+     * })
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Extend session timeout
+     * await client.admin.authSettings.update({
+     *   session_timeout_minutes: 240,
+     *   max_sessions_per_user: 10
+     * })
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Disable email verification during development
+     * await client.admin.authSettings.update({
+     *   require_email_verification: false
+     * })
+     * ```
+     */
+    update(request: UpdateAuthSettingsRequest): Promise<UpdateAuthSettingsResponse>;
+}
+/**
+ * OAuth Configuration Manager
+ *
+ * Root manager providing access to OAuth provider and authentication settings management.
+ *
+ * @example
+ * ```typescript
+ * const oauth = client.admin.oauth
+ *
+ * // Manage OAuth providers
+ * const providers = await oauth.providers.listProviders()
+ *
+ * // Manage auth settings
+ * const settings = await oauth.authSettings.get()
+ * ```
+ */
+declare class FluxbaseOAuth {
+    providers: OAuthProviderManager;
+    authSettings: AuthSettingsManager;
+    constructor(fetch: FluxbaseFetch);
+}
+
+/**
+ * Impersonation Manager
+ *
+ * Manages user impersonation for debugging, testing RLS policies, and customer support.
+ * Allows admins to view data as different users, anonymous visitors, or with service role permissions.
+ *
+ * All impersonation sessions are logged in the audit trail for security and compliance.
+ *
+ * @example
+ * ```typescript
+ * const impersonation = client.admin.impersonation
+ *
+ * // Impersonate a specific user
+ * const { session, access_token } = await impersonation.impersonateUser({
+ *   target_user_id: 'user-uuid',
+ *   reason: 'Support ticket #1234'
+ * })
+ *
+ * // Impersonate anonymous user
+ * await impersonation.impersonateAnon({
+ *   reason: 'Testing public data access'
+ * })
+ *
+ * // Impersonate with service role
+ * await impersonation.impersonateService({
+ *   reason: 'Administrative query'
+ * })
+ *
+ * // Stop impersonation
+ * await impersonation.stop()
+ * ```
+ */
+declare class ImpersonationManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Impersonate a specific user
+     *
+     * Start an impersonation session as a specific user. This allows you to see data
+     * exactly as that user would see it, respecting all RLS policies and permissions.
+     *
+     * @param request - Impersonation request with target user ID and reason
+     * @returns Promise resolving to impersonation session with access token
+     *
+     * @example
+     * ```typescript
+     * const result = await client.admin.impersonation.impersonateUser({
+     *   target_user_id: 'user-123',
+     *   reason: 'Support ticket #5678 - user reports missing data'
+     * })
+     *
+     * console.log('Impersonating:', result.target_user.email)
+     * console.log('Session ID:', result.session.id)
+     *
+     * // Use the access token for subsequent requests
+     * // (typically handled automatically by the SDK)
+     * ```
+     */
+    impersonateUser(request: ImpersonateUserRequest): Promise<StartImpersonationResponse>;
+    /**
+     * Impersonate anonymous user
+     *
+     * Start an impersonation session as an unauthenticated user. This allows you to see
+     * what data is publicly accessible and test RLS policies for anonymous access.
+     *
+     * @param request - Impersonation request with reason
+     * @returns Promise resolving to impersonation session with access token
+     *
+     * @example
+     * ```typescript
+     * await client.admin.impersonation.impersonateAnon({
+     *   reason: 'Testing public data access for blog posts'
+     * })
+     *
+     * // Now all queries will use anonymous permissions
+     * const publicPosts = await client.from('posts').select('*')
+     * console.log('Public posts:', publicPosts.length)
+     * ```
+     */
+    impersonateAnon(request: ImpersonateAnonRequest): Promise<StartImpersonationResponse>;
+    /**
+     * Impersonate with service role
+     *
+     * Start an impersonation session with service-level permissions. This provides elevated
+     * access that may bypass RLS policies, useful for administrative operations.
+     *
+     * @param request - Impersonation request with reason
+     * @returns Promise resolving to impersonation session with access token
+     *
+     * @example
+     * ```typescript
+     * await client.admin.impersonation.impersonateService({
+     *   reason: 'Administrative data cleanup'
+     * })
+     *
+     * // Now all queries will use service role permissions
+     * const allRecords = await client.from('sensitive_data').select('*')
+     * console.log('All records:', allRecords.length)
+     * ```
+     */
+    impersonateService(request: ImpersonateServiceRequest): Promise<StartImpersonationResponse>;
+    /**
+     * Stop impersonation
+     *
+     * Ends the current impersonation session and returns to admin context.
+     * The session is marked as ended in the audit trail.
+     *
+     * @returns Promise resolving to stop confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.admin.impersonation.stop()
+     * console.log('Impersonation ended')
+     *
+     * // Subsequent queries will use admin permissions
+     * ```
+     */
+    stop(): Promise<StopImpersonationResponse>;
+    /**
+     * Get current impersonation session
+     *
+     * Retrieves information about the active impersonation session, if any.
+     *
+     * @returns Promise resolving to current impersonation session or null
+     *
+     * @example
+     * ```typescript
+     * const current = await client.admin.impersonation.getCurrent()
+     *
+     * if (current.session) {
+     *   console.log('Currently impersonating:', current.target_user?.email)
+     *   console.log('Reason:', current.session.reason)
+     *   console.log('Started:', current.session.started_at)
+     * } else {
+     *   console.log('No active impersonation')
+     * }
+     * ```
+     */
+    getCurrent(): Promise<GetImpersonationResponse>;
+    /**
+     * List impersonation sessions (audit trail)
+     *
+     * Retrieves a list of impersonation sessions for audit and compliance purposes.
+     * Can be filtered by admin user, target user, type, and active status.
+     *
+     * @param options - Filter and pagination options
+     * @returns Promise resolving to list of impersonation sessions
+     *
+     * @example
+     * ```typescript
+     * // List all sessions
+     * const { sessions, total } = await client.admin.impersonation.listSessions()
+     * console.log(`Total sessions: ${total}`)
+     *
+     * // List active sessions only
+     * const active = await client.admin.impersonation.listSessions({
+     *   is_active: true
+     * })
+     * console.log('Active sessions:', active.sessions.length)
+     *
+     * // List sessions for a specific admin
+     * const adminSessions = await client.admin.impersonation.listSessions({
+     *   admin_user_id: 'admin-uuid',
+     *   limit: 50
+     * })
+     *
+     * // List user impersonation sessions only
+     * const userSessions = await client.admin.impersonation.listSessions({
+     *   impersonation_type: 'user',
+     *   offset: 0,
+     *   limit: 100
+     * })
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Audit trail: Find who impersonated a specific user
+     * const userHistory = await client.admin.impersonation.listSessions({
+     *   target_user_id: 'user-uuid'
+     * })
+     *
+     * userHistory.sessions.forEach(session => {
+     *   console.log(`Admin ${session.admin_user_id} impersonated user`)
+     *   console.log(`Reason: ${session.reason}`)
+     *   console.log(`Duration: ${session.started_at} - ${session.ended_at}`)
+     * })
+     * ```
+     */
+    listSessions(options?: ListImpersonationSessionsOptions): Promise<ListImpersonationSessionsResponse>;
+}
+
+/**
+ * API Keys management client
+ *
+ * Provides methods for managing API keys for service-to-service authentication.
+ * API keys allow external services to authenticate without user credentials.
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({ url: 'http://localhost:8080' })
+ * await client.auth.login({ email: 'user@example.com', password: 'password' })
+ *
+ * // Create an API key
+ * const { api_key, key } = await client.management.apiKeys.create({
+ *   name: 'Production Service',
+ *   scopes: ['read:users', 'write:users'],
+ *   rate_limit_per_minute: 100
+ * })
+ *
+ * // List API keys
+ * const { api_keys } = await client.management.apiKeys.list()
+ * ```
+ *
+ * @category Management
+ */
+declare class APIKeysManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Create a new API key
+     *
+     * @param request - API key configuration
+     * @returns Created API key with the full key value (only shown once)
+     *
+     * @example
+     * ```typescript
+     * const { api_key, key } = await client.management.apiKeys.create({
+     *   name: 'Production Service',
+     *   description: 'API key for production service',
+     *   scopes: ['read:users', 'write:users'],
+     *   rate_limit_per_minute: 100,
+     *   expires_at: '2025-12-31T23:59:59Z'
+     * })
+     *
+     * // Store the key securely - it won't be shown again
+     * console.log('API Key:', key)
+     * ```
+     */
+    create(request: CreateAPIKeyRequest): Promise<CreateAPIKeyResponse>;
+    /**
+     * List all API keys for the authenticated user
+     *
+     * @returns List of API keys (without full key values)
+     *
+     * @example
+     * ```typescript
+     * const { api_keys, total } = await client.management.apiKeys.list()
+     *
+     * api_keys.forEach(key => {
+     *   console.log(`${key.name}: ${key.key_prefix}... (expires: ${key.expires_at})`)
+     * })
+     * ```
+     */
+    list(): Promise<ListAPIKeysResponse>;
+    /**
+     * Get a specific API key by ID
+     *
+     * @param keyId - API key ID
+     * @returns API key details
+     *
+     * @example
+     * ```typescript
+     * const apiKey = await client.management.apiKeys.get('key-uuid')
+     * console.log('Last used:', apiKey.last_used_at)
+     * ```
+     */
+    get(keyId: string): Promise<APIKey>;
+    /**
+     * Update an API key
+     *
+     * @param keyId - API key ID
+     * @param updates - Fields to update
+     * @returns Updated API key
+     *
+     * @example
+     * ```typescript
+     * const updated = await client.management.apiKeys.update('key-uuid', {
+     *   name: 'Updated Name',
+     *   rate_limit_per_minute: 200
+     * })
+     * ```
+     */
+    update(keyId: string, updates: UpdateAPIKeyRequest): Promise<APIKey>;
+    /**
+     * Revoke an API key
+     *
+     * Revoked keys can no longer be used but remain in the system for audit purposes.
+     *
+     * @param keyId - API key ID
+     * @returns Revocation confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.management.apiKeys.revoke('key-uuid')
+     * console.log('API key revoked')
+     * ```
+     */
+    revoke(keyId: string): Promise<RevokeAPIKeyResponse>;
+    /**
+     * Delete an API key
+     *
+     * Permanently removes the API key from the system.
+     *
+     * @param keyId - API key ID
+     * @returns Deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.management.apiKeys.delete('key-uuid')
+     * console.log('API key deleted')
+     * ```
+     */
+    delete(keyId: string): Promise<DeleteAPIKeyResponse>;
+}
+/**
+ * Webhooks management client
+ *
+ * Provides methods for managing webhooks to receive real-time event notifications.
+ * Webhooks allow your application to be notified when events occur in Fluxbase.
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({ url: 'http://localhost:8080' })
+ * await client.auth.login({ email: 'user@example.com', password: 'password' })
+ *
+ * // Create a webhook
+ * const webhook = await client.management.webhooks.create({
+ *   url: 'https://myapp.com/webhook',
+ *   events: ['user.created', 'user.updated'],
+ *   secret: 'my-webhook-secret'
+ * })
+ *
+ * // Test the webhook
+ * const result = await client.management.webhooks.test(webhook.id)
+ * ```
+ *
+ * @category Management
+ */
+declare class WebhooksManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Create a new webhook
+     *
+     * @param request - Webhook configuration
+     * @returns Created webhook
+     *
+     * @example
+     * ```typescript
+     * const webhook = await client.management.webhooks.create({
+     *   url: 'https://myapp.com/webhook',
+     *   events: ['user.created', 'user.updated', 'user.deleted'],
+     *   description: 'User events webhook',
+     *   secret: 'my-webhook-secret'
+     * })
+     * ```
+     */
+    create(request: CreateWebhookRequest): Promise<Webhook>;
+    /**
+     * List all webhooks for the authenticated user
+     *
+     * @returns List of webhooks
+     *
+     * @example
+     * ```typescript
+     * const { webhooks, total } = await client.management.webhooks.list()
+     *
+     * webhooks.forEach(webhook => {
+     *   console.log(`${webhook.url}: ${webhook.is_active ? 'active' : 'inactive'}`)
+     * })
+     * ```
+     */
+    list(): Promise<ListWebhooksResponse>;
+    /**
+     * Get a specific webhook by ID
+     *
+     * @param webhookId - Webhook ID
+     * @returns Webhook details
+     *
+     * @example
+     * ```typescript
+     * const webhook = await client.management.webhooks.get('webhook-uuid')
+     * console.log('Events:', webhook.events)
+     * ```
+     */
+    get(webhookId: string): Promise<Webhook>;
+    /**
+     * Update a webhook
+     *
+     * @param webhookId - Webhook ID
+     * @param updates - Fields to update
+     * @returns Updated webhook
+     *
+     * @example
+     * ```typescript
+     * const updated = await client.management.webhooks.update('webhook-uuid', {
+     *   events: ['user.created', 'user.deleted'],
+     *   is_active: false
+     * })
+     * ```
+     */
+    update(webhookId: string, updates: UpdateWebhookRequest): Promise<Webhook>;
+    /**
+     * Delete a webhook
+     *
+     * @param webhookId - Webhook ID
+     * @returns Deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.management.webhooks.delete('webhook-uuid')
+     * console.log('Webhook deleted')
+     * ```
+     */
+    delete(webhookId: string): Promise<DeleteWebhookResponse>;
+    /**
+     * Test a webhook by sending a test payload
+     *
+     * @param webhookId - Webhook ID
+     * @returns Test result with status and response
+     *
+     * @example
+     * ```typescript
+     * const result = await client.management.webhooks.test('webhook-uuid')
+     *
+     * if (result.success) {
+     *   console.log('Webhook test successful')
+     * } else {
+     *   console.error('Webhook test failed:', result.error)
+     * }
+     * ```
+     */
+    test(webhookId: string): Promise<TestWebhookResponse>;
+    /**
+     * List webhook delivery history
+     *
+     * @param webhookId - Webhook ID
+     * @param limit - Maximum number of deliveries to return (default: 50)
+     * @returns List of webhook deliveries
+     *
+     * @example
+     * ```typescript
+     * const { deliveries } = await client.management.webhooks.listDeliveries('webhook-uuid', 100)
+     *
+     * deliveries.forEach(delivery => {
+     *   console.log(`Event: ${delivery.event}, Status: ${delivery.status_code}`)
+     * })
+     * ```
+     */
+    listDeliveries(webhookId: string, limit?: number): Promise<ListWebhookDeliveriesResponse>;
+}
+/**
+ * Invitations management client
+ *
+ * Provides methods for creating and managing user invitations.
+ * Invitations allow admins to invite new users to join the dashboard.
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({ url: 'http://localhost:8080' })
+ * await client.admin.login({ email: 'admin@example.com', password: 'password' })
+ *
+ * // Create an invitation
+ * const invitation = await client.management.invitations.create({
+ *   email: 'newuser@example.com',
+ *   role: 'dashboard_user'
+ * })
+ *
+ * console.log('Invite link:', invitation.invite_link)
+ * ```
+ *
+ * @category Management
+ */
+declare class InvitationsManager {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Create a new invitation (admin only)
+     *
+     * @param request - Invitation details
+     * @returns Created invitation with invite link
+     *
+     * @example
+     * ```typescript
+     * const invitation = await client.management.invitations.create({
+     *   email: 'newuser@example.com',
+     *   role: 'dashboard_user',
+     *   expiry_duration: 604800 // 7 days in seconds
+     * })
+     *
+     * // Share the invite link
+     * console.log('Send this link to the user:', invitation.invite_link)
+     * ```
+     */
+    create(request: CreateInvitationRequest): Promise<CreateInvitationResponse>;
+    /**
+     * List all invitations (admin only)
+     *
+     * @param options - Filter options
+     * @returns List of invitations
+     *
+     * @example
+     * ```typescript
+     * // List pending invitations only
+     * const { invitations } = await client.management.invitations.list({
+     *   include_accepted: false,
+     *   include_expired: false
+     * })
+     *
+     * // List all invitations including accepted and expired
+     * const all = await client.management.invitations.list({
+     *   include_accepted: true,
+     *   include_expired: true
+     * })
+     * ```
+     */
+    list(options?: ListInvitationsOptions): Promise<ListInvitationsResponse>;
+    /**
+     * Validate an invitation token (public endpoint)
+     *
+     * @param token - Invitation token
+     * @returns Validation result with invitation details
+     *
+     * @example
+     * ```typescript
+     * const result = await client.management.invitations.validate('invitation-token')
+     *
+     * if (result.valid) {
+     *   console.log('Valid invitation for:', result.invitation?.email)
+     * } else {
+     *   console.error('Invalid:', result.error)
+     * }
+     * ```
+     */
+    validate(token: string): Promise<ValidateInvitationResponse>;
+    /**
+     * Accept an invitation and create a new user (public endpoint)
+     *
+     * @param token - Invitation token
+     * @param request - User details (password and name)
+     * @returns Created user with authentication tokens
+     *
+     * @example
+     * ```typescript
+     * const response = await client.management.invitations.accept('invitation-token', {
+     *   password: 'SecurePassword123!',
+     *   name: 'John Doe'
+     * })
+     *
+     * // Store tokens
+     * localStorage.setItem('access_token', response.access_token)
+     * console.log('Welcome:', response.user.name)
+     * ```
+     */
+    accept(token: string, request: AcceptInvitationRequest): Promise<AcceptInvitationResponse>;
+    /**
+     * Revoke an invitation (admin only)
+     *
+     * @param token - Invitation token
+     * @returns Revocation confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.management.invitations.revoke('invitation-token')
+     * console.log('Invitation revoked')
+     * ```
+     */
+    revoke(token: string): Promise<RevokeInvitationResponse>;
+}
+/**
+ * Management client for API keys, webhooks, and invitations
+ *
+ * @category Management
+ */
+declare class FluxbaseManagement {
+    /** API Keys management */
+    apiKeys: APIKeysManager;
+    /** Webhooks management */
+    webhooks: WebhooksManager;
+    /** Invitations management */
+    invitations: InvitationsManager;
+    constructor(fetch: FluxbaseFetch);
+}
+
+/**
+ * Admin client for managing Fluxbase instance
+ */
+declare class FluxbaseAdmin {
+    private fetch;
+    private adminToken;
+    /**
+     * Settings manager for system and application settings
+     */
+    settings: FluxbaseSettings;
+    /**
+     * DDL manager for database schema and table operations
+     */
+    ddl: DDLManager;
+    /**
+     * OAuth configuration manager for provider and auth settings
+     */
+    oauth: FluxbaseOAuth;
+    /**
+     * Impersonation manager for user impersonation and audit trail
+     */
+    impersonation: ImpersonationManager;
+    /**
+     * Management namespace for API keys, webhooks, and invitations
+     */
+    management: FluxbaseManagement;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Set admin authentication token
+     */
+    setToken(token: string): void;
+    /**
+     * Get current admin token
+     */
+    getToken(): string | null;
+    /**
+     * Clear admin token
+     */
+    clearToken(): void;
+    /**
+     * Check if initial admin setup is needed
+     *
+     * @returns Setup status indicating if initial setup is required
+     *
+     * @example
+     * ```typescript
+     * const status = await admin.getSetupStatus();
+     * if (status.needs_setup) {
+     *   console.log('Initial setup required');
+     * }
+     * ```
+     */
+    getSetupStatus(): Promise<AdminSetupStatusResponse>;
+    /**
+     * Perform initial admin setup
+     *
+     * Creates the first admin user and completes initial setup.
+     * This endpoint can only be called once.
+     *
+     * @param email - Admin email address
+     * @param password - Admin password (minimum 12 characters)
+     * @param name - Admin display name
+     * @returns Authentication response with tokens
+     *
+     * @example
+     * ```typescript
+     * const response = await admin.setup({
+     *   email: 'admin@example.com',
+     *   password: 'SecurePassword123!',
+     *   name: 'Admin User'
+     * });
+     *
+     * // Store tokens
+     * localStorage.setItem('admin_token', response.access_token);
+     * ```
+     */
+    setup(request: AdminSetupRequest): Promise<AdminAuthResponse>;
+    /**
+     * Admin login
+     *
+     * Authenticate as an admin user
+     *
+     * @param email - Admin email
+     * @param password - Admin password
+     * @returns Authentication response with tokens
+     *
+     * @example
+     * ```typescript
+     * const response = await admin.login({
+     *   email: 'admin@example.com',
+     *   password: 'password123'
+     * });
+     *
+     * // Token is automatically set in the client
+     * console.log('Logged in as:', response.user.email);
+     * ```
+     */
+    login(request: AdminLoginRequest): Promise<AdminAuthResponse>;
+    /**
+     * Refresh admin access token
+     *
+     * @param refreshToken - Refresh token
+     * @returns New access and refresh tokens
+     *
+     * @example
+     * ```typescript
+     * const refreshToken = localStorage.getItem('admin_refresh_token');
+     * const response = await admin.refreshToken({ refresh_token: refreshToken });
+     *
+     * // Update stored tokens
+     * localStorage.setItem('admin_token', response.access_token);
+     * localStorage.setItem('admin_refresh_token', response.refresh_token);
+     * ```
+     */
+    refreshToken(request: AdminRefreshRequest): Promise<AdminRefreshResponse>;
+    /**
+     * Admin logout
+     *
+     * Invalidates the current admin session
+     *
+     * @example
+     * ```typescript
+     * await admin.logout();
+     * localStorage.removeItem('admin_token');
+     * ```
+     */
+    logout(): Promise<void>;
+    /**
+     * Get current admin user information
+     *
+     * @returns Current admin user details
+     *
+     * @example
+     * ```typescript
+     * const { user } = await admin.me();
+     * console.log('Logged in as:', user.email);
+     * console.log('Role:', user.role);
+     * ```
+     */
+    me(): Promise<AdminMeResponse>;
+    /**
+     * List all users
+     *
+     * @param options - Filter and pagination options
+     * @returns List of users with metadata
+     *
+     * @example
+     * ```typescript
+     * // List all users
+     * const { users, total } = await admin.listUsers();
+     *
+     * // List with filters
+     * const result = await admin.listUsers({
+     *   exclude_admins: true,
+     *   search: 'john',
+     *   limit: 50,
+     *   type: 'app'
+     * });
+     * ```
+     */
+    listUsers(options?: ListUsersOptions): Promise<ListUsersResponse>;
+    /**
+     * Get a user by ID
+     *
+     * Fetch a single user's details by their user ID
+     *
+     * @param userId - User ID to fetch
+     * @param type - User type ('app' or 'dashboard')
+     * @returns User details with metadata
+     *
+     * @example
+     * ```typescript
+     * // Get an app user
+     * const user = await admin.getUserById('user-123');
+     *
+     * // Get a dashboard user
+     * const dashboardUser = await admin.getUserById('admin-456', 'dashboard');
+     * console.log('User email:', dashboardUser.email);
+     * console.log('Last login:', dashboardUser.last_login_at);
+     * ```
+     */
+    getUserById(userId: string, type?: "app" | "dashboard"): Promise<EnrichedUser>;
+    /**
+     * Invite a new user
+     *
+     * Creates a new user and optionally sends an invitation email
+     *
+     * @param request - User invitation details
+     * @param type - User type ('app' or 'dashboard')
+     * @returns Created user and invitation details
+     *
+     * @example
+     * ```typescript
+     * const response = await admin.inviteUser({
+     *   email: 'newuser@example.com',
+     *   role: 'user',
+     *   send_email: true
+     * });
+     *
+     * console.log('User invited:', response.user.email);
+     * console.log('Invitation link:', response.invitation_link);
+     * ```
+     */
+    inviteUser(request: InviteUserRequest, type?: "app" | "dashboard"): Promise<InviteUserResponse>;
+    /**
+     * Delete a user
+     *
+     * Permanently deletes a user and all associated data
+     *
+     * @param userId - User ID to delete
+     * @param type - User type ('app' or 'dashboard')
+     * @returns Deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * await admin.deleteUser('user-uuid');
+     * console.log('User deleted');
+     * ```
+     */
+    deleteUser(userId: string, type?: "app" | "dashboard"): Promise<DeleteUserResponse>;
+    /**
+     * Update user role
+     *
+     * Changes a user's role
+     *
+     * @param userId - User ID
+     * @param role - New role
+     * @param type - User type ('app' or 'dashboard')
+     * @returns Updated user
+     *
+     * @example
+     * ```typescript
+     * const user = await admin.updateUserRole('user-uuid', 'admin');
+     * console.log('User role updated:', user.role);
+     * ```
+     */
+    updateUserRole(userId: string, role: string, type?: "app" | "dashboard"): Promise<EnrichedUser>;
+    /**
+     * Reset user password
+     *
+     * Generates a new password for the user and optionally sends it via email
+     *
+     * @param userId - User ID
+     * @param type - User type ('app' or 'dashboard')
+     * @returns Reset confirmation message
+     *
+     * @example
+     * ```typescript
+     * const response = await admin.resetUserPassword('user-uuid');
+     * console.log(response.message);
+     * ```
+     */
+    resetUserPassword(userId: string, type?: "app" | "dashboard"): Promise<ResetUserPasswordResponse>;
+}
+
+/**
+ * PostgreSQL query builder for Fluxbase SDK
+ * Inspired by Supabase's PostgREST client
+ */
+
+declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse<T>> {
+    private fetch;
+    private table;
+    private selectQuery;
+    private filters;
+    private orderBys;
+    private limitValue?;
+    private offsetValue?;
+    private singleRow;
+    private groupByColumns?;
+    constructor(fetch: FluxbaseFetch, table: string);
+    /**
+     * Select columns to return
+     * @example select('*')
+     * @example select('id, name, email')
+     * @example select('id, name, posts(title, content)')
+     */
+    select(columns?: string): this;
+    /**
+     * Insert a single row or multiple rows
+     */
+    insert(data: Partial<T> | Array<Partial<T>>): Promise<PostgrestResponse<T>>;
+    /**
+     * Upsert (insert or update) rows
+     */
+    upsert(data: Partial<T> | Array<Partial<T>>): Promise<PostgrestResponse<T>>;
+    /**
+     * Update rows matching the filters
+     */
+    update(data: Partial<T>): Promise<PostgrestResponse<T>>;
+    /**
+     * Delete rows matching the filters
+     */
+    delete(): Promise<PostgrestResponse<null>>;
+    /**
+     * Equal to
+     */
+    eq(column: string, value: unknown): this;
+    /**
+     * Not equal to
+     */
+    neq(column: string, value: unknown): this;
+    /**
+     * Greater than
+     */
+    gt(column: string, value: unknown): this;
+    /**
+     * Greater than or equal to
+     */
+    gte(column: string, value: unknown): this;
+    /**
+     * Less than
+     */
+    lt(column: string, value: unknown): this;
+    /**
+     * Less than or equal to
+     */
+    lte(column: string, value: unknown): this;
+    /**
+     * Pattern matching (case-sensitive)
+     */
+    like(column: string, pattern: string): this;
+    /**
+     * Pattern matching (case-insensitive)
+     */
+    ilike(column: string, pattern: string): this;
+    /**
+     * Check if value is null or not null
+     */
+    is(column: string, value: null | boolean): this;
+    /**
+     * Check if value is in array
+     */
+    in(column: string, values: unknown[]): this;
+    /**
+     * Contains (for arrays and JSONB)
+     */
+    contains(column: string, value: unknown): this;
+    /**
+     * Full-text search
+     */
+    textSearch(column: string, query: string): this;
+    /**
+     * Order results
+     */
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): this;
+    /**
+     * Limit number of rows returned
+     */
+    limit(count: number): this;
+    /**
+     * Skip rows
+     */
+    offset(count: number): this;
+    /**
+     * Return a single row (adds limit(1))
+     */
+    single(): this;
+    /**
+     * Range selection (pagination)
+     */
+    range(from: number, to: number): this;
+    /**
+     * Group results by one or more columns (for use with aggregations)
+     *
+     * @param columns - Column name(s) to group by
+     * @returns Query builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Group by single column
+     * const { data } = await client.from('orders')
+     *   .count('*')
+     *   .groupBy('status')
+     *   .execute()
+     *
+     * // Group by multiple columns
+     * const { data } = await client.from('sales')
+     *   .sum('amount')
+     *   .groupBy(['region', 'product_category'])
+     *   .execute()
+     * ```
+     *
+     * @category Aggregation
+     */
+    groupBy(columns: string | string[]): this;
+    /**
+     * Count rows or a specific column
+     *
+     * @param column - Column to count (default: '*' for row count)
+     * @returns Query builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Count all rows
+     * const { data } = await client.from('users').count().execute()
+     * // Returns: { count: 150 }
+     *
+     * // Count non-null values in a column
+     * const { data } = await client.from('orders').count('completed_at').execute()
+     *
+     * // Count with grouping
+     * const { data } = await client.from('products')
+     *   .count('*')
+     *   .groupBy('category')
+     *   .execute()
+     * // Returns: [{ category: 'electronics', count: 45 }, { category: 'books', count: 23 }]
+     * ```
+     *
+     * @category Aggregation
+     */
+    count(column?: string): this;
+    /**
+     * Calculate the sum of a numeric column
+     *
+     * @param column - Column to sum
+     * @returns Query builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Sum all prices
+     * const { data } = await client.from('products').sum('price').execute()
+     * // Returns: { sum_price: 15420.50 }
+     *
+     * // Sum by category
+     * const { data } = await client.from('orders')
+     *   .sum('total')
+     *   .groupBy('status')
+     *   .execute()
+     * // Returns: [{ status: 'completed', sum_total: 12500 }, { status: 'pending', sum_total: 3200 }]
+     * ```
+     *
+     * @category Aggregation
+     */
+    sum(column: string): this;
+    /**
+     * Calculate the average of a numeric column
+     *
+     * @param column - Column to average
+     * @returns Query builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Average price
+     * const { data } = await client.from('products').avg('price').execute()
+     * // Returns: { avg_price: 129.99 }
+     *
+     * // Average by category
+     * const { data } = await client.from('products')
+     *   .avg('price')
+     *   .groupBy('category')
+     *   .execute()
+     * ```
+     *
+     * @category Aggregation
+     */
+    avg(column: string): this;
+    /**
+     * Find the minimum value in a column
+     *
+     * @param column - Column to find minimum value
+     * @returns Query builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Find lowest price
+     * const { data } = await client.from('products').min('price').execute()
+     * // Returns: { min_price: 9.99 }
+     *
+     * // Find earliest date
+     * const { data } = await client.from('orders').min('created_at').execute()
+     * ```
+     *
+     * @category Aggregation
+     */
+    min(column: string): this;
+    /**
+     * Find the maximum value in a column
+     *
+     * @param column - Column to find maximum value
+     * @returns Query builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Find highest price
+     * const { data } = await client.from('products').max('price').execute()
+     * // Returns: { max_price: 1999.99 }
+     *
+     * // Find most recent order
+     * const { data } = await client.from('orders').max('created_at').execute()
+     * ```
+     *
+     * @category Aggregation
+     */
+    max(column: string): this;
+    /**
+     * Insert multiple rows in a single request (batch insert)
+     *
+     * This is a convenience method that explicitly shows intent for batch operations.
+     * Internally calls `insert()` with an array.
+     *
+     * @param rows - Array of row objects to insert
+     * @returns Promise with the inserted rows
+     *
+     * @example
+     * ```typescript
+     * // Insert multiple users at once
+     * const { data } = await client.from('users').insertMany([
+     *   { name: 'Alice', email: 'alice@example.com' },
+     *   { name: 'Bob', email: 'bob@example.com' },
+     *   { name: 'Charlie', email: 'charlie@example.com' }
+     * ]).execute()
+     * ```
+     *
+     * @category Batch Operations
+     */
+    insertMany(rows: Array<Partial<T>>): Promise<PostgrestResponse<T>>;
+    /**
+     * Update multiple rows matching the filters (batch update)
+     *
+     * Updates all rows that match the current query filters.
+     * This is a convenience method that explicitly shows intent for batch operations.
+     *
+     * @param data - Data to update matching rows with
+     * @returns Promise with the updated rows
+     *
+     * @example
+     * ```typescript
+     * // Apply discount to all electronics
+     * const { data } = await client.from('products')
+     *   .eq('category', 'electronics')
+     *   .updateMany({ discount: 10, updated_at: new Date() })
+     *   .execute()
+     *
+     * // Mark all pending orders as processing
+     * const { data } = await client.from('orders')
+     *   .eq('status', 'pending')
+     *   .updateMany({ status: 'processing' })
+     *   .execute()
+     * ```
+     *
+     * @category Batch Operations
+     */
+    updateMany(data: Partial<T>): Promise<PostgrestResponse<T>>;
+    /**
+     * Delete multiple rows matching the filters (batch delete)
+     *
+     * Deletes all rows that match the current query filters.
+     * This is a convenience method that explicitly shows intent for batch operations.
+     *
+     * @returns Promise confirming deletion
+     *
+     * @example
+     * ```typescript
+     * // Delete all inactive users
+     * await client.from('users')
+     *   .eq('active', false)
+     *   .deleteMany()
+     *   .execute()
+     *
+     * // Delete old logs
+     * await client.from('logs')
+     *   .lt('created_at', '2024-01-01')
+     *   .deleteMany()
+     *   .execute()
+     * ```
+     *
+     * @category Batch Operations
+     */
+    deleteMany(): Promise<PostgrestResponse<null>>;
+    /**
+     * Execute the query and return results
+     */
+    execute(): Promise<PostgrestResponse<T>>;
+    /**
+     * Make QueryBuilder awaitable (implements PromiseLike)
+     * This allows using `await client.from('table').select()` without calling `.execute()`
+     *
+     * @example
+     * ```typescript
+     * // Without .execute() (new way)
+     * const { data } = await client.from('users').select('*')
+     *
+     * // With .execute() (old way, still supported)
+     * const { data } = await client.from('users').select('*').execute()
+     * ```
+     */
+    then<TResult1 = PostgrestResponse<T>, TResult2 = never>(onfulfilled?: ((value: PostgrestResponse<T>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * Build the query string from filters, ordering, etc.
+     */
+    private buildQueryString;
+    /**
+     * Format a value for the query string
+     */
+    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 {
+    /** Internal HTTP client for making requests */
+    private fetch;
+    /** Authentication module for user management */
+    auth: FluxbaseAuth;
+    /** Realtime module for WebSocket subscriptions */
+    realtime: FluxbaseRealtime;
+    /** Storage module for file operations */
+    storage: FluxbaseStorage;
+    /** 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
+     */
+    constructor(options: FluxbaseClientOptions);
+    /**
+     * Create a query builder for a database table
+     *
+     * @param table - The table name (can include schema, e.g., 'public.users')
+     * @returns A query builder instance for constructing and executing queries
+     *
+     * @example
+     * ```typescript
+     * // Simple select
+     * const { data } = await client.from('users').select('*').execute()
+     *
+     * // With filters
+     * const { data } = await client.from('products')
+     *   .select('id, name, price')
+     *   .gt('price', 100)
+     *   .eq('category', 'electronics')
+     *   .execute()
+     *
+     * // Insert
+     * await client.from('users').insert({ name: 'John', email: 'john@example.com' }).execute()
+     * ```
+     *
+     * @category Database
+     */
+    from<T = any>(table: string): QueryBuilder<T>;
+    /**
+     * Call a PostgreSQL function (Remote Procedure Call)
+     *
+     * @param functionName - The name of the PostgreSQL function to call
+     * @param params - Optional parameters to pass to the function
+     * @returns Promise containing the function result or error
+     *
+     * @example
+     * ```typescript
+     * // Call a function without parameters
+     * const { data, error } = await client.rpc('get_total_users')
+     *
+     * // Call a function with parameters
+     * const { data, error } = await client.rpc('calculate_discount', {
+     *   product_id: 123,
+     *   coupon_code: 'SAVE20'
+     * })
+     * ```
+     *
+     * @category Database
+     */
+    rpc<T = any>(functionName: string, params?: Record<string, unknown>): Promise<{
+        data: T | null;
+        error: Error | null;
+    }>;
+    /**
+     * Sync auth state with realtime connections
+     * @internal
+     */
+    private setupAuthSync;
+    /**
+     * Get the current authentication token
+     *
+     * @returns The current JWT access token, or null if not authenticated
+     *
+     * @category Authentication
+     */
+    getAuthToken(): string | null;
+    /**
+     * Set a new authentication token
+     *
+     * This updates both the HTTP client and realtime connection with the new token.
+     *
+     * @param token - The JWT access token to set, or null to clear authentication
+     *
+     * @category Authentication
+     */
+    setAuthToken(token: string | null): void;
+    /**
+     * Get the internal HTTP client
+     *
+     * Use this for advanced scenarios like making custom API calls or admin operations.
+     *
+     * @returns The internal FluxbaseFetch instance
+     *
+     * @example
+     * ```typescript
+     * // Make a custom API call
+     * const data = await client.http.get('/api/custom-endpoint')
+     * ```
+     *
+     * @category Advanced
+     */
+    get http(): FluxbaseFetch;
+}
+/**
+ * Create a new Fluxbase client instance
+ *
+ * This is the recommended way to initialize the Fluxbase SDK.
+ *
+ * @param options - Client configuration options
+ * @returns A configured Fluxbase client instance
+ *
+ * @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
+ * })
+ * ```
+ *
+ * @category Client
+ */
+declare function createClient(options: FluxbaseClientOptions): FluxbaseClient;
+
+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 };