@resultdev/sdk 0.1.0 → 0.3.0

package/dist/client-DrsZ1qIm.d.ts

@@ -0,0 +1,1087 @@
+import { e as AuthSession, U as UserSchema, a as ResultConfig, G as AuthRefreshResponse, C as ChatCompletionRequest, B as ToolCall, H as Annotation, I as ImageGenerationRequest, j as EmbeddingsRequest, J as EmbeddingObject, h as CreateUserRequest, K as CreateUserResponse, o as ResultError, g as CreateSessionRequest, L as CreateSessionResponse, l as OAuthProvidersSchema, M as RefreshSessionResponse, N as GetProfileResponse, Q as SendVerificationEmailRequest, V as VerifyEmailRequest, W as VerifyEmailResponse, X as SendResetPasswordEmailRequest, Y as ExchangeResetPasswordTokenRequest, Z as ExchangeResetPasswordTokenResponse, _ as ResetPasswordResponse, $ as GetPublicAuthConfigResponse, S as SendRawEmailRequest, q as SendEmailResponse, v as SubscribeResponse, r as SocketMessage, P as PresenceMember, u as StorageFileSchema, a0 as ListObjectsResponseSchema, i as DeleteObjectsResponse, A as Analytics, w as Support } from './types-DSVtGaIA.js';
+import * as _supabase_postgrest_js from '@supabase/postgrest-js';
+import { PostgrestClient } from '@supabase/postgrest-js';
+
+type LogFunction = (message: string, ...args: any[]) => void;
+/**
+ * Debug logger for the Result SDK.
+ * Logs HTTP request/response details with automatic redaction of sensitive data.
+ *
+ * @example
+ * ```typescript
+ * // Enable via SDK config
+ * const client = new ResultClient({ debug: true });
+ *
+ * // Or with a custom log function
+ * const client = new ResultClient({
+ *   debug: (msg) => myLogger.info(msg)
+ * });
+ * ```
+ */
+declare class Logger {
+    /** Whether debug logging is currently enabled */
+    enabled: boolean;
+    private customLog;
+    /**
+     * Creates a new Logger instance.
+     * @param debug - Set to true to enable console logging, or pass a custom log function
+     */
+    constructor(debug?: boolean | LogFunction);
+    /**
+     * Logs a debug message at the info level.
+     * @param message - The message to log
+     * @param args - Additional arguments to pass to the log function
+     */
+    log(message: string, ...args: any[]): void;
+    /**
+     * Logs a debug message at the warning level.
+     * @param message - The message to log
+     * @param args - Additional arguments to pass to the log function
+     */
+    warn(message: string, ...args: any[]): void;
+    /**
+     * Logs a debug message at the error level.
+     * @param message - The message to log
+     * @param args - Additional arguments to pass to the log function
+     */
+    error(message: string, ...args: any[]): void;
+    /**
+     * Logs an outgoing HTTP request with method, URL, headers, and body.
+     * Sensitive headers and body fields are automatically redacted.
+     * @param method - HTTP method (GET, POST, etc.)
+     * @param url - The full request URL
+     * @param headers - Request headers (sensitive values will be redacted)
+     * @param body - Request body (sensitive fields will be masked)
+     */
+    logRequest(method: string, url: string, headers?: Record<string, string>, body?: any): void;
+    /**
+     * Logs an incoming HTTP response with method, URL, status, duration, and body.
+     * Error responses (4xx/5xx) are logged at the error level.
+     * @param method - HTTP method (GET, POST, etc.)
+     * @param url - The full request URL
+     * @param status - HTTP response status code
+     * @param durationMs - Request duration in milliseconds
+     * @param body - Response body (sensitive fields will be masked, large bodies truncated)
+     */
+    logResponse(method: string, url: string, status: number, durationMs: number, body?: any): void;
+}
+
+/**
+ * Token Manager for Result SDK
+ *
+ * Memory-only token storage.
+ */
+
+declare const AuthChangeEvent: {
+    readonly SIGNED_IN: "signedIn";
+    readonly SIGNED_OUT: "signedOut";
+    readonly TOKEN_REFRESHED: "tokenRefreshed";
+};
+type AuthChangeEvent = (typeof AuthChangeEvent)[keyof typeof AuthChangeEvent];
+type AuthStateChangeCallback = (event: AuthChangeEvent) => void;
+declare class TokenManager {
+    private accessToken;
+    private user;
+    private authStateChangeCallbacks;
+    /**
+     * Save session in memory
+     */
+    saveSession(session: AuthSession, event?: AuthChangeEvent): void;
+    /**
+     * Get current session
+     */
+    getSession(): AuthSession | null;
+    /**
+     * Get access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Set access token
+     */
+    setAccessToken(token: string, event?: AuthChangeEvent): void;
+    /**
+     * Get user
+     */
+    getUser(): UserSchema | null;
+    /**
+     * Set user
+     */
+    setUser(user: UserSchema): void;
+    /**
+     * Clear in-memory session
+     */
+    clearSession(): void;
+    onAuthStateChange(callback: AuthStateChangeCallback): () => void;
+    private notifyAuthStateChange;
+}
+
+type JsonRequestBody = Record<string, unknown> | unknown[] | null;
+interface RequestOptions extends Omit<RequestInit, "body"> {
+    params?: Record<string, string>;
+    body?: RequestInit["body"] | JsonRequestBody;
+    /** Allow retrying non-idempotent requests (POST, PATCH). Off by default to prevent duplicate writes. */
+    idempotent?: boolean;
+    /** Disable automatic access-token refresh for auth/control-flow requests. */
+    skipAuthRefresh?: boolean;
+}
+/**
+ * HTTP client with built-in retry, timeout, and exponential backoff support.
+ * Handles authentication, request serialization, and error normalization.
+ */
+declare class HttpClient {
+    readonly baseUrl: string;
+    readonly fetch: typeof fetch;
+    private readonly config;
+    private defaultHeaders;
+    private anonKey;
+    private userToken;
+    private logger;
+    private isRefreshing;
+    private refreshPromise;
+    private tokenManager;
+    private refreshToken;
+    private timeout;
+    private retryCount;
+    private retryDelay;
+    /**
+     * Creates a new HttpClient instance.
+     * @param config - SDK configuration including baseUrl, timeout, retry settings, and fetch implementation.
+     * @param tokenManager - Token manager for session persistence.
+     * @param logger - Optional logger instance for request/response debugging.
+     */
+    constructor(config: ResultConfig, tokenManager?: TokenManager, logger?: Logger);
+    /**
+     * Builds a full URL from a path and optional query parameters.
+     * Normalizes PostgREST select parameters for proper syntax.
+     */
+    private buildUrl;
+    /** Checks if an HTTP status code is eligible for retry (5xx server errors). */
+    private isRetryableStatus;
+    /**
+     * Computes the delay before the next retry using exponential backoff with jitter.
+     * @param attempt - The current retry attempt number (1-based).
+     * @returns Delay in milliseconds.
+     */
+    private computeRetryDelay;
+    private shouldRefreshAccessToken;
+    private fetchWithRetry;
+    /**
+     * Performs an HTTP request with automatic retry and timeout handling.
+     * Retries on network errors and 5xx server errors with exponential backoff.
+     * Client errors (4xx) and timeouts are thrown immediately without retry.
+     * @param method - HTTP method (GET, POST, PUT, PATCH, DELETE).
+     * @param path - API path relative to the base URL.
+     * @param options - Optional request configuration including headers, body, and query params.
+     * @returns Parsed response data.
+     * @throws {ResultError} On timeout, network failure, or HTTP error responses.
+     */
+    private handleRequest;
+    request<T>(method: string, path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Performs an SDK-configured fetch and returns the raw Response.
+     * This is used by clients such as postgrest-js that need to own response
+     * parsing while still sharing SDK auth and refresh behavior.
+     */
+    rawFetch(input: RequestInfo | URL, init?: RequestInit, options?: {
+        skipAuthRefresh?: boolean;
+    }): Promise<Response>;
+    /** Performs a GET request. */
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** Performs a POST request with an optional JSON body. */
+    post<T>(path: string, body?: any, options?: RequestOptions): Promise<T>;
+    /** Performs a PUT request with an optional JSON body. */
+    put<T>(path: string, body?: any, options?: RequestOptions): Promise<T>;
+    /** Performs a PATCH request with an optional JSON body. */
+    patch<T>(path: string, body?: any, options?: RequestOptions): Promise<T>;
+    /** Performs a DELETE request. */
+    delete<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** Sets or clears the user authentication token for subsequent requests. */
+    setAuthToken(token: string | null): void;
+    setRefreshToken(token: string | null): void;
+    /** Returns the current default headers including the authorization header if set. */
+    getHeaders(): Record<string, string>;
+    refreshAccessToken(): Promise<AuthRefreshResponse>;
+    /** Returns a token safe to use for a new connection handshake. */
+    getValidAccessToken(leewaySeconds?: number): Promise<string | null>;
+    private refreshAndSaveSession;
+    private clearAuthSession;
+}
+
+/**
+ * AI Module for Result SDK
+ * Response format roughly matches OpenAI SDK for compatibility
+ *
+ * The backend handles all the complexity of different AI providers
+ * and returns a unified format. This SDK transforms responses to match OpenAI-like format.
+ */
+
+interface ChatCompletionUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface ChatCompletionChoice {
+    index: number;
+    message: {
+        role: "assistant";
+        content: string;
+        tool_calls?: ToolCall[];
+        annotations?: Annotation[];
+    };
+    finish_reason: "stop" | "tool_calls";
+}
+interface ChatCompletion {
+    id: string;
+    object: "chat.completion";
+    created: number;
+    model?: string;
+    choices: ChatCompletionChoice[];
+    usage: ChatCompletionUsage;
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: "chat.completion.chunk";
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: {
+            content?: string;
+            tool_calls?: ToolCall[];
+            /** Web-search/file citations; arrives in a trailing chunk. */
+            annotations?: Annotation[];
+        };
+        finish_reason: "tool_calls" | null;
+    }[];
+    /** Token usage; arrives in a trailing chunk with empty choices. */
+    usage?: ChatCompletionUsage;
+}
+interface EmbeddingsResult {
+    object: "list";
+    data: EmbeddingObject[];
+    model?: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}
+interface ImageGenerationResult {
+    created: number;
+    data: {
+        b64_json?: string;
+        content?: string;
+    }[];
+    usage?: {
+        total_tokens: number;
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+declare class AI {
+    readonly chat: Chat;
+    readonly images: Images;
+    readonly embeddings: Embeddings;
+    constructor(http: HttpClient);
+}
+declare class Chat {
+    readonly completions: ChatCompletions;
+    constructor(http: HttpClient);
+}
+declare class ChatCompletions {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a chat completion - OpenAI-like response format
+     *
+     * @example
+     * ```typescript
+     * // Non-streaming
+     * const completion = await client.ai.chat.completions.create({
+     *   model: 'openai/gpt-4o-mini',
+     *   messages: [{ role: 'user', content: 'Hello!' }]
+     * });
+     * console.log(completion.choices[0].message.content);
+     *
+     * // With images. google/gemini-2.5-flash is the verified multimodal
+     * // model (openai/gpt-4o and gpt-4o-mini also accept images, but audio
+     * // requires gemini). URLs and base64 data URIs both work.
+     * const response = await client.ai.chat.completions.create({
+     *   model: 'google/gemini-2.5-flash',
+     *   messages: [{
+     *     role: 'user',
+     *     content: [
+     *       { type: 'text', text: 'What is in this image?' },
+     *       { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }
+     *     ]
+     *   }]
+     * });
+     *
+     * // With audio. Base64 data in wav/mp3/aiff/aac/ogg/flac/m4a only -
+     * // browser MediaRecorder's webm/opus is rejected; record PCM via the
+     * // Web Audio API and encode a 16 kHz mono WAV instead.
+     * const audioResponse = await client.ai.chat.completions.create({
+     *   model: 'google/gemini-2.5-flash',
+     *   messages: [{
+     *     role: 'user',
+     *     content: [
+     *       { type: 'text', text: 'Transcribe this recording' },
+     *       { type: 'input_audio', input_audio: { data: base64Wav, format: 'wav' } }
+     *     ]
+     *   }]
+     * });
+     *
+     * // With web search. Non-streaming: citations arrive on
+     * // response.choices[0].message.annotations. Streaming: they arrive in a
+     * // trailing chunk as chunk.choices[0].delta.annotations.
+     * const searchResponse = await client.ai.chat.completions.create({
+     *   model: 'openai/gpt-4o-mini',
+     *   messages: [{ role: 'user', content: 'What are the latest news about AI?' }],
+     *   webSearch: { enabled: true, maxResults: 5 }
+     * });
+     *
+     * // Streaming - returns async iterable
+     * const stream = await client.ai.chat.completions.create({
+     *   model: 'openai/gpt-4o-mini',
+     *   messages: [{ role: 'user', content: 'Tell me a story' }],
+     *   stream: true
+     * });
+     *
+     * for await (const chunk of stream) {
+     *   if (chunk.choices[0]?.delta?.content) {
+     *     process.stdout.write(chunk.choices[0].delta.content);
+     *   }
+     * }
+     * ```
+     */
+    create(params: ChatCompletionRequest & {
+        stream: true;
+    }): Promise<AsyncIterableIterator<ChatCompletionChunk>>;
+    create(params: ChatCompletionRequest & {
+        stream?: false;
+    }): Promise<ChatCompletion>;
+    create(params: ChatCompletionRequest): Promise<ChatCompletion | AsyncIterableIterator<ChatCompletionChunk>>;
+    /**
+     * Parse SSE stream into async iterable of OpenAI-like chunks
+     */
+    private parseSSEStream;
+}
+declare class Embeddings {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create embeddings for text input - OpenAI-like response format
+     *
+     * @example
+     * ```typescript
+     * // Single text input
+     * const response = await client.ai.embeddings.create({
+     *   model: 'openai/text-embedding-3-small',
+     *   input: 'Hello world'
+     * });
+     * console.log(response.data[0].embedding); // number[]
+     *
+     * // Multiple text inputs
+     * const response = await client.ai.embeddings.create({
+     *   model: 'openai/text-embedding-3-small',
+     *   input: ['Hello world', 'Goodbye world']
+     * });
+     * response.data.forEach((item, i) => {
+     *   console.log(`Embedding ${i}:`, item.embedding.slice(0, 5)); // First 5 dimensions
+     * });
+     *
+     * // With custom dimensions (if supported by model)
+     * const response = await client.ai.embeddings.create({
+     *   model: 'openai/text-embedding-3-small',
+     *   input: 'Hello world',
+     *   dimensions: 256
+     * });
+     *
+     * // With base64 encoding format
+     * const response = await client.ai.embeddings.create({
+     *   model: 'openai/text-embedding-3-small',
+     *   input: 'Hello world',
+     *   encoding_format: 'base64'
+     * });
+     * ```
+     */
+    create(params: EmbeddingsRequest): Promise<EmbeddingsResult>;
+}
+declare class Images {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Generate images - OpenAI-like response format
+     *
+     * @example
+     * ```typescript
+     * // Text-to-image
+     * const response = await client.ai.images.generate({
+     *   model: 'dall-e-3',
+     *   prompt: 'A sunset over mountains',
+     * });
+     * console.log(response.data[0].b64_json);
+     *
+     * // Image-to-image (with input images)
+     * const response = await client.ai.images.generate({
+     *   model: 'stable-diffusion-xl',
+     *   prompt: 'Transform this into a watercolor painting',
+     *   images: [
+     *     { url: 'https://example.com/input.jpg' },
+     *     // or base64-encoded Data URI:
+     *     { url: 'data:image/jpeg;base64,/9j/4AAQ...' }
+     *   ]
+     * });
+     * ```
+     */
+    generate(params: ImageGenerationRequest): Promise<ImageGenerationResult>;
+}
+
+/**
+ * Auth module for Result SDK
+ * Handles authentication, sessions, profiles, and email verification
+ */
+
+interface AuthOptions {
+    isServerMode?: boolean;
+    detectOAuthCallback?: boolean;
+}
+type OAuthSignInOptions = {
+    redirectTo: string;
+    additionalParams?: Record<string, string>;
+    skipBrowserRedirect?: boolean;
+};
+type OAuthSignInLegacyOptions = OAuthSignInOptions & {
+    provider: OAuthProvidersSchema | string;
+};
+/**
+ * Authentication client.
+ *
+ * Session model: the refresh token lives in an httpOnly cookie set by the
+ * backend (plus a CSRF cookie); the access token is held in memory and
+ * refreshed from that cookie. Nothing auth-related is written to
+ * localStorage, so an empty localStorage does NOT mean the user is signed
+ * out. Check state with getCurrentUser() or onAuthStateChange(), never by
+ * reading browser storage.
+ */
+declare class Auth {
+    private http;
+    private tokenManager;
+    private options;
+    private authCallbackHandled;
+    constructor(http: HttpClient, tokenManager: TokenManager, options?: AuthOptions);
+    private isServerMode;
+    /** Subscribe to SDK authentication state changes. */
+    onAuthStateChange(callback: AuthStateChangeCallback): () => void;
+    /**
+     * Save session from API response
+     * Handles token storage, CSRF token, and HTTP auth header
+     */
+    private saveSessionFromResponse;
+    /**
+     * Detect and handle OAuth callback parameters in URL
+     * Supports the PKCE flow (OAuth callback code in the URL)
+     */
+    private detectAuthCallback;
+    signUp(request: CreateUserRequest): Promise<{
+        data: CreateUserResponse | null;
+        error: ResultError | null;
+    }>;
+    signInWithPassword(request: CreateSessionRequest): Promise<{
+        data: CreateSessionResponse | null;
+        error: ResultError | null;
+    }>;
+    signOut(): Promise<{
+        error: ResultError | null;
+    }>;
+    /**
+     * Sign in with OAuth provider using PKCE flow
+     */
+    signInWithOAuth(provider: OAuthProvidersSchema | string, options: OAuthSignInOptions): Promise<{
+        data: {
+            url?: string;
+            provider?: string;
+            codeVerifier?: string;
+        };
+        error: ResultError | null;
+    }>;
+    /**
+     * @deprecated Use signInWithOAuth(provider, { redirectTo, additionalParams, skipBrowserRedirect }).
+     */
+    signInWithOAuth(options: OAuthSignInLegacyOptions): Promise<{
+        data: {
+            url?: string;
+            provider?: string;
+            codeVerifier?: string;
+        };
+        error: ResultError | null;
+    }>;
+    /**
+     * Exchange OAuth authorization code for tokens (PKCE flow)
+     * Called automatically on initialization when the OAuth callback code is in the URL
+     */
+    exchangeOAuthCode(code: string, codeVerifier?: string): Promise<{
+        data: CreateSessionResponse | null;
+        error: ResultError | null;
+    }>;
+    /**
+     * Sign in with an ID token from a native SDK (Google One Tap, etc.)
+     * Use this for native mobile apps or Google One Tap on web.
+     *
+     * @param credentials.provider - The identity provider (currently only 'google' is supported)
+     * @param credentials.token - The ID token from the native SDK
+     */
+    signInWithIdToken(credentials: {
+        provider: "google";
+        token: string;
+    }): Promise<{
+        data: CreateSessionResponse | null;
+        error: ResultError | null;
+    }>;
+    /**
+     * Refresh the current auth session.
+     *
+     * Browser mode:
+     * - Uses httpOnly refresh cookie and optional CSRF header.
+     *
+     * Legacy server mode (`isServerMode: true`):
+     * - Uses mobile auth flow and requires `refreshToken` in request body.
+     *
+     * SSR apps should prefer `createRefreshAuthRouter()` / `refreshAuth()` from
+     * `@resultdev/sdk/ssr`.
+     */
+    refreshSession(options?: {
+        refreshToken?: string;
+    }): Promise<{
+        data: RefreshSessionResponse | null;
+        error: ResultError | null;
+    }>;
+    /**
+     * Get current user, automatically waits for pending OAuth callback
+     */
+    getCurrentUser(): Promise<{
+        data: {
+            user: UserSchema | null;
+        };
+        error: ResultError | null;
+    }>;
+    getProfile(userId: string): Promise<{
+        data: GetProfileResponse | null;
+        error: ResultError | null;
+    }>;
+    setProfile(profile: Record<string, unknown>): Promise<{
+        data: GetProfileResponse | null;
+        error: ResultError | null;
+    }>;
+    resendVerificationEmail(request: SendVerificationEmailRequest): Promise<{
+        data: {
+            success: boolean;
+            message: string;
+        } | null;
+        error: ResultError | null;
+    }>;
+    verifyEmail(request: VerifyEmailRequest): Promise<{
+        data: VerifyEmailResponse | null;
+        error: ResultError | null;
+    }>;
+    sendResetPasswordEmail(request: SendResetPasswordEmailRequest): Promise<{
+        data: {
+            success: boolean;
+            message: string;
+        } | null;
+        error: ResultError | null;
+    }>;
+    exchangeResetPasswordToken(request: ExchangeResetPasswordTokenRequest): Promise<{
+        data: ExchangeResetPasswordTokenResponse | null;
+        error: ResultError | null;
+    }>;
+    resetPassword(request: {
+        newPassword: string;
+        otp: string;
+    }): Promise<{
+        data: ResetPasswordResponse | null;
+        error: ResultError | null;
+    }>;
+    getPublicAuthConfig(): Promise<{
+        data: GetPublicAuthConfigResponse | null;
+        error: ResultError | null;
+    }>;
+}
+
+/**
+ * Database client using postgrest-js
+ * Drop-in replacement with FULL PostgREST capabilities
+ */
+declare class Database {
+    private postgrest;
+    constructor(httpClient: HttpClient, defaultSchema?: string);
+    /**
+     * Select a non-default Postgres schema for the chained query. Maps to
+     * PostgREST's `Accept-Profile` (reads) / `Content-Profile` (writes) header.
+     * The schema must be exposed by the backend.
+     *
+     * @example
+     * const { data } = await client.database
+     *   .schema('analytics')
+     *   .from('events')
+     *   .select('*');
+     *
+     * @example
+     * await client.database.schema('analytics').rpc('rollup', { day: '2026-01-01' });
+     */
+    schema(schemaName: string): PostgrestClient<any, any, string, any>;
+    /**
+     * Create a query builder for a table
+     *
+     * @example
+     * // Basic query
+     * const { data, error } = await client.database
+     *   .from('posts')
+     *   .select('*')
+     *   .eq('user_id', userId);
+     *
+     * // With count (Supabase style!)
+     * const { data, error, count } = await client.database
+     *   .from('posts')
+     *   .select('*', { count: 'exact' })
+     *   .range(0, 9);
+     *
+     * // Just get count, no data
+     * const { count } = await client.database
+     *   .from('posts')
+     *   .select('*', { count: 'exact', head: true });
+     *
+     * // Complex queries with OR
+     * const { data } = await client.database
+     *   .from('posts')
+     *   .select('*, users!inner(*)')
+     *   .or('status.eq.active,status.eq.pending');
+     *
+     * // All features work:
+     * - Nested selects
+     * - Foreign key expansion
+     * - OR/AND/NOT conditions
+     * - Count with head
+     * - Range pagination
+     * - Upserts
+     */
+    from(table: string): _supabase_postgrest_js.PostgrestQueryBuilder<any, any, any, string, unknown>;
+    /**
+     * Call a PostgreSQL function (RPC)
+     *
+     * @example
+     * // Call a function with parameters
+     * const { data, error } = await client.database
+     *   .rpc('get_user_stats', { user_id: 123 });
+     *
+     * // Call a function with no parameters
+     * const { data, error } = await client.database
+     *   .rpc('get_all_active_users');
+     *
+     * // With options (head, count, get)
+     * const { data, count } = await client.database
+     *   .rpc('search_posts', { query: 'hello' }, { count: 'exact' });
+     */
+    rpc(fn: string, args?: Record<string, unknown>, options?: {
+        head?: boolean;
+        get?: boolean;
+        count?: "exact" | "planned" | "estimated";
+    }): _supabase_postgrest_js.PostgrestFilterBuilder<any, any, any, any, string, null, "RPC">;
+}
+
+/**
+ * Emails client for sending custom emails
+ *
+ * @example
+ * ```typescript
+ * // Send a simple email
+ * const { data, error } = await client.emails.send({
+ *   to: 'user@example.com',
+ *   subject: 'Welcome!',
+ *   html: '<h1>Welcome to our platform</h1>'
+ * });
+ *
+ * if (error) {
+ *   console.error('Failed to send:', error.message);
+ *   return;
+ * }
+ * // Email sent successfully - data is {} (empty object)
+ *
+ * // Send to multiple recipients with CC
+ * const { data, error } = await client.emails.send({
+ *   to: ['user1@example.com', 'user2@example.com'],
+ *   cc: 'manager@example.com',
+ *   subject: 'Team Update',
+ *   html: '<p>Here is the latest update...</p>',
+ *   replyTo: 'support@example.com'
+ * });
+ * ```
+ */
+declare class Emails {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Send a custom HTML email
+     * @param options Email options including recipients, subject, and HTML content
+     */
+    send(options: SendRawEmailRequest): Promise<{
+        data: SendEmailResponse | null;
+        error: ResultError | null;
+    }>;
+}
+
+interface FunctionInvokeOptions {
+    /**
+     * The body of the request: a JSON-serializable value, or any fetch
+     * BodyInit (FormData, Blob, string, ...)
+     */
+    body?: BodyInit | JsonRequestBody;
+    /**
+     * Custom headers to send with the request
+     */
+    headers?: Record<string, string>;
+    /**
+     * HTTP method (default: POST)
+     */
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+}
+/**
+ * Edge Functions client for invoking serverless functions.
+ *
+ * @example
+ * ```typescript
+ * const { data, error } = await client.functions.invoke('hello-world', {
+ *   body: { name: 'World' }
+ * });
+ * ```
+ */
+declare class Functions {
+    private http;
+    private functionsUrl;
+    constructor(http: HttpClient, functionsUrl?: string);
+    /**
+     * Derive the legacy subhosting URL from the base URL
+     * ({appKey}.{region}.<domain> -> {appKey}.functions.<domain>).
+     * Only used to recognize when a configured functionsUrl still points at
+     * the local deployment, so in-process dispatch can short-circuit it.
+     */
+    private static deriveSubhostingUrl;
+    /**
+     * Build a Request for in-process dispatch. The host is a non-routable
+     * placeholder; the router only reads pathname.
+     */
+    private buildInProcessRequest;
+    /**
+     * Invoke an Edge Function.
+     *
+     * Dispatch order:
+     * 1. If the platform's in-process dispatch hook is present and no foreign
+     *    functionsUrl is configured, call it directly (function-to-function
+     *    calls inside the same deployment).
+     * 2. If a custom functionsUrl is configured, try it; fall back to the
+     *    proxy path on 404 or network failure.
+     * 3. Otherwise, invoke through the main host's /functions/{slug} proxy.
+     *    This route works from browsers too (correct CORS).
+     *
+     * @param slug The function slug to invoke
+     * @param options Request options
+     */
+    invoke<T = any>(slug: string, options?: FunctionInvokeOptions): Promise<{
+        data: T | null;
+        error: ResultError | null;
+    }>;
+}
+
+type ConnectionState = "disconnected" | "connecting" | "connected";
+type EventCallback<T = unknown> = (payload: T) => void;
+/**
+ * Socket.IO realtime client. Authentication is evaluated for every handshake,
+ * while an established socket remains authenticated until it disconnects.
+ */
+declare class Realtime {
+    private baseUrl;
+    private tokenManager;
+    private anonKey?;
+    private getValidAccessToken;
+    private socket;
+    private connectPromise;
+    private connectionAttempt;
+    private nextConnectionAttemptId;
+    private subscriptions;
+    private eventListeners;
+    constructor(baseUrl: string, tokenManager: TokenManager, anonKey?: string | undefined, getValidAccessToken?: () => Promise<string | null>);
+    private notifyListeners;
+    private getHandshakeToken;
+    connect(): Promise<void>;
+    disconnect(): void;
+    private reconnectForAuthChange;
+    private handleDisconnect;
+    private resubscribeChannels;
+    private requestSubscription;
+    private settleSubscription;
+    private applyPresenceEvent;
+    get isConnected(): boolean;
+    get connectionState(): ConnectionState;
+    get socketId(): string | undefined;
+    subscribe(channel: string): Promise<SubscribeResponse>;
+    unsubscribe(channel: string): void;
+    /**
+     * Publish an event to a channel.
+     *
+     * Delivery notes (verified against a live backend):
+     * - Payload fields arrive spread onto the received message itself, next to
+     *   `meta` - not nested under a `payload` key. Publishing `{ text: "hi" }`
+     *   means receivers read `msg.text`.
+     * - The sender receives its own message too. Deduplicate with
+     *   `msg.meta.messageId` (or `msg.meta.senderId`) if you also update local
+     *   state optimistically.
+     */
+    publish<T = unknown>(channel: string, event: string, payload: T): Promise<void>;
+    /**
+     * Listen for an event by name, across all subscribed channels.
+     * Filter by channel inside the callback: `msg.meta.channel` always matches
+     * the exact name passed to subscribe() (the SDK strips the server's
+     * transport prefix before delivery).
+     */
+    on<T = SocketMessage>(event: string, callback: EventCallback<T>): void;
+    off<T = SocketMessage>(event: string, callback: EventCallback<T>): void;
+    once<T = SocketMessage>(event: string, callback: EventCallback<T>): void;
+    getSubscribedChannels(): string[];
+    getPresenceState(channel: string): PresenceMember[];
+}
+
+/**
+ * Storage module for Result SDK
+ * Handles file uploads, downloads, and bucket management
+ */
+
+interface StorageResponse<T> {
+    data: T | null;
+    error: ResultError | null;
+}
+/**
+ * Storage bucket operations
+ */
+declare class StorageBucket {
+    private bucketName;
+    private http;
+    constructor(bucketName: string, http: HttpClient);
+    /**
+     * Upload a file to a specific key.
+     * Uses the upload strategy from the backend (direct or presigned).
+     * Standard PUT semantics: uploading to an existing key replaces the
+     * current object in place.
+     * @param path - The object key/path
+     * @param file - File or Blob to upload
+     */
+    upload(path: string, file: File | Blob): Promise<StorageResponse<StorageFileSchema>>;
+    /**
+     * Upload a file under an automatically generated, collision-free key.
+     * The key is derived client-side from the filename (sanitized base +
+     * timestamp + random suffix) and uploaded through the standard
+     * {@link upload} path, so repeated uploads of the same file never
+     * overwrite each other. Reads the filename structurally to avoid assuming
+     * a global `File` (which Node 18 does not expose).
+     * @param file - File or Blob to upload
+     */
+    uploadAuto(file: File | Blob): Promise<StorageResponse<StorageFileSchema>>;
+    /**
+     * Internal method to handle presigned URL uploads
+     */
+    private uploadWithPresignedUrl;
+    /**
+     * Download a file
+     * Uses the download strategy from backend (direct or presigned)
+     * @param path - The object key/path
+     * Returns the file as a Blob
+     */
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: ResultError | null;
+    }>;
+    /**
+     * Get the public URL for an object in a public bucket.
+     *
+     * Pure string construction — no network call, no auth. The URL only resolves
+     * if the bucket is public; for private objects use {@link createSignedUrl}.
+     *
+     * @param path - The object key/path
+     * @returns `{ data: { publicUrl }, error }` — matches the external SDK pattern,
+     *   so `const { data } = getPublicUrl(path)` then `data.publicUrl`.
+     */
+    getPublicUrl(path: string): StorageResponse<{
+        publicUrl: string;
+    }>;
+    /**
+     * Resolve a download strategy (signed or direct URL) for an object with a
+     * caller-supplied TTL. Prefers the canonical GET route and falls back to the
+     * legacy POST alias so signed-URL creation still works against older backends
+     * that predate the GET route (they return 404/405 for it). A genuine
+     * "object not found" (STORAGE_NOT_FOUND) is not retried.
+     */
+    private requestDownloadStrategy;
+    /**
+     * Create a signed URL for an object.
+     *
+     * Returns a time-limited, credential-free URL that can be handed directly to
+     * a browser (`<img src>`), an email, or a third party — no SDK or session is
+     * needed to fetch it. Authorization is enforced when the URL is minted (the
+     * caller must be allowed to read the object), so the resulting link is a
+     * pre-authorized capability scoped to this one object until it expires.
+     *
+     * @param path - The object key/path
+     * @param expiresIn - Lifetime in seconds (default 3600 = 1h, max 604800 = 7d).
+     *   Honored for private buckets; public buckets return their long-lived URL.
+     */
+    createSignedUrl(path: string, expiresIn?: number): Promise<StorageResponse<{
+        signedUrl: string;
+        expiresAt: string | null;
+    }>>;
+    /**
+     * Create signed URLs for multiple objects in a single call.
+     *
+     * Each entry resolves independently: a failure on one key (not found / not
+     * permitted) is reported on that entry's `error` without failing the rest.
+     *
+     * @param paths - The object keys/paths
+     * @param expiresIn - Lifetime in seconds (default 3600 = 1h, max 604800 = 7d)
+     */
+    createSignedUrls(paths: string[], expiresIn?: number): Promise<StorageResponse<Array<{
+        path: string;
+        signedUrl: string | null;
+        error: string | null;
+    }>>>;
+    /**
+     * List objects in the bucket
+     * @param prefix - Filter by key prefix
+     * @param search - Search in file names
+     * @param limit - Maximum number of results (default: 100, max: 1000)
+     * @param offset - Number of results to skip
+     */
+    list(options?: {
+        prefix?: string;
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<StorageResponse<ListObjectsResponseSchema>>;
+    /** Delete a single file. */
+    remove(path: string): Promise<StorageResponse<{
+        message: string;
+    }>>;
+    /** Delete multiple files in a single request. */
+    remove(paths: string[]): Promise<StorageResponse<DeleteObjectsResponse>>;
+    /** Delete one or more files when the input type is not narrowed. */
+    remove(pathOrPaths: string | string[]): Promise<StorageResponse<{
+        message: string;
+    } | DeleteObjectsResponse>>;
+}
+/**
+ * Storage module for file operations
+ */
+declare class Storage {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get a bucket instance for operations
+     * @param bucketName - Name of the bucket
+     */
+    from(bucketName: string): StorageBucket;
+}
+
+type AccessTokenChangeEvent = typeof AuthChangeEvent.SIGNED_IN | typeof AuthChangeEvent.TOKEN_REFRESHED;
+/**
+ * Main Result SDK Client
+ *
+ * @example
+ * ```typescript
+ * import { ResultClient } from '@resultdev/sdk';
+ *
+ * const client = new ResultClient({
+ *   baseUrl: 'http://localhost:7130'
+ * });
+ *
+ * // Authentication
+ * const { data, error } = await client.auth.signUp({
+ *   email: 'user@example.com',
+ *   password: 'password123',
+ *   name: 'John Doe'
+ * });
+ *
+ * // Database operations
+ * const { data, error } = await client.database
+ *   .from('posts')
+ *   .select('*')
+ *   .eq('user_id', session.user.id)
+ *   .order('created_at', { ascending: false })
+ *   .limit(10);
+ *
+ * // Insert data
+ * const { data: newPost } = await client.database
+ *   .from('posts')
+ *   .insert({ title: 'Hello', content: 'World' })
+ *   .single();
+ *
+ * // Invoke edge functions
+ * const { data, error } = await client.functions.invoke('my-function', {
+ *   body: { message: 'Hello from SDK' }
+ * });
+ *
+ * // Enable debug logging
+ * const debugClient = new ResultClient({
+ *   baseUrl: 'http://localhost:7130',
+ *   debug: true
+ * });
+ * ```
+ */
+declare class ResultClient {
+    private http;
+    private tokenManager;
+    readonly auth: Auth;
+    readonly database: Database;
+    readonly storage: Storage;
+    readonly ai: AI;
+    readonly functions: Functions;
+    readonly realtime: Realtime;
+    readonly emails: Emails;
+    readonly analytics: Analytics;
+    readonly support: Support;
+    constructor(config?: ResultConfig);
+    /**
+     * Get the underlying HTTP client for custom requests
+     *
+     * @example
+     * ```typescript
+     * const httpClient = client.getHttpClient();
+     * const customData = await httpClient.get('/api/custom-endpoint');
+     * ```
+     */
+    getHttpClient(): HttpClient;
+    /**
+     * Set the access token used by every SDK surface. Updates both the HTTP
+     * client (database / storage / functions / AI / emails) and the realtime
+     * token manager. Pass `null` to sign out. By default a token replacement is
+     * treated as a sign-in boundary and reconnects realtime. Pass
+     * `AuthChangeEvent.TOKEN_REFRESHED` for a same-identity refresh to preserve a live socket; the
+     * refreshed token is then used at the next handshake.
+     *
+     * Use this when an external auth provider (Better Auth, Clerk, Auth0,
+     * WorkOS, Kinde, Stytch, …) issues the JWT and you need to keep the
+     * long-lived Result client in sync. Without this, you'd have to call
+     * `client.getHttpClient().setAuthToken(token)` AND reach into the private
+     * realtime token manager separately.
+     *
+     * @example
+     * ```typescript
+     * import { AuthChangeEvent } from '@resultdev/sdk';
+     *
+     * // Refresh a third-party-issued JWT periodically
+     * const { token } = await fetch('/api/backend-token').then((r) => r.json());
+     * client.setAccessToken(token, AuthChangeEvent.TOKEN_REFRESHED);
+     *
+     * // Sign-out
+     * client.setAccessToken(null);
+     * ```
+     */
+    setAccessToken(token: string | null, event?: AccessTokenChangeEvent): void;
+}
+
+export { AI as A, type ChatCompletion as C, Database as D, Emails as E, type FunctionInvokeOptions as F, HttpClient as H, type ImageGenerationResult as I, Logger as L, ResultClient as R, Storage as S, type AccessTokenChangeEvent as a, Auth as b, AuthChangeEvent as c, type AuthStateChangeCallback as d, type ChatCompletionChoice as e, type ChatCompletionChunk as f, type ChatCompletionUsage as g, type ConnectionState as h, type EmbeddingsResult as i, type EventCallback as j, Functions as k, Realtime as l, StorageBucket as m, type StorageResponse as n };