@backflow.sdk/client 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1845 @@
+interface RequestContext {
+    method: string;
+    path: string;
+    params?: Record<string, unknown>;
+    body?: unknown;
+    startTime: number;
+}
+interface ResponseContext extends RequestContext {
+    status: number;
+    duration: number;
+    response?: unknown;
+    error?: Error;
+}
+type RequestMiddleware = (ctx: RequestContext) => RequestContext | void | Promise<RequestContext | void>;
+type ResponseMiddleware = (ctx: ResponseContext) => void | Promise<void>;
+interface BackflowMiddleware {
+    onRequest?: RequestMiddleware;
+    onResponse?: ResponseMiddleware;
+}
+interface BackflowConfig {
+    clientKey?: string;
+    getAuthToken?: () => Promise<string>;
+    endpoint?: string;
+    middleware?: BackflowMiddleware;
+    debug?: boolean;
+}
+interface RequestOptions extends Omit<RequestInit, "body"> {
+    params?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}
+type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
+interface BackflowResponse<T> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+interface BackflowError extends Error {
+    status: number;
+    code?: string;
+    details?: unknown;
+}
+interface SSESubscribeHandlers<T = unknown> {
+    onConnected?: () => void;
+    onComplete?: (data: T) => void;
+    onFailed?: (error: string) => void;
+    onProgress?: (progress: number, message?: string) => void;
+    onWarning?: (message: string) => void;
+    onError?: (error: Event) => void;
+}
+type DatabaseProvider = 'supabase' | 'firebase' | 'sqlite' | 'custom' | string;
+type DatabaseFilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in' | 'is';
+interface DatabaseFilter {
+    column: string;
+    operator: DatabaseFilterOperator;
+    value: unknown;
+}
+interface ChainedDatabaseQuery {
+    table: string;
+    operation?: 'select' | 'insert' | 'update' | 'delete';
+    filters?: DatabaseFilter[];
+    data?: Record<string, unknown>;
+    select?: string;
+    single?: boolean;
+    order?: {
+        column: string;
+        ascending?: boolean;
+    };
+    limit?: number;
+    offset?: number;
+    as: string;
+}
+interface DatabaseIntegrationAction {
+    type: 'database';
+    action: 'select' | 'insert' | 'update' | 'upsert' | 'delete';
+    table: string;
+    data?: Record<string, unknown>;
+    filters?: DatabaseFilter[];
+    select?: string;
+    orderBy?: {
+        column: string;
+        direction?: 'asc' | 'desc';
+    };
+    limit?: number;
+    offset?: number;
+    single?: boolean;
+    provider?: DatabaseProvider;
+    or?: Omit<DatabaseIntegrationAction, 'type' | 'action' | 'or' | 'chain'>[];
+    chain?: ChainedDatabaseQuery[];
+    saveResponseAs?: string;
+}
+
+declare class BackflowClient {
+    private config;
+    private tokenCache;
+    private tokenPromise;
+    constructor(config: BackflowConfig);
+    private exchangeApiKeyForToken;
+    private getToken;
+    get endpoint(): string;
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    put<T>(path: string, body?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    patch<T>(path: string, body?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    upload<T>(path: string, files: File | File[], metadata?: Record<string, string>): Promise<T>;
+    getRaw(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<Response>;
+    createWebSocket(room: string): WebSocket;
+    subscribeSSE<T = unknown>(path: string, handlers: SSESubscribeHandlers<T>): () => void;
+}
+
+declare class AgentAnalysisResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Retrieve cached analysis results from a previous scan */
+    get(executionId: string): Promise<unknown>;
+    /** Apply fixes from cached analysis. In hybrid mode, returns fix instructions for local MCP execution. */
+    createApply(executionId: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class AnalyticsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get high-level analytics overview (tenant-isolated) */
+    list(): Promise<unknown>;
+    /** Get endpoint statistics (tenant-isolated) */
+    listEndpoints(): Promise<unknown>;
+    /** Get recent errors (tenant-isolated) */
+    listErrors(): Promise<unknown>;
+    /** Get device type breakdown (tenant-isolated) */
+    listDevices(): Promise<unknown>;
+    /** Get geographic distribution of requests (tenant-isolated) */
+    listGeography(): Promise<unknown>;
+    /** Get time series data (tenant-isolated) */
+    listTimeseries(): Promise<unknown>;
+    /** Get endpoints that haven't been called recently (tenant-isolated) */
+    listUnusedEndpoints(): Promise<unknown>;
+}
+
+interface BatchImportOptions {
+    entity: string;
+    records: Record<string, unknown>[];
+    mode?: 'insert' | 'upsert';
+    upsertKey?: string;
+    chunkSize?: number;
+    async?: boolean;
+}
+interface BatchImportResult {
+    jobId?: string;
+    status: 'completed' | 'partial' | 'failed' | 'queued';
+    total: number;
+    successful: number;
+    failed: number;
+    errors?: Array<{
+        index: number;
+        error: string;
+        record?: unknown;
+    }>;
+    message?: string;
+}
+interface BatchJob {
+    id: string;
+    entity: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    total: number;
+    processed: number;
+    successful: number;
+    failed: number;
+    errors: Array<{
+        index: number;
+        error: string;
+    }>;
+    progress: number;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
+interface BatchExportOptions {
+    entity: string;
+    filters?: Array<{
+        field: string;
+        operator: string;
+        value: unknown;
+    }>;
+    select?: string[];
+    limit?: number;
+}
+interface BatchExportResult {
+    entity: string;
+    count: number;
+    records: Record<string, unknown>[];
+}
+declare class BatchResource {
+    private client;
+    constructor(client: BackflowClient);
+    /**
+     * Import records in batch to a specified entity
+     *
+     * @param options - Import options including entity name, records, and mode
+     * @returns Import result with success/failure counts
+     *
+     * @example
+     * // Insert new records
+     * const result = await bf.batch.import({
+     *   entity: 'products',
+     *   records: [
+     *     { name: 'Product 1', price: 100 },
+     *     { name: 'Product 2', price: 200 },
+     *   ],
+     * });
+     *
+     * @example
+     * // Upsert records (update existing, insert new)
+     * const result = await bf.batch.import({
+     *   entity: 'products',
+     *   records: products,
+     *   mode: 'upsert',
+     *   upsertKey: 'sku',
+     * });
+     *
+     * @example
+     * // Large async import (>1000 records or explicit async)
+     * const result = await bf.batch.import({
+     *   entity: 'orders',
+     *   records: largeDataset,
+     *   async: true,
+     * });
+     * // Check status
+     * const status = await bf.batch.getJob(result.jobId!);
+     */
+    import(options: BatchImportOptions): Promise<BatchImportResult>;
+    /**
+     * Get status of a batch import job
+     *
+     * @param jobId - The job ID returned from async import
+     * @returns Job status including progress and error details
+     */
+    getJob(jobId: string): Promise<BatchJob>;
+    /**
+     * List batch jobs for the current tenant
+     *
+     * @returns List of recent batch jobs
+     */
+    listJobs(): Promise<{
+        jobs: BatchJob[];
+    }>;
+    /**
+     * Export records from an entity
+     *
+     * @param options - Export options including entity name and optional filters
+     * @returns Exported records
+     *
+     * @example
+     * // Export all records
+     * const result = await bf.batch.export({ entity: 'products' });
+     *
+     * @example
+     * // Export with filters
+     * const result = await bf.batch.export({
+     *   entity: 'orders',
+     *   filters: [
+     *     { field: 'status', operator: 'eq', value: 'completed' },
+     *   ],
+     *   select: ['id', 'total', 'created_at'],
+     *   limit: 5000,
+     * });
+     */
+    export(options: BatchExportOptions): Promise<BatchExportResult>;
+    /**
+     * Poll job until completion
+     *
+     * @param jobId - The job ID to poll
+     * @param intervalMs - Polling interval in milliseconds (default: 1000)
+     * @param timeoutMs - Timeout in milliseconds (default: 300000 = 5 minutes)
+     * @returns Final job status
+     */
+    waitForJob(jobId: string, intervalMs?: number, timeoutMs?: number): Promise<BatchJob>;
+}
+
+interface TenantAsset {
+    id: string;
+    bucket: string;
+    path: string;
+    url: string;
+    size: number;
+    content_type: string;
+    entity_type: string;
+    entity_id: string;
+    uploaded_by?: string;
+    uploaded_at: string;
+    tenant_id?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface AssetListParams {
+    limit?: number;
+    offset?: number;
+    entityType?: string;
+    entityId?: string;
+    tenant?: string;
+}
+interface AssetListResponse {
+    data: TenantAsset[];
+    count: number;
+    limit: number;
+    offset: number;
+}
+interface AssetStatsResponse {
+    data: {
+        totalFiles: number;
+        totalSizeBytes: number;
+        totalSizeMB: number;
+        byContentType: Record<string, number>;
+        byEntityType: Record<string, number>;
+    };
+}
+declare class AssetsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** List tenant assets with optional filtering */
+    list(params?: AssetListParams): Promise<AssetListResponse>;
+    /** Get asset by ID */
+    get(id: string): Promise<{
+        data: TenantAsset;
+    }>;
+    /** Delete asset by ID */
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+    /** Get asset storage statistics */
+    stats(tenant?: string): Promise<AssetStatsResponse>;
+}
+
+declare class CacheResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get cache statistics including hit rate, memory usage, and item count */
+    list(): Promise<unknown>;
+    /** Clear all items from the cache and reset statistics */
+    delete(): Promise<unknown>;
+    /** Invalidate all cache entries that match a given pattern */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Reset cache hit/miss statistics while preserving cached data */
+    createResetStats(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class DefaultResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** GET /tenant/debug/raw-query */
+    list(): Promise<unknown>;
+}
+
+declare class DeploymentResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get deployment information */
+    list(): Promise<unknown>;
+    /** Get server information */
+    listServer(): Promise<unknown>;
+    /** Get full deployment status */
+    listStatus(): Promise<unknown>;
+    /** Get Cloud Run service URL */
+    listUrl(): Promise<unknown>;
+    /** Server-Sent Events (SSE) stream for real-time deployment status updates. Sends periodic status updates and heartbeats. */
+    listStream(): Promise<unknown>;
+    /** Filtered Server-Sent Events (SSE) stream for specific deployment event types. Filter by status, server, or url events. */
+    listEvents(): Promise<unknown>;
+}
+
+declare class EmbeddingsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List all embedded documents with chunk counts and metadata */
+    list(): Promise<unknown>;
+    /** Upload and process a document for vector embeddings with automatic chunking. Supports various content types (code, documentation, articles) with optimized chunking strategies for RAG. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Search within a specific document using semantic similarity. Performs vector search within document chunks. */
+    search(documentId: string): Promise<unknown>;
+    /** Search across all embedded documents using semantic similarity */
+    listSearch(): Promise<unknown>;
+    /** Delete all chunks and embeddings for a document. Removes the document from the vector store. */
+    delete(documentId: string): Promise<unknown>;
+    /** Process multiple documents (up to 50) for vector embeddings in a single batch. Supports both raw text and file references (PDF, DOCX, TXT, MD). Uses 3 concurrent processing threads. */
+    createBatch(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class FeedbackResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Submit feedback for a workflow execution. Used to optimize and improve workflow performance based on user ratings and suggestions. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get feedback trends and analytics. Analyzes workflow feedback to identify patterns and areas for improvement. */
+    list(): Promise<unknown>;
+}
+
+declare class FilesResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Upload a single file with entity association and tenant isolation */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Upload multiple files with entity association and tenant isolation */
+    createUploadMultiple(data: Record<string, unknown>): Promise<unknown>;
+    /** List files for an entity with pagination */
+    get(entityType: string, entityId: string): Promise<unknown>;
+    /** Delete all files for an entity */
+    delete(entityType: string, entityId: string): Promise<unknown>;
+    /** Download file via secure signed URL redirect (5 minute expiry) */
+    getDownload(bucket: string, path: string): Promise<unknown>;
+    /** Get a signed URL for file access (max 30 seconds expiry) */
+    getSignedUrl(bucket: string, path: string): Promise<unknown>;
+    /** Delete a file from storage */
+    deleteDELETE(bucket: string, path: string): Promise<unknown>;
+    /** Upload JSON content to storage */
+    createUploadJson(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class GithubResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get GitHub repositories for a user */
+    get(username: string): Promise<unknown>;
+    /** Get file or directory contents from a GitHub repository */
+    getContent(owner: string, repo: string, path: string): Promise<unknown>;
+    /** Create or update a file in a GitHub repository */
+    updateContent(owner: string, repo: string, path: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete a file from a GitHub repository */
+    deleteContent(owner: string, repo: string, path: string): Promise<unknown>;
+    /** Compare two commits and view the diff */
+    getCompare(owner: string, repo: string, basehead: string): Promise<unknown>;
+    /** Get a single commit with its changes */
+    getCommit(owner: string, repo: string, ref: string): Promise<unknown>;
+    /** List commits in a repository */
+    commits(owner: string, repo: string): Promise<unknown>;
+    /** Get pull request details */
+    getPull(owner: string, repo: string, pull_number: string): Promise<unknown>;
+    /** List files changed in a pull request with diffs */
+    files(owner: string, repo: string, pull_number: string): Promise<unknown>;
+}
+
+declare class GoalsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Configure goal evaluation rules for a workflow. Sets KPIs, success criteria, and evaluation parameters. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Manually trigger goal evaluation for a workflow. Evaluates workflow performance against configured KPIs and success criteria. */
+    createEvaluate(workflowId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get evaluation history for a workflow. Returns all historical goal evaluation records. */
+    get(workflowId: string): Promise<unknown>;
+    /** Start scheduled goal evaluation. Automatically evaluates all active workflows at specified intervals. */
+    createStart(data: Record<string, unknown>): Promise<unknown>;
+    /** Stop scheduled goal evaluation. Cancels automatic workflow evaluations. */
+    createStop(data: Record<string, unknown>): Promise<unknown>;
+    /** Evaluate all active workflows. Generates evaluation reports for all workflows with configured goals. */
+    createEvaluateAll(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class GoogleDriveResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** List files in Google Drive */
+    list(): Promise<unknown>;
+    /** Get file metadata from Google Drive */
+    get(fileId: string): Promise<unknown>;
+    /** Update file metadata (rename, move) */
+    patch(fileId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete a file from Google Drive */
+    delete(fileId: string): Promise<unknown>;
+    /** Download file content from Google Drive */
+    download(fileId: string): Promise<unknown>;
+    /** Search for PDF files in Google Drive */
+    listPdfs(): Promise<unknown>;
+}
+
+declare class JiraResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Search JIRA issues using JQL */
+    list(): Promise<unknown>;
+    /** Get JIRA issue details */
+    get(issueKey: string): Promise<unknown>;
+    /** Update a JIRA issue */
+    update(issueKey: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete a JIRA issue */
+    delete(issueKey: string): Promise<unknown>;
+    /** Create a new JIRA issue */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get available transitions for a JIRA issue */
+    transitions(issueKey: string): Promise<unknown>;
+    /** Transition a JIRA issue to new status */
+    createTransition(issueKey: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get comments for a JIRA issue */
+    comments(issueKey: string): Promise<unknown>;
+    /** Add comment to a JIRA issue */
+    createComment(issueKey: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Assign a JIRA issue to a user */
+    updateAssign(issueKey: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get all JIRA projects */
+    listProjects(): Promise<unknown>;
+    /** Get JIRA project details */
+    getProjects(projectKey: string): Promise<unknown>;
+    /** Get current authenticated JIRA user */
+    listMe(): Promise<unknown>;
+    /** Search JIRA users */
+    listSearch(): Promise<unknown>;
+    /** Get all JIRA issue types */
+    listIssueTypes(): Promise<unknown>;
+    /** Get all JIRA priority levels */
+    listPriorities(): Promise<unknown>;
+}
+
+declare class LlmResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** POST /llm/stream */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** GET /llm/models */
+    list(): Promise<unknown>;
+}
+
+declare class McpToolsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** List all available MCP tools from connected servers. Returns tools, connection status, and server information. */
+    list(): Promise<unknown>;
+    /** Execute a Model Context Protocol (MCP) tool. MCP tools provide external capabilities like file system access, database queries, and API calls to LLM workflows. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class PolarResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Create a Polar checkout session */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Retrieve a Polar checkout session */
+    get(checkoutId: string): Promise<unknown>;
+    /** Create a Polar subscription */
+    createSubscriptions(data: Record<string, unknown>): Promise<unknown>;
+    /** Cancel a Polar subscription */
+    delete(subscriptionId: string): Promise<unknown>;
+    /** List Polar products */
+    list(): Promise<unknown>;
+    /** Create a Polar product */
+    createProducts(data: Record<string, unknown>): Promise<unknown>;
+    /** Retrieve a Polar order */
+    getOrders(orderId: string): Promise<unknown>;
+    /** Create a Polar benefit */
+    createBenefits(data: Record<string, unknown>): Promise<unknown>;
+    /** Grant a Polar benefit to a customer */
+    createGrants(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class ProjectsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** List version history for a project with pagination and date range filter */
+    versions(id: string): Promise<unknown>;
+    /** Create a new project version record (Pro tier) */
+    createVersion(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete all versions for a project and their R2 files (parallel) */
+    deleteAllVersions(id: string): Promise<unknown>;
+    /** Get a specific version record */
+    getVersion(id: string, versionId: string): Promise<unknown>;
+    /** Delete a specific project version and its R2 files */
+    deleteVersion(id: string, versionId: string): Promise<unknown>;
+    /** Rollback project to a previous version (Pro tier) */
+    rollback(id: string, version: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Save project with parallel R2 uploads and Firestore updates */
+    updateSave(projectId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Save project and execute content as workflow */
+    saveAndRun(projectId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get project by ID */
+    get(id: string): Promise<unknown>;
+    /** Update project metadata (title, description, etc.) */
+    patch(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete project and all related files/versions (parallel) */
+    delete(id: string): Promise<unknown>;
+    /** List all shares for a project */
+    shares(id: string): Promise<unknown>;
+    /** Share a project with another user */
+    share(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Remove share access from a user */
+    deleteShare(id: string, userId: string): Promise<unknown>;
+    /** Get public project by ID (no auth required) */
+    public(projectId: string): Promise<unknown>;
+    /** Toggle project public/private status with optional email notification */
+    patchPublic(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** List all projects shared with the current user */
+    list(): Promise<unknown>;
+    /** Update project files (add/remove attached assets) */
+    patchFile(id: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class PublishResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Initialize publishing system - checks database setup */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Verify database migration was applied */
+    createVerify(data: Record<string, unknown>): Promise<unknown>;
+    /** Publish an entity (checks database readiness automatically) */
+    createEntity(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class QueuesResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all queues and their statistics (tenant-isolated) */
+    list(): Promise<unknown>;
+    /** Get statistics for a specific queue (tenant-isolated) */
+    stats(name: string): Promise<unknown>;
+    /** Get jobs from a queue (tenant-isolated) */
+    jobs(name: string): Promise<unknown>;
+    /** Add a job to the queue (with tenant isolation) */
+    createJob(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get a specific job (tenant-isolated) */
+    getJob(name: string, jobId: string): Promise<unknown>;
+    /** Retry a failed job (tenant-isolated) */
+    retry(name: string, jobId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Pause a queue (admin only - affects all tenants) */
+    pause(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Resume a paused queue (admin only - affects all tenants) */
+    resume(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Clean old jobs from queue (tenant-isolated) */
+    createClean(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get detailed performance metrics for a queue */
+    metrics(name: string): Promise<unknown>;
+}
+
+declare class SearchResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Fast search across an entity with configurable modes (exact, fuzzy, hybrid) */
+    get(entity: string): Promise<unknown>;
+    /** Index entity records for vector search */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Delete and reindex all records for an entity */
+    createReindex(data: Record<string, unknown>): Promise<unknown>;
+    /** Delete all indexed records for an entity */
+    delete(entity: string): Promise<unknown>;
+    /** Get search index statistics */
+    list(): Promise<unknown>;
+}
+
+declare class StripeResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Create a Stripe customer */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Create a Stripe payment intent */
+    createPaymentIntents(data: Record<string, unknown>): Promise<unknown>;
+    /** Create a Stripe subscription */
+    createSubscriptions(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class TeamsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all teams */
+    list(): Promise<unknown>;
+    /** Create a new team */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get team by ID */
+    get(id: string): Promise<unknown>;
+    /** Update team metadata (name, description, members) */
+    update(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete team */
+    delete(id: string): Promise<unknown>;
+    /** Get all projects for a team */
+    projects(id: string): Promise<unknown>;
+}
+
+declare class TenantWebhookReceiversResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** List webhook receivers */
+    list(): Promise<unknown>;
+    /** Create webhook receiver */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get webhook receiver */
+    get(id: string): Promise<unknown>;
+    /** Update webhook receiver */
+    update(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete webhook receiver */
+    delete(id: string): Promise<unknown>;
+}
+
+declare class TenantWebhooksResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** List webhooks */
+    list(): Promise<unknown>;
+    /** Create webhook */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get webhook */
+    get(id: string): Promise<unknown>;
+    /** Update webhook */
+    update(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete webhook */
+    delete(id: string): Promise<unknown>;
+}
+
+declare class ToolDiscoveryResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all registered tools including MCP, user-configured, and built-in tools */
+    list(): Promise<unknown>;
+    /** Search for tools using text query, category, tags, capabilities, and performance filters */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Search for tools using natural language semantic similarity */
+    createSemanticSearch(data: Record<string, unknown>): Promise<unknown>;
+    /** Use AI to automatically select appropriate tools based on a natural language goal */
+    createSelect(data: Record<string, unknown>): Promise<unknown>;
+    /** Get tool recommendations based on goal and historical performance data */
+    createRecommend(data: Record<string, unknown>): Promise<unknown>;
+    /** Get performance metrics (success rate, latency, usage) for a specific tool */
+    metrics(toolName: string): Promise<unknown>;
+    /** Index all registered tools for semantic search using embeddings */
+    createIndex(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class TrackingResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get MCP call statistics for the tenant */
+    list(): Promise<unknown>;
+    /** Get field-level change history for an entity */
+    history(entityType: string, entityId: string): Promise<unknown>;
+    /** Get change history for a specific field */
+    getField(entityType: string, entityId: string, fieldName: string): Promise<unknown>;
+    /** Get tracking buffer status (AI usage buffer size) */
+    listStatus(): Promise<unknown>;
+    /** Manually flush tracking buffers to database */
+    create(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class TwitterResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Search X (Twitter) tweets by query */
+    list(): Promise<unknown>;
+    /** Get details of a specific tweet */
+    get(tweetId: string): Promise<unknown>;
+    /** Delete a tweet */
+    delete(tweetId: string): Promise<unknown>;
+    /** Post a new tweet */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Like a tweet */
+    createLike(userId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Unlike a tweet */
+    deleteLike(userId: string, tweetId: string): Promise<unknown>;
+    /** Retweet a tweet */
+    createRetweet(userId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Remove a retweet */
+    deleteRetweet(userId: string, tweetId: string): Promise<unknown>;
+    /** Get user information by username */
+    getUsername(username: string): Promise<unknown>;
+    /** Get user information by user ID */
+    getUsers(userId: string): Promise<unknown>;
+    /** Get authenticated user information */
+    listMe(): Promise<unknown>;
+    /** Get recent tweets from a user */
+    tweets(userId: string): Promise<unknown>;
+    /** Follow a user */
+    createFollowing(userId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Unfollow a user */
+    deleteFollowing(userId: string, targetUserId: string): Promise<unknown>;
+    /** Get followers of a user */
+    followers(userId: string): Promise<unknown>;
+    /** Get users that a user is following */
+    followingList(userId: string): Promise<unknown>;
+    /** Get users who liked a tweet */
+    likedBy(tweetId: string): Promise<unknown>;
+    /** Get users who retweeted a tweet */
+    retweetedBy(tweetId: string): Promise<unknown>;
+    /** Get tweets in a conversation thread */
+    getConversations(conversationId: string): Promise<unknown>;
+    /** Get tweets liked by a user */
+    likedTweets(userId: string): Promise<unknown>;
+}
+
+declare class UsageResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get unified usage metrics for a user across AI, API, and integrations */
+    get(userId: string): Promise<unknown>;
+    /** Get a brief summary of user usage */
+    summary(userId: string): Promise<unknown>;
+    /** Get usage metrics for the authenticated user */
+    list(): Promise<unknown>;
+}
+
+declare class WebsocketResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** WebSocket API Documentation */
+    list(): Promise<unknown>;
+}
+
+declare class WorkflowsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Orchestrate a task by ID. Executes predefined task orchestration logic. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Execute an agentic workflow with tools and steps. Workflows define a series of actions that can call LLMs, APIs, shell commands, and MCP tools. */
+    createWorkflow(data: Record<string, unknown>): Promise<unknown>;
+    /** List all workflow executions with date range filter and pagination. */
+    list(): Promise<unknown>;
+    /** Delete all workflow executions and their activity records */
+    delete(): Promise<unknown>;
+    /** Delete a specific workflow execution and all its activity records */
+    deleteExecutions(workflowId: string): Promise<unknown>;
+    /** Get execution history for a workflow by ID. Returns all historical execution records. */
+    history(workflowId: string): Promise<unknown>;
+    /** Resume a paused workflow execution. Allows continuing or cancelling execution with optional user input. */
+    createResume(data: Record<string, unknown>): Promise<unknown>;
+    /** Request pause for a running workflow. The workflow will pause after the current step completes. */
+    pause(executionId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Cancel a running workflow. The workflow will stop after the current step completes. */
+    cancel(executionId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get background execution status for workflows that returned early */
+    status(executionId: string): Promise<unknown>;
+    /** Retry a workflow execution. Can restart from beginning or resume from last checkpoint. */
+    retry(executionId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Health check endpoint with detailed component status. Returns status of embeddings, vector store, MCP servers, and database. */
+    listHealth(): Promise<unknown>;
+    /** Automatically generate and execute a workflow from a natural language goal using AI */
+    createDynamic(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class WorkspacesResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all workspaces */
+    list(): Promise<unknown>;
+    /** Create a new workspace */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get workspace by ID */
+    get(id: string): Promise<unknown>;
+    /** Update workspace */
+    update(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete workspace */
+    delete(id: string): Promise<unknown>;
+}
+
+interface AIChatOptions {
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    projectContext?: unknown;
+}
+interface AIChatResponse {
+    chatResponse: {
+        message: string;
+        suggestions?: string[];
+    };
+}
+declare class AIResource {
+    private client;
+    constructor(client: BackflowClient);
+    chat(options: AIChatOptions): Promise<AIChatResponse>;
+}
+
+interface PresenceData {
+    projectId: string;
+    cursor?: unknown;
+    selection?: unknown;
+}
+declare class CollaborationResource {
+    private client;
+    constructor(client: BackflowClient);
+    presence(data: PresenceData): Promise<{
+        success: boolean;
+    }>;
+}
+
+interface HighResExportOptions {
+    format: 'png' | 'svg' | 'pdf';
+    scale: number;
+    content: unknown;
+    contentType?: string;
+}
+interface HighResExportResult {
+    export: string;
+    r2Upload: {
+        url: string;
+    };
+}
+declare class ExportsResource {
+    private client;
+    constructor(client: BackflowClient);
+    highRes(options: HighResExportOptions): Promise<HighResExportResult>;
+}
+
+interface UserMetrics {
+    role?: string;
+    teamSize?: string;
+    useCase?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface UserProfile {
+    uid: string;
+    email?: string;
+    displayName?: string;
+    photoURL?: string;
+    emailVerified?: boolean;
+}
+interface UpdateProfileOptions {
+    displayName?: string;
+    photoURL?: string;
+}
+declare class UserResource {
+    private client;
+    constructor(client: BackflowClient);
+    createMetrics(metrics: UserMetrics): Promise<{
+        success: boolean;
+    }>;
+    getMetrics(): Promise<{
+        data: UserMetrics;
+    }>;
+    updateMetrics(metrics: Partial<UserMetrics>): Promise<{
+        success: boolean;
+    }>;
+    getProfile(): Promise<{
+        user: UserProfile;
+    }>;
+    updateProfile(options: UpdateProfileOptions): Promise<{
+        success: boolean;
+        user: UserProfile;
+    }>;
+}
+
+interface RouteInfo {
+    path: string;
+    method: string;
+    description?: string;
+    tags?: string[];
+}
+interface CollectionInfo {
+    collection: string;
+    routes: RouteInfo[];
+}
+interface EntityRecord {
+    id: string;
+    [key: string]: unknown;
+}
+interface ListEntitiesOptions {
+    limit?: number;
+    offset?: number;
+    includeDeleted?: boolean;
+}
+interface GetEntityOptions {
+    includeDeleted?: boolean;
+}
+interface DeleteEntityOptions {
+    hard?: boolean;
+    softDelete?: boolean;
+}
+interface DeleteEntityResult {
+    success: boolean;
+    softDeleted?: boolean;
+}
+interface RestoreEntityResult {
+    success: boolean;
+    data?: EntityRecord;
+}
+interface ListEntitiesResult {
+    data: EntityRecord[];
+    count?: number;
+}
+type ValidationPreset = "email" | "url" | "phone-us" | "phone-intl" | "uuid" | "slug" | "username" | "password" | "name" | "currency" | "percentage" | "date" | "datetime" | "time" | "ip" | "ipv4" | "ipv6" | "mac-address" | "credit-card" | "postal-code-us" | "ssn" | "hex-color" | "json";
+type FieldType = "text" | "varchar" | "integer" | "bigint" | "decimal" | "boolean" | "timestamp" | "date" | "json" | "jsonb" | "array" | "uuid" | "enum";
+interface SchemaField {
+    name: string;
+    source: "builtin" | "route" | "entity";
+    type?: FieldType;
+    required?: boolean;
+    preset?: ValidationPreset;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    enum?: string[];
+}
+interface CollectionSchema {
+    collection: string;
+    fields: SchemaField[];
+}
+interface ValidationResult$1 {
+    valid: boolean;
+    errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+declare class EntitiesResource {
+    private client;
+    constructor(client: BackflowClient);
+    listCollections(): Promise<CollectionInfo[]>;
+    list(collection: string, options?: ListEntitiesOptions): Promise<ListEntitiesResult>;
+    get(collection: string, id: string, options?: GetEntityOptions): Promise<EntityRecord>;
+    create(collection: string, data: Record<string, unknown>): Promise<EntityRecord>;
+    update(collection: string, id: string, data: Record<string, unknown>): Promise<EntityRecord>;
+    delete(collection: string, id: string, options?: DeleteEntityOptions): Promise<DeleteEntityResult>;
+    restore(collection: string, id: string): Promise<RestoreEntityResult>;
+    getSchema(): Promise<CollectionSchema[]>;
+    /**
+     * Get schema for a specific collection
+     */
+    getCollectionSchema(collection: string): Promise<CollectionSchema | null>;
+    /**
+     * Validate data against a collection's schema (client-side)
+     */
+    validate(collection: string, data: Record<string, unknown>): Promise<ValidationResult$1>;
+    private validatePreset;
+    /**
+     * Create with validation (validates before sending to server)
+     */
+    createValidated(collection: string, data: Record<string, unknown>): Promise<{
+        data?: EntityRecord;
+        errors?: ValidationResult$1["errors"];
+    }>;
+    /**
+     * Update with validation (validates before sending to server)
+     */
+    updateValidated(collection: string, id: string, data: Record<string, unknown>): Promise<{
+        data?: EntityRecord;
+        errors?: ValidationResult$1["errors"];
+    }>;
+}
+
+interface FileUploadOptions {
+    bucket?: string;
+    entityType?: string;
+    entityId?: string;
+}
+interface FileMetadata {
+    id: string;
+    bucket: string;
+    path: string;
+    url: string;
+    size: number;
+    content_type: string;
+    uploaded_at: string;
+    uploaded_by: string;
+    tenant_id: string;
+    entity_type: string;
+    entity_id: string;
+    created_at?: {
+        _seconds: number;
+        _nanoseconds: number;
+    } | string;
+}
+interface SignedUrlResponse {
+    success: boolean;
+    signedUrl: string;
+    expiresAt: string;
+}
+interface DownloadProgress {
+    loaded: number;
+    total: number;
+    percentage: number;
+}
+declare class FilesResource {
+    private client;
+    constructor(client: BackflowClient);
+    upload(file: File, options?: FileUploadOptions): Promise<FileMetadata>;
+    uploadMultiple(files: File[], options?: FileUploadOptions): Promise<FileMetadata[]>;
+    list(entityType: string, entityId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<FileMetadata[]>;
+    getSignedUrl(bucket: string, key: string, expiresIn?: number): Promise<SignedUrlResponse>;
+    download(bucket: string, key: string): Promise<Blob>;
+    /**
+     * Stream file download with optional progress tracking
+     * More efficient for large files than standard download()
+     * Streaming must be enabled in backend config (r2.streaming.enabled: true)
+     */
+    downloadStream(bucket: string, key: string, options?: {
+        onProgress?: (progress: DownloadProgress) => void;
+    }): Promise<Blob>;
+    /**
+     * Get a raw stream for the file
+     * Useful for custom processing or piping to other streams
+     * Streaming must be enabled in backend config (r2.streaming.enabled: true)
+     */
+    getDownloadStream(bucket: string, key: string): Promise<ReadableStream<Uint8Array>>;
+    delete(bucket: string, key: string): Promise<{
+        success: boolean;
+    }>;
+    deleteByEntity(entityType: string, entityId: string): Promise<{
+        success: boolean;
+        deleted: number;
+    }>;
+    uploadJson(options: {
+        content: string;
+        filename: string;
+        entityType?: string;
+        entityId?: string;
+        bucket?: string;
+    }): Promise<{
+        upload: {
+            url: string;
+            key: string;
+            bucket: string;
+            path: string;
+        };
+    }>;
+}
+
+declare const TOOL_TYPES: readonly ["llm_call", "api_call", "shell_command", "web_search", "file_edit", "git_command", "mcp_tool", "storage", "database", "notification", "workflow", "rag", "cache", "emit_event", "transform"];
+declare const TRIGGER_TYPES: readonly ["manual", "cron", "webhook", "event"];
+declare const NOTIFY_CHANNELS: readonly ["email", "sms", "whatsapp", "push", "slack"];
+declare const NOTIFY_PRIORITIES: readonly ["low", "normal", "high", "urgent"];
+declare const DB_OPERATIONS: readonly ["get", "query", "insert", "update", "upsert", "delete", "deletewhere", "arrayRemove", "updateArrayElement", "count"];
+declare const STORAGE_OPERATIONS: readonly ["get", "download", "put", "upload", "list", "signedUrl", "delete", "deleteByPrefix", "url", "publicUrl"];
+declare const CACHE_OPERATIONS: readonly ["get", "set", "delete", "invalidate"];
+declare const LLM_PROVIDERS: readonly ["openai", "anthropic", "google", "openrouter", "lmstudio", "custom", "claude", "ollama"];
+declare const CLI_PROVIDERS: readonly ["claude", "openai", "aider", "anthropic", "claude-cli", "openai-cli", "ollama-cli"];
+declare const DB_PROVIDERS: readonly ["firebase", "supabase", "sqlite", "custom"];
+declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
+declare const RAG_MODES: readonly ["single", "accumulate", "iterative"];
+declare const CHUNKING_STRATEGIES: readonly ["fixed_size", "recursive", "token_based", "semantic"];
+declare const IMAGE_DETAILS: readonly ["auto", "low", "high"];
+declare const CONDITION_OPERATORS: readonly ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$exists"];
+type ToolType = typeof TOOL_TYPES[number];
+type TriggerType = typeof TRIGGER_TYPES[number];
+type NotifyChannel = typeof NOTIFY_CHANNELS[number];
+type NotifyPriority = typeof NOTIFY_PRIORITIES[number];
+interface PropertyValidation {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'enum';
+    required: boolean;
+    multiselect?: boolean;
+    options?: readonly string[];
+    itemType?: PropertyValidation;
+    properties?: Record<string, PropertyValidation>;
+    description?: string;
+    default?: unknown;
+}
+interface WorkflowValidationSchema {
+    root: Record<string, PropertyValidation>;
+    tool: Record<string, PropertyValidation>;
+    step: Record<string, PropertyValidation>;
+    trigger: Record<string, PropertyValidation>;
+    pausePoint: Record<string, PropertyValidation>;
+    notify: Record<string, PropertyValidation>;
+    workflow: Record<string, PropertyValidation>;
+    fileAttachment: Record<string, PropertyValidation>;
+    imageAttachment: Record<string, PropertyValidation>;
+    conditionOperators: Record<string, PropertyValidation>;
+}
+declare const WORKFLOW_VALIDATION_SCHEMA: WorkflowValidationSchema;
+interface WorkflowConfig {
+    id?: string;
+    name?: string;
+    steps: WorkflowStep[];
+    tools?: WorkflowTool[];
+    masterContext?: string;
+}
+interface WorkflowStep {
+    id: string;
+    action: string;
+    params?: Record<string, unknown>;
+    dependsOn?: string[];
+    parallel?: boolean;
+    earlyReturn?: boolean;
+    queueAsJob?: boolean;
+    condition?: string;
+    pausePoint?: PausePoint;
+    files?: string[];
+    images?: string[];
+    /** If true, step failure won't stop the workflow */
+    optional?: boolean;
+    /** Alias for optional */
+    continueOnError?: boolean;
+    /** Value to use if step fails when optional=true */
+    defaultValue?: unknown;
+    /** Variable name to store step output */
+    output?: string;
+}
+interface PausePoint {
+    requireApproval?: boolean;
+    message?: string;
+    metadata?: Record<string, unknown>;
+    notify?: NotifyConfig;
+}
+interface NotifyConfig {
+    enabled?: boolean;
+    channels?: NotifyChannel[];
+    priority?: NotifyPriority;
+    userId?: string;
+}
+interface WorkflowTool {
+    name: string;
+    type: ToolType;
+    description?: string;
+    endpoint?: string;
+    params?: Record<string, unknown>;
+}
+interface WorkflowExecution {
+    id: string;
+    workflowId: string;
+    status: 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'accepted';
+    result?: unknown;
+    error?: string;
+    channel?: string;
+    jobId?: string;
+    startedAt: string;
+    completedAt?: string;
+}
+interface BackgroundExecutionStatus {
+    executionId: string;
+    workflowId: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    completedSteps: string[];
+    pendingSteps: string[];
+    error?: string;
+}
+type StepStatus = 'pending' | 'success' | 'failed' | 'skipped';
+interface WorkflowProgressEvent {
+    stepId: string;
+    status: StepStatus;
+    result?: unknown;
+    error?: string;
+}
+interface WorkflowActivityEvent {
+    timestamp: string;
+    type: string;
+    stepId?: string;
+    data?: unknown;
+}
+interface WorkflowSubscribeHandlers {
+    onProgress?: (event: WorkflowProgressEvent) => void;
+    onComplete?: (execution: WorkflowExecution) => void;
+    onError?: (error: unknown) => void;
+    /** Called when a step starts */
+    onStepStarted?: (stepId: string) => void;
+    /** Called when a step completes successfully */
+    onStepCompleted?: (stepId: string, duration?: number) => void;
+    /** Called when a non-optional step fails */
+    onStepFailed?: (stepId: string, error?: string) => void;
+    /** Called when an optional step fails but workflow continues */
+    onStepSkipped?: (stepId: string, error?: string) => void;
+}
+declare class WorkflowsResource {
+    private client;
+    constructor(client: BackflowClient);
+    execute(config: WorkflowConfig): Promise<WorkflowExecution>;
+    get(executionId: string): Promise<WorkflowExecution>;
+    list(params?: {
+        limit?: number;
+        page?: number;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<{
+        executions: WorkflowExecution[];
+        pagination: {
+            page: number;
+            limit: number;
+            total: number;
+            hasMore: boolean;
+        };
+    }>;
+    getHistory(workflowId: string): Promise<{
+        history: WorkflowActivityEvent[];
+    }>;
+    pause(executionId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    resume(executionId: string, options?: {
+        continue?: boolean;
+        userInput?: unknown;
+    }): Promise<{
+        success: boolean;
+        result?: unknown;
+    }>;
+    cancel(executionId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getStatus(executionId: string): Promise<BackgroundExecutionStatus>;
+    retry(executionId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    rerun(workflowId: string): Promise<WorkflowExecution>;
+    delete(workflowId: string): Promise<{
+        success: boolean;
+    }>;
+    deleteAll(): Promise<{
+        success: boolean;
+        deleted: number;
+    }>;
+    subscribe(executionId: string, handlers: WorkflowSubscribeHandlers): () => void;
+    getValidationSchema(): WorkflowValidationSchema;
+    getSchemaFor(section: keyof WorkflowValidationSchema): Record<string, PropertyValidation>;
+    getToolTypes(): readonly string[];
+    getTriggerTypes(): readonly string[];
+    getNotifyChannels(): readonly string[];
+    getNotifyPriorities(): readonly string[];
+    getDbOperations(): readonly string[];
+    getStorageOperations(): readonly string[];
+    validateProperty(section: keyof WorkflowValidationSchema, property: string, value: unknown): {
+        valid: boolean;
+        error?: string;
+    };
+}
+declare const TOOL_PARAM_CONTEXT: Record<string, string[]>;
+interface PromptContextOptions {
+    sections?: (keyof WorkflowValidationSchema)[];
+    toolType?: string;
+    compact?: boolean;
+}
+declare function toPromptContext(options?: PromptContextOptions): string;
+declare function toCompactContext(toolType?: string): string;
+
+type EmbeddingContentType = 'article' | 'code' | 'conversation' | 'document' | 'general';
+interface EmbedDocumentOptions {
+    document: string;
+    documentId?: string;
+    contentType?: EmbeddingContentType;
+    metadata?: Record<string, unknown>;
+    subscribable?: boolean;
+}
+interface EmbeddingResult {
+    documentId: string;
+    chunksCreated: number;
+    success: boolean;
+}
+interface SubscribableResponse {
+    accepted: true;
+    jobId: string;
+    subscribe: {
+        sse: string;
+        websocket: {
+            path: string;
+            channel: string;
+        };
+        poll: string;
+    };
+}
+interface BatchEmbeddingDocument {
+    document: string;
+    documentId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface BatchEmbeddingResult {
+    results: EmbeddingResult[];
+    totalChunks: number;
+    success: boolean;
+}
+interface DocumentSearchResult {
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+interface EmbeddedDocument {
+    documentId: string;
+    chunkCount: number;
+    metadata: Record<string, unknown>;
+}
+declare class EmbeddingsResource {
+    private client;
+    constructor(client: BackflowClient);
+    listDocuments(limit?: number): Promise<{
+        success: boolean;
+        documents: EmbeddedDocument[];
+    }>;
+    embedDocument(options: EmbedDocumentOptions & {
+        subscribable: true;
+    }): Promise<SubscribableResponse>;
+    embedDocument(options: EmbedDocumentOptions & {
+        subscribable?: false;
+    }): Promise<EmbeddingResult>;
+    embedBatch(documents: BatchEmbeddingDocument[], contentType?: EmbeddingContentType): Promise<BatchEmbeddingResult>;
+    search(documentId: string, query: string, limit?: number): Promise<{
+        results: DocumentSearchResult[];
+    }>;
+    delete(documentId: string): Promise<{
+        success: boolean;
+    }>;
+    semanticSearch(query: string, limit?: number): Promise<{
+        results: DocumentSearchResult[];
+    }>;
+}
+
+interface UsageMetrics {
+    userId: string;
+    apiCalls: number;
+    tokensUsed: number;
+    storageUsed: number;
+    workflowsRun: number;
+    period: string;
+}
+interface UsageSummary {
+    total: UsageMetrics;
+    breakdown: {
+        date: string;
+        metrics: Partial<UsageMetrics>;
+    }[];
+}
+declare class UsageResource {
+    private client;
+    constructor(client: BackflowClient);
+    getMyUsage(): Promise<UsageMetrics>;
+    getUserUsage(userId: string, options?: {
+        startDate?: string;
+        endDate?: string;
+    }): Promise<UsageMetrics>;
+    getSummary(userId: string): Promise<UsageSummary>;
+}
+
+interface ProjectAnalytics {
+    views: number;
+    edits: number;
+    collaborators: number;
+    lastActive: string;
+}
+declare class AnalyticsResource {
+    private client;
+    constructor(client: BackflowClient);
+    project(projectId: string): Promise<ProjectAnalytics>;
+}
+
+interface GithubImportResult {
+    diagram: unknown;
+    r2Upload: {
+        url: string;
+    };
+}
+declare class GithubResource {
+    private client;
+    constructor(client: BackflowClient);
+    import(owner: string, repo: string, options: {
+        path: string;
+        ref?: string;
+        githubToken: string;
+    }): Promise<GithubImportResult>;
+    repos(): Promise<unknown[]>;
+    contents(owner: string, repo: string, path?: string): Promise<unknown>;
+    branches(owner: string, repo: string): Promise<unknown[]>;
+    pulls(owner: string, repo: string): Promise<unknown[]>;
+    getPull(owner: string, repo: string, pullNumber: string): Promise<unknown>;
+    files(owner: string, repo: string, pullNumber: string): Promise<unknown[]>;
+}
+
+declare class QueuesResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all queues and their statistics (tenant-isolated) */
+    list(): Promise<unknown>;
+    /** Get statistics for a specific queue (tenant-isolated) */
+    stats(name: string): Promise<unknown>;
+    /** Get jobs from a queue (tenant-isolated) */
+    jobs(name: string): Promise<unknown>;
+    /** Add a job to the queue (with tenant isolation) */
+    createJob(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get a specific job (tenant-isolated) */
+    getJob(name: string, jobId: string): Promise<unknown>;
+    /** Retry a failed job (tenant-isolated) */
+    retry(name: string, jobId: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Pause a queue (admin only - affects all tenants) */
+    pause(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Resume a paused queue (admin only - affects all tenants) */
+    resume(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Clean old jobs from queue (tenant-isolated) */
+    createClean(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get detailed performance metrics for a queue */
+    metrics(name: string): Promise<unknown>;
+    /** Subscribe to job updates via SSE. Returns unsubscribe function. */
+    subscribe<T = unknown>(sseUrl: string, handlers: {
+        onConnected?: () => void;
+        onComplete?: (result: T) => void;
+        onFailed?: (error: string) => void;
+        onProgress?: (progress: number, message?: string) => void;
+        onWarning?: (warning: string) => void;
+        onError?: (error: Event) => void;
+    }): () => void;
+}
+
+type SearchMode = 'exact' | 'fuzzy' | 'hybrid';
+interface SearchOptions {
+    q: string;
+    mode?: SearchMode;
+    limit?: number;
+    threshold?: number;
+}
+interface SearchMeta {
+    entity: string;
+    query: string;
+    mode: SearchMode;
+    cached: boolean;
+    latency: number;
+    total: number;
+}
+interface SearchResponse<T = Record<string, unknown>> {
+    results: T[];
+    meta: SearchMeta;
+}
+interface IndexOptions {
+    entity: string;
+    ids?: string[];
+    batchSize?: number;
+}
+interface IndexResult {
+    success: boolean;
+    entity: string;
+    indexed: number;
+    latency: number;
+}
+interface ReindexOptions {
+    entity: string;
+    batchSize?: number;
+}
+interface ReindexResult {
+    success: boolean;
+    entity: string;
+    deleted: number;
+    indexed: number;
+    latency: number;
+}
+interface DeleteIndexResult {
+    success: boolean;
+    entity: string;
+    deleted: number;
+    latency: number;
+}
+interface SearchStats {
+    enabled: boolean;
+    configuredEntities: string[];
+    defaultMode: SearchMode;
+    cacheTTL: number;
+}
+interface SearchEntityConfig {
+    searchFields: string[];
+    filters?: Array<{
+        column: string;
+        operator: string;
+        value: unknown;
+    }>;
+    idField?: string;
+}
+interface SearchConfig {
+    enabled: boolean;
+    defaultMode: SearchMode;
+    defaultLimit: number;
+    cacheTTL: number;
+    threshold: number;
+    entities: Record<string, SearchEntityConfig>;
+}
+interface ValidationError {
+    field: string;
+    message: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * Context-aware field validator for search configuration
+ *
+ * @example
+ * ```typescript
+ * const validator = new SearchConfigValidator();
+ *
+ * // Validate entity config
+ * const result = validator.validateEntityConfig('products', {
+ *   searchFields: ['name', 'description'],
+ *   filters: [{ column: 'is_active', operator: 'eq', value: true }]
+ * });
+ *
+ * if (!result.valid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+declare class SearchConfigValidator {
+    private validOperators;
+    private validModes;
+    /**
+     * Validate search options for a query
+     */
+    validateSearchOptions(options: SearchOptions): ValidationResult;
+    /**
+     * Validate entity configuration
+     */
+    validateEntityConfig(entity: string, config: SearchEntityConfig): ValidationResult;
+    /**
+     * Validate full search configuration
+     */
+    validateConfig(config: Partial<SearchConfig>): ValidationResult;
+}
+/**
+ * Search resource for fast entity search
+ *
+ * @example
+ * ```typescript
+ * import { createBackflow } from '@backflow/sdk';
+ *
+ * const backflow = createBackflow({ apiKey: 'your-api-key' });
+ *
+ * // Search products with hybrid mode (vector + cache)
+ * const results = await backflow.search.query('products', {
+ *   q: 'wireless headphones',
+ *   mode: 'hybrid',
+ *   limit: 10
+ * });
+ *
+ * console.log(`Found ${results.meta.total} results in ${results.meta.latency}ms`);
+ * console.log('Cached:', results.meta.cached);
+ *
+ * // Index products for vector search
+ * await backflow.search.index({ entity: 'products' });
+ *
+ * // Search with exact mode (faster, no typo tolerance)
+ * const exact = await backflow.search.query('products', {
+ *   q: 'Sony WH-1000XM5',
+ *   mode: 'exact'
+ * });
+ *
+ * // Search with fuzzy mode (semantic, typo tolerant)
+ * const fuzzy = await backflow.search.query('products', {
+ *   q: 'wireles headfones',
+ *   mode: 'fuzzy',
+ *   threshold: 0.6
+ * });
+ * ```
+ */
+declare class SearchResource {
+    private client;
+    readonly validator: SearchConfigValidator;
+    constructor(client: BackflowClient);
+    /**
+     * Search an entity
+     *
+     * @param entity - Entity/table name to search
+     * @param options - Search options
+     * @returns Search results with metadata
+     *
+     * @example
+     * ```typescript
+     * // Basic search
+     * const results = await backflow.search.query('products', { q: 'laptop' });
+     *
+     * // Advanced search with all options
+     * const results = await backflow.search.query('products', {
+     *   q: 'gaming laptop',
+     *   mode: 'hybrid',      // 'exact' | 'fuzzy' | 'hybrid'
+     *   limit: 20,           // max results
+     *   threshold: 0.7       // similarity threshold for fuzzy/hybrid
+     * });
+     *
+     * // Access results
+     * results.results.forEach(product => {
+     *   console.log(product.name, product._score); // _score for fuzzy results
+     * });
+     * ```
+     */
+    query<T = Record<string, unknown>>(entity: string, options: SearchOptions): Promise<SearchResponse<T>>;
+    /**
+     * Index entity records for vector search
+     *
+     * @param options - Index options
+     * @returns Index result
+     *
+     * @example
+     * ```typescript
+     * // Index all products
+     * const result = await backflow.search.index({ entity: 'products' });
+     * console.log(`Indexed ${result.indexed} records in ${result.latency}ms`);
+     *
+     * // Index specific records
+     * await backflow.search.index({
+     *   entity: 'products',
+     *   ids: ['prod_123', 'prod_456'],
+     *   batchSize: 50
+     * });
+     * ```
+     */
+    index(options: IndexOptions): Promise<IndexResult>;
+    /**
+     * Delete and reindex all records for an entity
+     *
+     * @param options - Reindex options
+     * @returns Reindex result
+     *
+     * @example
+     * ```typescript
+     * // Reindex all products
+     * const result = await backflow.search.reindex({ entity: 'products' });
+     * console.log(`Deleted ${result.deleted}, indexed ${result.indexed}`);
+     * ```
+     */
+    reindex(options: ReindexOptions): Promise<ReindexResult>;
+    /**
+     * Delete all indexed records for an entity
+     *
+     * @param entity - Entity name
+     * @returns Delete result
+     *
+     * @example
+     * ```typescript
+     * await backflow.search.delete('products');
+     * ```
+     */
+    delete(entity: string): Promise<DeleteIndexResult>;
+    /**
+     * Get search statistics
+     *
+     * @returns Search configuration stats
+     *
+     * @example
+     * ```typescript
+     * const stats = await backflow.search.stats();
+     * console.log('Configured entities:', stats.configuredEntities);
+     * console.log('Default mode:', stats.defaultMode);
+     * ```
+     */
+    stats(): Promise<SearchStats>;
+}
+
+interface TenantConfig {
+    tenantId: string;
+    name?: string;
+    plan?: string;
+    features?: string[];
+    routes?: any[];
+    [key: string]: any;
+}
+interface TenantInfo {
+    id: string;
+    name: string;
+    plan: string;
+    createdAt: string;
+    subscriptionStatus: string;
+}
+interface TenantUsage {
+    entities: number;
+    workflows: number;
+    apiCalls: number;
+    storage: number;
+    quotas: {
+        entities?: number;
+        workflows?: number;
+        apiCalls?: number;
+        storage?: number;
+    };
+}
+declare class TenantResource {
+    private client;
+    constructor(client: BackflowClient);
+    getInfo(): Promise<TenantInfo>;
+    getConfig(): Promise<{
+        config: TenantConfig;
+        version: number;
+    }>;
+    updateConfig(config: Partial<TenantConfig>): Promise<{
+        config: TenantConfig;
+        version: number;
+    }>;
+    getUsage(): Promise<TenantUsage>;
+    getId(): Promise<string>;
+}
+
+declare class IntegrationsResource {
+    private client;
+    readonly stripe: StripeResource;
+    readonly polar: PolarResource;
+    constructor(client: BackflowClient);
+}
+declare class BackflowSDK {
+    private client;
+    readonly agentAnalysis: AgentAnalysisResource;
+    readonly assets: AssetsResource;
+    readonly batch: BatchResource;
+    readonly cache: CacheResource;
+    readonly default: DefaultResource;
+    readonly deployment: DeploymentResource;
+    readonly feedback: FeedbackResource;
+    readonly goals: GoalsResource;
+    readonly googleDrive: GoogleDriveResource;
+    readonly jira: JiraResource;
+    readonly llm: LlmResource;
+    readonly mcptools: McpToolsResource;
+    readonly projects: ProjectsResource;
+    readonly publish: PublishResource;
+    readonly teams: TeamsResource;
+    readonly tenantWebhookReceivers: TenantWebhookReceiversResource;
+    readonly tenantWebhooks: TenantWebhooksResource;
+    readonly tooldiscovery: ToolDiscoveryResource;
+    readonly tracking: TrackingResource;
+    readonly twitter: TwitterResource;
+    readonly websocket: WebsocketResource;
+    readonly workspaces: WorkspacesResource;
+    readonly integrations: IntegrationsResource;
+    readonly files: FilesResource;
+    readonly workflows: WorkflowsResource;
+    readonly embeddings: EmbeddingsResource;
+    readonly usage: UsageResource;
+    readonly analytics: AnalyticsResource;
+    readonly github: GithubResource;
+    readonly queues: QueuesResource;
+    readonly search: SearchResource;
+    readonly ai: AIResource;
+    readonly collaboration: CollaborationResource;
+    readonly webhooks: (projectId: string) => {
+        trigger: (data: {
+            event: string;
+            data: unknown;
+        }) => Promise<unknown>;
+    };
+    readonly exports: ExportsResource;
+    readonly user: UserResource;
+    readonly tenant: TenantResource;
+    readonly entities: EntitiesResource;
+    constructor(config: BackflowConfig);
+    get endpoint(): string;
+    get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(path: string, data?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    put<T>(path: string, data?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    patch<T>(path: string, data?: unknown, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+}
+type BackflowSDKWithDynamicResources = BackflowSDK & {
+    [key: string]: {
+        [method: string]: (...args: unknown[]) => Promise<unknown>;
+    };
+};
+declare function createBackflow(config: BackflowConfig): BackflowSDKWithDynamicResources;
+
+/**
+ * SDK Documentation for LLM App Generation
+ * This is injected into the app generation prompt so the LLM knows
+ * what SDK methods are available for generated apps.
+ */
+declare function getSDKDocs(): string;
+/**
+ * Get compact SDK reference for shorter prompts
+ */
+declare function getSDKDocsCompact(): string;
+
+export { AgentAnalysisResource, AnalyticsResource$1 as AnalyticsResource, type AssetListParams, type AssetListResponse, type AssetStatsResponse, AssetsResource, BackflowSDK as Backflow, BackflowClient, type BackflowConfig, type BackflowError, type BackflowResponse, BackflowSDK, type BackflowSDKWithDynamicResources, type BatchExportOptions, type BatchExportResult, type BatchImportOptions, type BatchImportResult, type BatchJob, BatchResource, CACHE_OPERATIONS, CHUNKING_STRATEGIES, CLI_PROVIDERS, CONDITION_OPERATORS, CacheResource, DB_OPERATIONS, DB_PROVIDERS, type DatabaseFilter, type DatabaseFilterOperator, type DatabaseIntegrationAction, type DatabaseProvider, DefaultResource, DeploymentResource, EmbeddingsResource$1 as EmbeddingsResource, FeedbackResource, FilesResource$1 as FilesResource, GithubResource$1 as GithubResource, GoalsResource, GoogleDriveResource, HTTP_METHODS, type HttpMethod, IMAGE_DETAILS, JiraResource, LLM_PROVIDERS, LlmResource, McpToolsResource, NOTIFY_CHANNELS, NOTIFY_PRIORITIES, type NotifyChannel, type NotifyConfig, type NotifyPriority, type PausePoint, PolarResource, ProjectsResource, type PromptContextOptions, type PropertyValidation, PublishResource, QueuesResource$1 as QueuesResource, RAG_MODES, type RequestOptions, type SSESubscribeHandlers, STORAGE_OPERATIONS, SearchResource$1 as SearchResource, StripeResource, TOOL_PARAM_CONTEXT, TOOL_TYPES, TRIGGER_TYPES, TeamsResource, type TenantAsset, TenantWebhookReceiversResource, TenantWebhooksResource, ToolDiscoveryResource, type ToolType, TrackingResource, type TriggerType, TwitterResource, UsageResource$1 as UsageResource, WORKFLOW_VALIDATION_SCHEMA, WebsocketResource, type WorkflowValidationSchema, WorkflowsResource$1 as WorkflowsResource, WorkspacesResource, createBackflow, getSDKDocs, getSDKDocsCompact, toCompactContext, toPromptContext };