@backflow.sdk/admin 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2499 @@
+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>;
+    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>;
+}
+
+declare class ApiKeysResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List API keys */
+    list(): Promise<unknown>;
+    /** Create API key */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Revoke API key */
+    delete(keyId: string): Promise<unknown>;
+    /** Rotate API key */
+    rotate(keyId: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class AppsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** Create a new app (available to all authenticated users) */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get current app usage and limits */
+    list(): Promise<unknown>;
+    /** Update app settings (name and environment only) */
+    patch(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class AssetsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Upload asset to R2 with Firebase metadata */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** List user assets */
+    list(): Promise<unknown>;
+    /** Get asset by ID */
+    get(id: string): Promise<unknown>;
+    /** Delete asset from R2 and Firebase */
+    delete(id: string): Promise<unknown>;
+    /** Update asset metadata */
+    updateMetadata(id: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class AuthenticationResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Login with email and password. Returns JWT token if MFA is disabled, or requires MFA verification if enabled. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Complete login with MFA verification. Supports TOTP tokens and backup codes. */
+    createMfa(data: Record<string, unknown>): Promise<unknown>;
+    /** Verify MFA token without full login. Production endpoint for token validation. */
+    createVerifyMfaToken(data: Record<string, unknown>): Promise<unknown>;
+    /** Switch to a different tenant. Returns a new JWT with tenantId claim. */
+    createSwitchTenant(data: Record<string, unknown>): Promise<unknown>;
+    /** Exchange API key for JWT token. Used by SDK for programmatic access. */
+    createToken(data: Record<string, unknown>): Promise<unknown>;
+    /** Request password reset email */
+    createForgotPassword(data: Record<string, unknown>): Promise<unknown>;
+    /** Verify password reset token is valid */
+    createVerifyResetToken(data: Record<string, unknown>): Promise<unknown>;
+    /** Reset password with valid token */
+    createResetPassword(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class BillingResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all available billing plans with feature limits */
+    list(): Promise<unknown>;
+    /** Get current usage statistics against plan limits (tenant-isolated) */
+    listUsage(): Promise<unknown>;
+    /** Get current subscription status and details (tenant-isolated) */
+    listSubscription(): Promise<unknown>;
+    /** Request to upgrade to a different plan (tenant-isolated) */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** List products from tenant's Polar organization */
+    listProducts(): Promise<unknown>;
+    /** Create a product in tenant's Polar organization */
+    createProducts(data: Record<string, unknown>): Promise<unknown>;
+    /** Create a checkout session for a user in tenant's Polar org */
+    createCheckout(data: Record<string, unknown>): Promise<unknown>;
+    /** List customers from tenant's Polar organization */
+    listCustomers(): Promise<unknown>;
+    /** List subscriptions from tenant's Polar organization */
+    listSubscriptions(): Promise<unknown>;
+    /** Cancel a subscription in tenant's Polar organization */
+    delete(id: string): Promise<unknown>;
+    /** Get customer subscription state from tenant's Polar organization */
+    state(id: string): Promise<unknown>;
+    /** Stripe webhook handler for subscription events */
+    createStripe(data: Record<string, unknown>): Promise<unknown>;
+    /** Polar webhook handler for subscription events */
+    createPolar(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class CacheResource$1 {
+    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 ConfigResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get active tenant configuration */
+    list(): Promise<unknown>;
+    /** Upload or update tenant configuration */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** List configuration versions */
+    listVersions(): Promise<unknown>;
+    /** Rollback configuration */
+    createRollback(version: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get available webhook events */
+    listEvents(): 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 DomainsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List domains */
+    list(): Promise<unknown>;
+    /** Add domain */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Remove domain */
+    delete(domain: string): Promise<unknown>;
+    /** Verify domain */
+    createVerify(domain: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Get verification instructions */
+    verification(domain: string): 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 MfaResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Initialize MFA setup for the authenticated user. Generates TOTP secret, QR code, and backup codes. Requires JWT authentication. */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Verify MFA setup with a TOTP token from authenticator app and enable MFA for the account. Requires JWT authentication. */
+    createVerify(data: Record<string, unknown>): Promise<unknown>;
+    /** Disable MFA for the authenticated user. Requires current valid MFA token for security verification. */
+    createDisable(data: Record<string, unknown>): Promise<unknown>;
+    /** Check MFA status for the authenticated user. Returns whether MFA is enabled and setup dates. */
+    list(): Promise<unknown>;
+    /** Generate new backup codes for MFA recovery. Invalidates all previous backup codes. Requires current MFA token for security. */
+    createRegenerateBackupCodes(data: Record<string, unknown>): Promise<unknown>;
+    /** Validate an MFA token without side effects. Useful for protecting sensitive operations with MFA verification. */
+    createValidate(data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class MigrationResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get database migration SQL and instructions */
+    list(): Promise<unknown>;
+    /** Check if database migration has been applied */
+    listStatus(): Promise<unknown>;
+    /** Get quick migration with RLS disabled for development */
+    listQuickFix(): 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 SecretsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List secrets */
+    list(): Promise<unknown>;
+    /** Store a secret */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Delete a secret */
+    delete(key: string): Promise<unknown>;
+    /** Rotate a secret */
+    rotate(key: string, data: Record<string, unknown>): 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 SystemResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get comprehensive system information including routes, providers, and integrations */
+    list(): Promise<unknown>;
+    /** Get detailed information about all registered routes including tenant-specific custom routes */
+    listRoutes(): Promise<unknown>;
+    /** Get detailed information about all available integrations */
+    listIntegrations(): Promise<unknown>;
+    /** Get information about the versioning system and how to use it */
+    listVersioning(): Promise<unknown>;
+    /** Get information about the caching system */
+    listCache(): Promise<unknown>;
+    /** Get information about the multi-tenancy system */
+    listMultiTenancy(): Promise<unknown>;
+    /** Get information about tenant configuration management */
+    listTenantConfig(): Promise<unknown>;
+    /** Get information about role-based access control */
+    listRbac(): Promise<unknown>;
+    /** Get information about rate limiting */
+    listRateLimiting(): Promise<unknown>;
+    /** Get information about the queue system */
+    listQueues(): Promise<unknown>;
+    /** Get information about the events system */
+    listEvents(): Promise<unknown>;
+    /** Get information about webhooks */
+    listWebhooks(): Promise<unknown>;
+    /** Get information about file storage */
+    listFileStorage(): Promise<unknown>;
+    /** Get information about multi-factor authentication */
+    listMfa(): Promise<unknown>;
+    /** Get information about analytics */
+    listAnalytics(): Promise<unknown>;
+    /** Get information about billing and subscriptions */
+    listBilling(): Promise<unknown>;
+    /** Get information about notifications */
+    listNotifications(): Promise<unknown>;
+    /** Get information about WebSocket and real-time features */
+    listWebsocket(): Promise<unknown>;
+    /** Get information about the agent and AI system */
+    listAgent(): Promise<unknown>;
+    /** Get information about authentication */
+    listAuth(): Promise<unknown>;
+    /** Get information about encryption and security */
+    listEncryption(): Promise<unknown>;
+    /** Get information about database migrations */
+    listMigrations(): Promise<unknown>;
+    /** Get information about route aliasing */
+    listRouteAliasing(): Promise<unknown>;
+    /** Get information about the publishing system */
+    listPublishing(): Promise<unknown>;
+    /** Get information about deployment tracking */
+    listDeployment(): Promise<unknown>;
+    /** Get information about OpenAPI documentation */
+    listOpenapi(): Promise<unknown>;
+    /** Get information about gRPC support */
+    listGrpc(): Promise<unknown>;
+    /** Get information about microservices architecture */
+    listMicroservices(): Promise<unknown>;
+    /** Get information about domain management */
+    listDomains(): Promise<unknown>;
+    /** Get information about LLM streaming */
+    listLlmStreaming(): Promise<unknown>;
+    /** Get information about user usage tracking */
+    listUserUsage(): 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 TenantIntegrationsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List integrations */
+    list(): Promise<unknown>;
+    /** Create or update integration */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get integration */
+    get(integrationId: string): Promise<unknown>;
+    /** Delete integration */
+    delete(integrationId: string): Promise<unknown>;
+    /** Clone from default */
+    createClone(integrationId: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+declare class TenantJobsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List job definitions */
+    list(): Promise<unknown>;
+    /** Create or update job definition */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get job definition */
+    get(jobDefId: string): Promise<unknown>;
+    /** Delete job definition */
+    delete(jobDefId: string): Promise<unknown>;
+    /** Enqueue job from definition */
+    createEnqueue(data: Record<string, unknown>): Promise<unknown>;
+    /** Get job execution history */
+    listHistory(): Promise<unknown>;
+}
+
+declare class TenantLimitsResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get user limits configuration */
+    list(): Promise<unknown>;
+    /** Update user limits configuration */
+    update(data: Record<string, unknown>): Promise<unknown>;
+    /** Get usage statistics */
+    listUsage(): Promise<unknown>;
+    /** Check if action is allowed */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get storage limits configuration */
+    listStorage(): Promise<unknown>;
+    /** Update storage limits configuration */
+    updateStorage(data: Record<string, unknown>): Promise<unknown>;
+    /** Get storage usage statistics */
+    listGET2(): Promise<unknown>;
+    /** Check if file upload is allowed */
+    createCheck(data: Record<string, unknown>): Promise<unknown>;
+    /** Get storage usage by user */
+    listByUser(): Promise<unknown>;
+    /** Get resource limits configuration */
+    listResources(): Promise<unknown>;
+    /** Update resource limits configuration */
+    updateResources(data: Record<string, unknown>): Promise<unknown>;
+    /** Get available resource types */
+    listDefinitions(): Promise<unknown>;
+    /** Get resource usage statistics */
+    listGET3(): Promise<unknown>;
+    /** Check if resource action is allowed */
+    createPOST2(data: Record<string, unknown>): Promise<unknown>;
+    /** Track resource usage */
+    createTrack(data: Record<string, unknown>): Promise<unknown>;
+    /** Get limit for specific collection */
+    get(collection: string): Promise<unknown>;
+    /** Set limit for specific collection */
+    updateLimits(collection: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Remove limit for specific collection */
+    delete(collection: string): Promise<unknown>;
+}
+
+declare class TenantRbacResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get RBAC configuration */
+    list(): Promise<unknown>;
+    /** Update RBAC configuration */
+    update(data: Record<string, unknown>): Promise<unknown>;
+    /** List all roles */
+    listRoles(): Promise<unknown>;
+    /** Create a new role */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Update a role */
+    updateRoles(name: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete a role */
+    delete(name: 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 TenantWorkflowsResource$1 {
+    private client;
+    constructor(client: BackflowClient);
+    /** List workflows */
+    list(): Promise<unknown>;
+    /** Create or update workflow */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Get workflow */
+    get(workflowId: string): Promise<unknown>;
+    /** Delete workflow */
+    delete(workflowId: string): Promise<unknown>;
+    /** Clone from default */
+    createClone(workflowId: string, data: Record<string, unknown>): 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 UsersResource {
+    private client;
+    constructor(client: BackflowClient);
+    /** Get all users */
+    list(): Promise<unknown>;
+    /** Get user by ID */
+    get(id: string): Promise<unknown>;
+    /** Create a new user */
+    create(data: Record<string, unknown>): Promise<unknown>;
+    /** Update user */
+    update(id: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Delete user */
+    delete(id: string): 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;
+}
+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>;
+    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"];
+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[];
+}
+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;
+}
+interface WorkflowProgressEvent {
+    stepId: string;
+    status: string;
+    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;
+}
+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;
+
+interface CacheStats {
+    enabled: boolean;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    size: number;
+    memory?: {
+        usedMB: number;
+        maxMB: number;
+        percentage: number;
+    };
+}
+interface CacheInvalidationResult {
+    success: boolean;
+    message: string;
+    pattern: string;
+}
+declare class CacheResource {
+    private client;
+    constructor(client: BackflowClient);
+    getStats(): Promise<CacheStats>;
+    flush(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    invalidate(pattern: string): Promise<CacheInvalidationResult>;
+    invalidateRoute(method: string, path: string): Promise<CacheInvalidationResult>;
+    resetStats(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+
+type Environment = 'development' | 'staging' | 'production';
+interface TenantConfigData {
+    name?: string;
+    environment?: Environment;
+    routes?: unknown[];
+    integrations?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+    database?: Record<string, unknown>;
+    notifications?: Record<string, unknown>;
+    rateLimit?: Record<string, unknown>;
+    webhooks?: Record<string, unknown>;
+    cache?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface TenantConfigResponse {
+    name?: string;
+    environment?: Environment;
+    config: TenantConfigData;
+    version: number;
+    updatedAt: string;
+    planTier?: string;
+    isolationLevel?: string;
+}
+interface SecretMetadata {
+    key: string;
+    type?: string;
+    provider?: string;
+    description?: string;
+    createdAt: string;
+    expiresAt?: string;
+}
+interface ApiKeyMetadata {
+    id: string;
+    keyPrefix: string;
+    name: string;
+    scopes: string[];
+    expiresAt?: string;
+    lastUsedAt?: string;
+    useCount: number;
+    createdAt: string;
+    isActive: boolean;
+}
+interface CreateApiKeyResult {
+    id: string;
+    key: string;
+    prefix: string;
+    name: string;
+    scopes: string[];
+    expiresAt?: string;
+}
+interface TenantDomain {
+    domain: string;
+    type: 'primary' | 'alias';
+    verified: boolean;
+    verificationToken?: string;
+    verificationMethod?: 'dns' | 'http';
+    sslStatus: 'pending' | 'active' | 'failed';
+    createdAt: string;
+    updatedAt?: string;
+}
+interface VerificationInstructions {
+    method: 'dns' | 'http';
+    domain: string;
+    dnsRecord?: {
+        type: string;
+        name: string;
+        value: string;
+    };
+    httpPath?: string;
+    httpContent?: string;
+}
+interface AddDomainResult {
+    domain: TenantDomain;
+    verificationInstructions: VerificationInstructions;
+}
+interface TenantApp {
+    id: string;
+    name: string;
+    parentTenantId?: string;
+    planTier: string;
+    createdAt: string;
+    isActive: boolean;
+    environment?: string;
+    createdBy?: string;
+    createdFor?: string;
+    isNewTenant?: boolean;
+}
+interface CreateAppOptions {
+    name: string;
+    environment?: 'development' | 'staging' | 'production';
+    config?: Record<string, unknown>;
+}
+interface UpdateSettingsOptions {
+    name?: string;
+    environment?: 'development' | 'staging' | 'production';
+}
+interface UpdateSettingsResponse {
+    success: boolean;
+    version: number;
+    message: string;
+}
+interface AppUsage {
+    current: number;
+    limit: number;
+    percentage: number;
+    planTier: string;
+    canCreate: boolean;
+}
+interface TenantRole {
+    name: string;
+    description?: string;
+    permissions: string[];
+    parentRole?: string;
+}
+interface TenantRBACConfig {
+    enabled: boolean;
+    roles: TenantRole[];
+    defaultRole?: string;
+}
+type GateAction = 'login' | 'upgrade';
+interface EntityLimitConfig {
+    limit: number;
+    gateAction?: GateAction;
+    tiers?: Record<string, number>;
+    scope?: 'user' | 'tenant';
+}
+interface UserLimitsConfig {
+    enabled: boolean;
+    defaultGateAction: GateAction;
+    entityLimits?: Record<string, EntityLimitConfig>;
+}
+interface UsageStats {
+    collection: string;
+    current: number;
+    limit: number;
+    percentage: number;
+    gateAction: GateAction;
+}
+interface CheckLimitResult {
+    allowed: boolean;
+    gateAction: GateAction;
+    reason?: string;
+    usage: {
+        current: number;
+        limit: number;
+    };
+    upgrade?: {
+        tier: string;
+        newLimit: number;
+    };
+}
+interface StorageTierLimit {
+    maxStorageMB: number;
+    maxFileSizeMB?: number;
+}
+interface StorageLimitsConfig {
+    enabled: boolean;
+    scope: 'user' | 'tenant';
+    tiers?: Record<string, StorageTierLimit>;
+    gateAction: GateAction;
+}
+interface StorageUsageStats {
+    currentBytes: number;
+    currentMB: number;
+    limitMB: number;
+    percentage: number;
+    fileCount: number;
+    gateAction: GateAction;
+}
+interface StorageCheckResult {
+    allowed: boolean;
+    gateAction: GateAction;
+    reason?: string;
+    usage: {
+        currentMB: number;
+        limitMB: number;
+    };
+    upgrade?: {
+        tier: string;
+        newLimitMB: number;
+    };
+}
+interface StorageByUser {
+    userId: string;
+    totalBytes: number;
+    totalMB: number;
+    fileCount: number;
+}
+type MetricType = 'count' | 'tokens' | 'cost' | 'bytes' | 'connections' | 'duration' | 'requests';
+type PeriodType = 'minute' | 'hour' | 'day' | 'month';
+type ResourceGateAction = 'block' | 'warn' | 'upgrade';
+type ResourceScope = 'user' | 'tenant';
+type ResourceCategory = 'compute' | 'storage' | 'network' | 'ai' | 'custom';
+interface ResourceDefinition {
+    resource: string;
+    metrics: MetricType[];
+    description: string;
+    category: ResourceCategory;
+}
+interface ResourceLimitConditions {
+    roles?: string[];
+    userTier?: string;
+}
+interface ResourceLimit {
+    resource: string;
+    metric: MetricType;
+    period: PeriodType;
+    limit: number;
+    scope?: ResourceScope;
+    tiers?: Record<string, number>;
+    conditions?: ResourceLimitConditions;
+    gateAction?: ResourceGateAction;
+}
+interface ResourceUsageStats {
+    resource: string;
+    metric: MetricType;
+    period: PeriodType;
+    current: number;
+    limit: number;
+    percentage: number;
+    scope: ResourceScope;
+}
+interface ResourceCheckResult {
+    allowed: boolean;
+    gateAction: ResourceGateAction;
+    reason?: string;
+    usage: {
+        current: number;
+        limit: number;
+    };
+    upgrade?: {
+        tier: string;
+        newLimit: number;
+    };
+    warning?: boolean;
+}
+interface ResourceCheckContext {
+    roles?: string[];
+    userTier?: string;
+}
+declare class TenantResource {
+    private client;
+    constructor(client: BackflowClient);
+    getConfig(): Promise<TenantConfigResponse>;
+    updateConfig(config: Partial<TenantConfigData>, options?: {
+        planTier?: string;
+        isolationLevel?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<TenantConfigResponse>;
+    updateSettings(settings: UpdateSettingsOptions): Promise<UpdateSettingsResponse>;
+    get secrets(): SecretsResource;
+    get apiKeys(): ApiKeysResource;
+    get cache(): CacheResource;
+    get domains(): DomainsResource;
+    get apps(): AppsResource;
+    get limits(): LimitsResource;
+    get workflows(): TenantWorkflowsResource;
+    get integrations(): TenantIntegrationsResource;
+    get jobs(): TenantJobsResource;
+    get rbac(): RBACResource;
+}
+declare class SecretsResource {
+    private client;
+    constructor(client: BackflowClient);
+    set(key: string, value: string, metadata?: {
+        type?: string;
+        provider?: string;
+        description?: string;
+    }, expiresAt?: string): Promise<{
+        success: boolean;
+    }>;
+    list(): Promise<SecretMetadata[]>;
+    delete(key: string): Promise<{
+        success: boolean;
+    }>;
+    rotate(key: string, newValue: string, gracePeriodDays?: number): Promise<{
+        success: boolean;
+    }>;
+}
+declare class ApiKeysResource {
+    private client;
+    constructor(client: BackflowClient);
+    create(name: string, options?: {
+        scopes?: string[];
+        expiresAt?: Date;
+    }): Promise<CreateApiKeyResult>;
+    list(): Promise<ApiKeyMetadata[]>;
+    revoke(keyId: string): Promise<{
+        success: boolean;
+    }>;
+    rotate(keyId: string, gracePeriodDays?: number): Promise<CreateApiKeyResult>;
+}
+declare class DomainsResource {
+    private client;
+    constructor(client: BackflowClient);
+    list(): Promise<TenantDomain[]>;
+    add(domain: string, type?: 'primary' | 'alias'): Promise<AddDomainResult>;
+    remove(domain: string): Promise<{
+        success: boolean;
+    }>;
+    verify(domain: string): Promise<{
+        verified: boolean;
+        message?: string;
+    }>;
+    getVerificationInstructions(domain: string): Promise<VerificationInstructions>;
+}
+declare class AppsResource {
+    private client;
+    constructor(client: BackflowClient);
+    list(): Promise<TenantApp[]>;
+    create(options: CreateAppOptions): Promise<TenantApp>;
+    delete(appId: string): Promise<{
+        success: boolean;
+    }>;
+    getUsage(): Promise<AppUsage>;
+}
+declare class LimitsResource {
+    private client;
+    constructor(client: BackflowClient);
+    get(): Promise<UserLimitsConfig>;
+    update(config: Partial<UserLimitsConfig>): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getLimit(collection: string): Promise<EntityLimitConfig | null>;
+    setLimit(collection: string, config: EntityLimitConfig): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    deleteLimit(collection: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getUsage(userId?: string): Promise<Record<string, UsageStats>>;
+    check(userId: string, collection: string, action: 'create', userTier?: string): Promise<CheckLimitResult>;
+    get storage(): StorageLimitsResource;
+    get resources(): ResourceLimitsResource;
+}
+declare class StorageLimitsResource {
+    private client;
+    constructor(client: BackflowClient);
+    getConfig(): Promise<StorageLimitsConfig | null>;
+    updateConfig(config: Partial<StorageLimitsConfig>): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getUsage(userId?: string, userTier?: string): Promise<StorageUsageStats | null>;
+    check(userId: string, fileSizeBytes: number, userTier?: string): Promise<StorageCheckResult>;
+    getByUser(): Promise<StorageByUser[]>;
+}
+declare class ResourceLimitsResource {
+    private client;
+    constructor(client: BackflowClient);
+    getConfig(): Promise<ResourceLimit[]>;
+    updateConfig(limits: ResourceLimit[]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getDefinitions(): Promise<ResourceDefinition[]>;
+    getUsage(userId?: string, resource?: string): Promise<ResourceUsageStats[]>;
+    check(resource: string, metric: MetricType, options?: {
+        userId?: string;
+        amount?: number;
+        context?: ResourceCheckContext;
+    }): Promise<ResourceCheckResult>;
+    track(resource: string, metric: MetricType, options?: {
+        userId?: string;
+        amount?: number;
+    }): Promise<{
+        success: boolean;
+    }>;
+}
+interface TenantWorkflowDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    tools?: unknown[];
+    workflows?: unknown[];
+    trigger?: {
+        type: 'manual' | 'event' | 'schedule' | 'webhook';
+        config?: unknown;
+    };
+    [key: string]: unknown;
+}
+interface TenantWorkflow {
+    id: string;
+    tenantId: string;
+    workflowId: string;
+    name: string;
+    description?: string;
+    triggerType: 'manual' | 'event' | 'schedule' | 'webhook';
+    isActive: boolean;
+    version: number;
+    definition: TenantWorkflowDefinition;
+    isDefault?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+declare class TenantWorkflowsResource {
+    private client;
+    constructor(client: BackflowClient);
+    list(): Promise<TenantWorkflow[]>;
+    get(workflowId: string): Promise<TenantWorkflow>;
+    save(definition: TenantWorkflowDefinition): Promise<TenantWorkflow>;
+    delete(workflowId: string): Promise<{
+        success: boolean;
+    }>;
+    cloneFromDefault(workflowId: string): Promise<TenantWorkflow>;
+}
+interface TenantIntegrationDefinition {
+    name: string;
+    displayName?: string;
+    description?: string;
+    version?: string;
+    baseUrl: string;
+    auth?: {
+        type: 'none' | 'bearer' | 'api_key' | 'oauth2' | 'basic';
+        [key: string]: unknown;
+    };
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+    endpoints?: unknown[];
+    [key: string]: unknown;
+}
+interface TenantIntegration {
+    id: string;
+    tenantId: string;
+    integrationId: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    baseUrl: string;
+    authType: 'none' | 'bearer' | 'api_key' | 'oauth2' | 'basic';
+    isActive: boolean;
+    version: number;
+    definition: TenantIntegrationDefinition;
+    isDefault?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+declare class TenantIntegrationsResource {
+    private client;
+    constructor(client: BackflowClient);
+    list(): Promise<TenantIntegration[]>;
+    get(integrationId: string): Promise<TenantIntegration>;
+    save(definition: TenantIntegrationDefinition): Promise<TenantIntegration>;
+    delete(integrationId: string): Promise<{
+        success: boolean;
+    }>;
+    cloneFromDefault(integrationId: string): Promise<TenantIntegration>;
+}
+interface TenantJobDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    queueName: string;
+    handler: string;
+    defaultOptions?: {
+        attempts?: number;
+        backoff?: {
+            type: 'exponential' | 'fixed';
+            delay: number;
+        };
+        delay?: number;
+        priority?: number;
+        timeout?: number;
+    };
+    defaultPayload?: unknown;
+}
+interface TenantJobDef {
+    id: string;
+    tenantId: string;
+    jobDefId: string;
+    name: string;
+    description?: string;
+    queueName: string;
+    handler: string;
+    defaultOptions?: TenantJobDefinition['defaultOptions'];
+    defaultPayload?: unknown;
+    isActive: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface TenantJobExecution {
+    id: string;
+    tenantId: string;
+    jobDefId: string;
+    jobId: string;
+    queueName: string;
+    status: 'pending' | 'active' | 'completed' | 'failed' | 'delayed';
+    payload: unknown;
+    result?: unknown;
+    error?: string;
+    attempts: number;
+    startedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+}
+declare class TenantJobsResource {
+    private client;
+    constructor(client: BackflowClient);
+    listDefinitions(): Promise<TenantJobDef[]>;
+    getDefinition(jobDefId: string): Promise<TenantJobDef>;
+    saveDefinition(definition: TenantJobDefinition): Promise<TenantJobDef>;
+    deleteDefinition(jobDefId: string): Promise<{
+        success: boolean;
+    }>;
+    enqueue(jobDefId: string, payload?: unknown, options?: {
+        delay?: number;
+        priority?: number;
+    }): Promise<TenantJobExecution>;
+    listHistory(options?: {
+        jobDefId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<TenantJobExecution[]>;
+}
+declare class RBACResource {
+    private client;
+    constructor(client: BackflowClient);
+    getConfig(): Promise<TenantRBACConfig>;
+    updateConfig(config: Partial<TenantRBACConfig>): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    listRoles(): Promise<TenantRole[]>;
+    createRole(role: TenantRole): Promise<{
+        success: boolean;
+        message: string;
+        role: TenantRole;
+    }>;
+    updateRole(name: string, updates: Omit<TenantRole, 'name'>): Promise<{
+        success: boolean;
+        message: string;
+        role: TenantRole;
+    }>;
+    deleteRole(name: string): Promise<{
+        success: boolean;
+        message: 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>;
+}
+
+declare class IntegrationsResource {
+    private client;
+    readonly stripe: StripeResource;
+    readonly polar: PolarResource;
+    constructor(client: BackflowClient);
+}
+declare class BackflowSDK {
+    private client;
+    readonly agentAnalysis: AgentAnalysisResource;
+    readonly apikeys: ApiKeysResource$1;
+    readonly apps: AppsResource$1;
+    readonly assets: AssetsResource;
+    readonly authentication: AuthenticationResource;
+    readonly billing: BillingResource;
+    readonly cache: CacheResource$1;
+    readonly config: ConfigResource;
+    readonly default: DefaultResource;
+    readonly deployment: DeploymentResource;
+    readonly domains: DomainsResource$1;
+    readonly feedback: FeedbackResource;
+    readonly goals: GoalsResource;
+    readonly googleDrive: GoogleDriveResource;
+    readonly jira: JiraResource;
+    readonly llm: LlmResource;
+    readonly mcptools: McpToolsResource;
+    readonly mfa: MfaResource;
+    readonly migration: MigrationResource;
+    readonly projects: ProjectsResource;
+    readonly publish: PublishResource;
+    readonly secrets: SecretsResource$1;
+    readonly system: SystemResource;
+    readonly teams: TeamsResource;
+    readonly tenantIntegrations: TenantIntegrationsResource$1;
+    readonly tenantJobs: TenantJobsResource$1;
+    readonly tenantLimits: TenantLimitsResource;
+    readonly tenantRbac: TenantRbacResource;
+    readonly tenantWebhookReceivers: TenantWebhookReceiversResource;
+    readonly tenantWebhooks: TenantWebhooksResource;
+    readonly tenantWorkflows: TenantWorkflowsResource$1;
+    readonly tooldiscovery: ToolDiscoveryResource;
+    readonly tracking: TrackingResource;
+    readonly twitter: TwitterResource;
+    readonly users: UsersResource;
+    readonly websocket: WebsocketResource;
+    readonly workspaces: WorkspacesResource;
+    readonly integrations: IntegrationsResource;
+    readonly files: FilesResource;
+    readonly workflows: WorkflowsResource;
+    readonly tenant: TenantResource;
+    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 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;
+
+export { AgentAnalysisResource, AnalyticsResource$1 as AnalyticsResource, ApiKeysResource$1 as ApiKeysResource, AppsResource$1 as AppsResource, AssetsResource, AuthenticationResource, BackflowSDK as Backflow, BackflowClient, type BackflowConfig, type BackflowError, type BackflowResponse, BackflowSDK, type BackflowSDKWithDynamicResources, BillingResource, CACHE_OPERATIONS, CHUNKING_STRATEGIES, CLI_PROVIDERS, CONDITION_OPERATORS, CacheResource$1 as CacheResource, ConfigResource, DB_OPERATIONS, DB_PROVIDERS, type DatabaseFilter, type DatabaseFilterOperator, type DatabaseIntegrationAction, type DatabaseProvider, DefaultResource, DeploymentResource, DomainsResource$1 as DomainsResource, 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, MfaResource, MigrationResource, 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, SecretsResource$1 as SecretsResource, StripeResource, SystemResource, TOOL_PARAM_CONTEXT, TOOL_TYPES, TRIGGER_TYPES, TeamsResource, TenantIntegrationsResource$1 as TenantIntegrationsResource, TenantJobsResource$1 as TenantJobsResource, TenantLimitsResource, TenantRbacResource, TenantWebhookReceiversResource, TenantWebhooksResource, TenantWorkflowsResource$1 as TenantWorkflowsResource, ToolDiscoveryResource, type ToolType, TrackingResource, type TriggerType, TwitterResource, UsageResource$1 as UsageResource, UsersResource, WORKFLOW_VALIDATION_SCHEMA, WebsocketResource, type WorkflowValidationSchema, WorkflowsResource$1 as WorkflowsResource, WorkspacesResource, createBackflow, toCompactContext, toPromptContext };