@backflow.sdk/admin 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3568 @@
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://api.backflow.dev";
+var BackflowClient = class {
+  constructor(config) {
+    this.tokenCache = null;
+    this.tokenPromise = null;
+    const clientKey = config.clientKey;
+    if (!clientKey && !config.getAuthToken) {
+      throw new Error("Either clientKey or getAuthToken is required");
+    }
+    this.config = {
+      ...config,
+      clientKey,
+      endpoint: config.endpoint?.replace(/\/$/, "") || DEFAULT_ENDPOINT
+    };
+  }
+  async exchangeApiKeyForToken() {
+    const response = await fetch(`${this.config.endpoint}/auth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.config.clientKey
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Token exchange failed" }));
+      throw new Error(error.error || "Failed to exchange API key for token");
+    }
+    const data = await response.json();
+    const expiresAt = Date.now() + data.expiresIn * 1e3 * 0.8;
+    return { token: data.token, expiresAt };
+  }
+  async getToken() {
+    if (this.config.getAuthToken) {
+      return this.config.getAuthToken();
+    }
+    if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
+      return this.tokenCache.token;
+    }
+    if (this.tokenPromise) {
+      const cache = await this.tokenPromise.then(() => this.tokenCache);
+      return cache.token;
+    }
+    this.tokenPromise = this.exchangeApiKeyForToken().then((cache) => {
+      this.tokenCache = cache;
+      this.tokenPromise = null;
+      return cache.token;
+    }).catch((err) => {
+      this.tokenPromise = null;
+      throw err;
+    });
+    return this.tokenPromise;
+  }
+  get endpoint() {
+    return this.config.endpoint;
+  }
+  async request(path, options = {}) {
+    const { params, body, ...fetchOptions } = options;
+    const startTime = Date.now();
+    const debug = this.config.debug ?? false;
+    let ctx = {
+      method: fetchOptions.method || "GET",
+      path,
+      params,
+      body,
+      startTime
+    };
+    if (this.config.middleware?.onRequest) {
+      const result = await this.config.middleware.onRequest(ctx);
+      if (result) ctx = result;
+    }
+    let url = `${this.config.endpoint}${ctx.path}`;
+    if (ctx.params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(ctx.params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...fetchOptions.headers || {}
+    };
+    const token = await this.getToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (debug) {
+      console.log(`[Backflow] \u2192 ${ctx.method} ${url}`);
+      console.log(
+        `[Backflow] clientKey: ${this.config.clientKey ? "***" : "(not set)"}`
+      );
+      if (ctx.body) console.log("[Backflow] Request body:", ctx.body);
+    }
+    let response;
+    let responseData;
+    let error;
+    try {
+      response = await fetch(url, {
+        ...fetchOptions,
+        headers,
+        body: ctx.body ? JSON.stringify(ctx.body) : void 0
+      });
+      if (!response.ok) {
+        error = new Error(
+          `Request failed: ${response.status}`
+        );
+        error.status = response.status;
+        try {
+          const errorBody = await response.json();
+          error.code = errorBody.code;
+          error.details = errorBody;
+          error.message = errorBody.message || errorBody.error || error.message;
+        } catch {
+        }
+      } else {
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          responseData = await response.json();
+        } else {
+          responseData = await response.text();
+        }
+      }
+    } catch (e) {
+      error = e;
+      error.status = 0;
+    }
+    const duration = Date.now() - startTime;
+    if (debug) {
+      const status = error?.status ?? response.status;
+      if (error) console.log("[Backflow] Error:", error.message);
+      else console.log("[Backflow] Response:", responseData);
+    }
+    if (this.config.middleware?.onResponse) {
+      const resCtx = {
+        ...ctx,
+        status: error?.status ?? response.status,
+        duration,
+        response: responseData,
+        error
+      };
+      await this.config.middleware.onResponse(resCtx);
+    }
+    if (error) throw error;
+    return responseData;
+  }
+  async get(path, params) {
+    return this.request(path, { method: "GET", params });
+  }
+  async post(path, body, params) {
+    return this.request(path, { method: "POST", body, params });
+  }
+  async put(path, body, params) {
+    return this.request(path, { method: "PUT", body, params });
+  }
+  async patch(path, body, params) {
+    return this.request(path, { method: "PATCH", body, params });
+  }
+  async delete(path, params) {
+    return this.request(path, { method: "DELETE", params });
+  }
+  async upload(path, files, metadata) {
+    const formData = new FormData();
+    const fileArray = Array.isArray(files) ? files : [files];
+    const fieldName = fileArray.length === 1 ? "file" : "files";
+    fileArray.forEach((file) => formData.append(fieldName, file));
+    if (metadata) {
+      Object.entries(metadata).forEach(([key, value]) => {
+        formData.append(key, value);
+      });
+    }
+    const url = `${this.config.endpoint}${path}`;
+    const uploadHeaders = {};
+    const token = await this.getToken();
+    if (token) {
+      uploadHeaders["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: uploadHeaders,
+      body: formData
+    });
+    if (!response.ok) {
+      const error = new Error(
+        `Upload failed: ${response.status}`
+      );
+      error.status = response.status;
+      try {
+        const errorBody = await response.json();
+        error.code = errorBody.code;
+        error.details = errorBody;
+        error.message = errorBody.message || errorBody.error || error.message;
+      } catch {
+      }
+      throw error;
+    }
+    return response.json();
+  }
+  createWebSocket(room) {
+    const wsEndpoint = this.config.endpoint.replace("http", "ws");
+    const ws = new WebSocket(`${wsEndpoint}/ws`);
+    ws.onopen = async () => {
+      const token = await this.getToken();
+      ws.send(JSON.stringify({ type: "auth", token }));
+      ws.send(JSON.stringify({ type: "join_room", room }));
+    };
+    return ws;
+  }
+  subscribeSSE(path, handlers) {
+    const es = new EventSource(`${this.config.endpoint}${path}`);
+    es.addEventListener("connected", () => handlers.onConnected?.());
+    es.addEventListener("completed", (e) => {
+      const data = JSON.parse(e.data);
+      handlers.onComplete?.(data);
+      es.close();
+    });
+    es.addEventListener("failed", (e) => {
+      const data = JSON.parse(e.data);
+      handlers.onFailed?.(data.error || data.message);
+      es.close();
+    });
+    es.addEventListener("progress", (e) => {
+      const data = JSON.parse(e.data);
+      handlers.onProgress?.(data.progress, data.message);
+    });
+    es.addEventListener("warning", (e) => {
+      handlers.onWarning?.(e.data);
+    });
+    es.onerror = (e) => {
+      handlers.onError?.(e);
+      es.close();
+    };
+    return () => es.close();
+  }
+};
+
+// src/generated/agent-analysis.ts
+var AgentAnalysisResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Retrieve cached analysis results from a previous scan */
+  async get(executionId) {
+    return this.client.get(`/agent/analysis/${executionId}`);
+  }
+  /** Apply fixes from cached analysis. In hybrid mode, returns fix instructions for local MCP execution. */
+  async createApply(executionId, data) {
+    return this.client.post(`/agent/analysis/${executionId}/apply`, data);
+  }
+};
+
+// src/generated/analytics.ts
+var AnalyticsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get high-level analytics overview (tenant-isolated) */
+  async list() {
+    return this.client.get("/analytics/overview");
+  }
+  /** Get endpoint statistics (tenant-isolated) */
+  async listEndpoints() {
+    return this.client.get("/analytics/endpoints");
+  }
+  /** Get recent errors (tenant-isolated) */
+  async listErrors() {
+    return this.client.get("/analytics/errors");
+  }
+  /** Get device type breakdown (tenant-isolated) */
+  async listDevices() {
+    return this.client.get("/analytics/devices");
+  }
+  /** Get geographic distribution of requests (tenant-isolated) */
+  async listGeography() {
+    return this.client.get("/analytics/geography");
+  }
+  /** Get time series data (tenant-isolated) */
+  async listTimeseries() {
+    return this.client.get("/analytics/timeseries");
+  }
+  /** Get endpoints that haven't been called recently (tenant-isolated) */
+  async listUnusedEndpoints() {
+    return this.client.get("/analytics/unused-endpoints");
+  }
+};
+
+// src/generated/apikeys.ts
+var ApiKeysResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List API keys */
+  async list() {
+    return this.client.get("/tenant/api-keys");
+  }
+  /** Create API key */
+  async create(data) {
+    return this.client.post("/tenant/api-keys", data);
+  }
+  /** Revoke API key */
+  async delete(keyId) {
+    return this.client.delete(`/tenant/api-keys/${keyId}`);
+  }
+  /** Rotate API key */
+  async rotate(keyId, data) {
+    return this.client.post(`/tenant/api-keys/${keyId}/rotate`, data);
+  }
+};
+
+// src/generated/apps.ts
+var AppsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new app (available to all authenticated users) */
+  async create(data) {
+    return this.client.post("/public/apps/create", data);
+  }
+  /** Get current app usage and limits */
+  async list() {
+    return this.client.get("/public/apps/usage");
+  }
+  /** Update app settings (name and environment only) */
+  async patch(data) {
+    return this.client.patch("/public/app/settings", data);
+  }
+};
+
+// src/generated/assets.ts
+var AssetsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Upload asset to R2 with Firebase metadata */
+  async create(data) {
+    return this.client.post("/assets/upload", data);
+  }
+  /** List user assets */
+  async list() {
+    return this.client.get("/assets");
+  }
+  /** Get asset by ID */
+  async get(id) {
+    return this.client.get(`/assets/${id}`);
+  }
+  /** Delete asset from R2 and Firebase */
+  async delete(id) {
+    return this.client.delete(`/assets/${id}`);
+  }
+  /** Update asset metadata */
+  async updateMetadata(id, data) {
+    return this.client.put(`/assets/${id}/metadata`, data);
+  }
+};
+
+// src/generated/authentication.ts
+var AuthenticationResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Login with email and password. Returns JWT token if MFA is disabled, or requires MFA verification if enabled. */
+  async create(data) {
+    return this.client.post("/auth/login", data);
+  }
+  /** Complete login with MFA verification. Supports TOTP tokens and backup codes. */
+  async createMfa(data) {
+    return this.client.post("/auth/login/mfa", data);
+  }
+  /** Verify MFA token without full login. Production endpoint for token validation. */
+  async createVerifyMfaToken(data) {
+    return this.client.post("/auth/verify-mfa-token", data);
+  }
+  /** Switch to a different tenant. Returns a new JWT with tenantId claim. */
+  async createSwitchTenant(data) {
+    return this.client.post("/auth/switch-tenant", data);
+  }
+  /** Exchange API key for JWT token. Used by SDK for programmatic access. */
+  async createToken(data) {
+    return this.client.post("/auth/token", data);
+  }
+  /** Request password reset email */
+  async createForgotPassword(data) {
+    return this.client.post("/api/auth/forgot-password", data);
+  }
+  /** Verify password reset token is valid */
+  async createVerifyResetToken(data) {
+    return this.client.post("/auth/verify-reset-token", data);
+  }
+  /** Reset password with valid token */
+  async createResetPassword(data) {
+    return this.client.post("/auth/reset-password", data);
+  }
+};
+
+// src/generated/billing.ts
+var BillingResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all available billing plans with feature limits */
+  async list() {
+    return this.client.get("/billing/plans");
+  }
+  /** Get current usage statistics against plan limits (tenant-isolated) */
+  async listUsage() {
+    return this.client.get("/billing/usage");
+  }
+  /** Get current subscription status and details (tenant-isolated) */
+  async listSubscription() {
+    return this.client.get("/billing/subscription");
+  }
+  /** Request to upgrade to a different plan (tenant-isolated) */
+  async create(data) {
+    return this.client.post("/billing/upgrade", data);
+  }
+  /** List products from tenant's Polar organization */
+  async listProducts() {
+    return this.client.get("/billing/tenant/products");
+  }
+  /** Create a product in tenant's Polar organization */
+  async createProducts(data) {
+    return this.client.post("/billing/tenant/products", data);
+  }
+  /** Create a checkout session for a user in tenant's Polar org */
+  async createCheckout(data) {
+    return this.client.post("/billing/tenant/checkout", data);
+  }
+  /** List customers from tenant's Polar organization */
+  async listCustomers() {
+    return this.client.get("/billing/tenant/customers");
+  }
+  /** List subscriptions from tenant's Polar organization */
+  async listSubscriptions() {
+    return this.client.get("/billing/tenant/subscriptions");
+  }
+  /** Cancel a subscription in tenant's Polar organization */
+  async delete(id) {
+    return this.client.delete(`/billing/tenant/subscriptions/${id}`);
+  }
+  /** Get customer subscription state from tenant's Polar organization */
+  async state(id) {
+    return this.client.get(`/billing/tenant/customers/${id}/state`);
+  }
+  /** Stripe webhook handler for subscription events */
+  async createStripe(data) {
+    return this.client.post("/webhooks/billing/stripe", data);
+  }
+  /** Polar webhook handler for subscription events */
+  async createPolar(data) {
+    return this.client.post("/webhooks/billing/polar", data);
+  }
+};
+
+// src/generated/cache.ts
+var CacheResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get cache statistics including hit rate, memory usage, and item count */
+  async list() {
+    return this.client.get("/cache/stats");
+  }
+  /** Clear all items from the cache and reset statistics */
+  async delete() {
+    return this.client.delete("/cache/flush");
+  }
+  /** Invalidate all cache entries that match a given pattern */
+  async create(data) {
+    return this.client.post("/cache/invalidate", data);
+  }
+  /** Reset cache hit/miss statistics while preserving cached data */
+  async createResetStats(data) {
+    return this.client.post("/cache/reset-stats", data);
+  }
+};
+
+// src/generated/config.ts
+var ConfigResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get active tenant configuration */
+  async list() {
+    return this.client.get("/tenant/config");
+  }
+  /** Upload or update tenant configuration */
+  async create(data) {
+    return this.client.post("/tenant/config", data);
+  }
+  /** List configuration versions */
+  async listVersions() {
+    return this.client.get("/tenant/config/versions");
+  }
+  /** Rollback configuration */
+  async createRollback(version, data) {
+    return this.client.post(`/tenant/config/rollback/${version}`, data);
+  }
+  /** Get available webhook events */
+  async listEvents() {
+    return this.client.get("/tenant/events");
+  }
+};
+
+// src/generated/default.ts
+var DefaultResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** GET /tenant/debug/raw-query */
+  async list() {
+    return this.client.get("/tenant/debug/raw-query");
+  }
+};
+
+// src/generated/deployment.ts
+var DeploymentResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get deployment information */
+  async list() {
+    return this.client.get("/deployment");
+  }
+  /** Get server information */
+  async listServer() {
+    return this.client.get("/deployment/server");
+  }
+  /** Get full deployment status */
+  async listStatus() {
+    return this.client.get("/deployment/status");
+  }
+  /** Get Cloud Run service URL */
+  async listUrl() {
+    return this.client.get("/deployment/url");
+  }
+  /** Server-Sent Events (SSE) stream for real-time deployment status updates. Sends periodic status updates and heartbeats. */
+  async listStream() {
+    return this.client.get("/deployment/stream");
+  }
+  /** Filtered Server-Sent Events (SSE) stream for specific deployment event types. Filter by status, server, or url events. */
+  async listEvents() {
+    return this.client.get("/deployment/events");
+  }
+};
+
+// src/generated/domains.ts
+var DomainsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List domains */
+  async list() {
+    return this.client.get("/tenant/domains");
+  }
+  /** Add domain */
+  async create(data) {
+    return this.client.post("/tenant/domains", data);
+  }
+  /** Remove domain */
+  async delete(domain) {
+    return this.client.delete(`/tenant/domains/${domain}`);
+  }
+  /** Verify domain */
+  async createVerify(domain, data) {
+    return this.client.post(`/tenant/domains/${domain}/verify`, data);
+  }
+  /** Get verification instructions */
+  async verification(domain) {
+    return this.client.get(`/tenant/domains/${domain}/verification`);
+  }
+};
+
+// src/generated/embeddings.ts
+var EmbeddingsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all embedded documents with chunk counts and metadata */
+  async list() {
+    return this.client.get("/agent/embeddings/documents");
+  }
+  /** Upload and process a document for vector embeddings with automatic chunking. Supports various content types (code, documentation, articles) with optimized chunking strategies for RAG. */
+  async create(data) {
+    return this.client.post("/agent/embeddings/document", data);
+  }
+  /** Search within a specific document using semantic similarity. Performs vector search within document chunks. */
+  async search(documentId) {
+    return this.client.get(`/agent/embeddings/document/${documentId}/search`);
+  }
+  /** Search across all embedded documents using semantic similarity */
+  async listSearch() {
+    return this.client.get("/agent/embeddings/search");
+  }
+  /** Delete all chunks and embeddings for a document. Removes the document from the vector store. */
+  async delete(documentId) {
+    return this.client.delete(`/agent/embeddings/document/${documentId}`);
+  }
+  /** 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. */
+  async createBatch(data) {
+    return this.client.post("/agent/embeddings/batch", data);
+  }
+};
+
+// src/generated/feedback.ts
+var FeedbackResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Submit feedback for a workflow execution. Used to optimize and improve workflow performance based on user ratings and suggestions. */
+  async create(data) {
+    return this.client.post("/agent/feedback", data);
+  }
+  /** Get feedback trends and analytics. Analyzes workflow feedback to identify patterns and areas for improvement. */
+  async list() {
+    return this.client.get("/agent/feedback/trends");
+  }
+};
+
+// src/generated/files.ts
+var FilesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Upload a single file with entity association and tenant isolation */
+  async create(data) {
+    return this.client.post("/files/upload", data);
+  }
+  /** Upload multiple files with entity association and tenant isolation */
+  async createUploadMultiple(data) {
+    return this.client.post("/files/upload-multiple", data);
+  }
+  /** List files for an entity with pagination */
+  async get(entityType, entityId) {
+    return this.client.get(`/files/entity/${entityType}/${entityId}`);
+  }
+  /** Delete all files for an entity */
+  async delete(entityType, entityId) {
+    return this.client.delete(`/files/entity/${entityType}/${entityId}`);
+  }
+  /** Download file via secure signed URL redirect (5 minute expiry) */
+  async getDownload(bucket, path) {
+    return this.client.get(`/files/download/${bucket}/${path}`);
+  }
+  /** Get a signed URL for file access (max 30 seconds expiry) */
+  async getSignedUrl(bucket, path) {
+    return this.client.get(`/files/signed-url/${bucket}/${path}`);
+  }
+  /** Delete a file from storage */
+  async deleteDELETE(bucket, path) {
+    return this.client.delete(`/files/${bucket}/${path}`);
+  }
+  /** Upload JSON content to storage */
+  async createUploadJson(data) {
+    return this.client.post("/files/upload-json", data);
+  }
+};
+
+// src/generated/github.ts
+var GithubResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get GitHub repositories for a user */
+  async get(username) {
+    return this.client.get(`/api/github/repos/${username}`);
+  }
+  /** Get file or directory contents from a GitHub repository */
+  async getContent(owner, repo, path) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/contents/${path}`);
+  }
+  /** Create or update a file in a GitHub repository */
+  async updateContent(owner, repo, path, data) {
+    return this.client.put(`/api/github/repos/${owner}/${repo}/contents/${path}`, data);
+  }
+  /** Delete a file from a GitHub repository */
+  async deleteContent(owner, repo, path) {
+    return this.client.delete(`/api/github/repos/${owner}/${repo}/contents/${path}`);
+  }
+  /** Compare two commits and view the diff */
+  async getCompare(owner, repo, basehead) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/compare/${basehead}`);
+  }
+  /** Get a single commit with its changes */
+  async getCommit(owner, repo, ref) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/commits/${ref}`);
+  }
+  /** List commits in a repository */
+  async commits(owner, repo) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/commits`);
+  }
+  /** Get pull request details */
+  async getPull(owner, repo, pull_number) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pull_number}`);
+  }
+  /** List files changed in a pull request with diffs */
+  async files(owner, repo, pull_number) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pull_number}/files`);
+  }
+};
+
+// src/generated/goals.ts
+var GoalsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Configure goal evaluation rules for a workflow. Sets KPIs, success criteria, and evaluation parameters. */
+  async create(data) {
+    return this.client.post("/agent/goal/configure", data);
+  }
+  /** Manually trigger goal evaluation for a workflow. Evaluates workflow performance against configured KPIs and success criteria. */
+  async createEvaluate(workflowId, data) {
+    return this.client.post(`/agent/goal/evaluate/${workflowId}`, data);
+  }
+  /** Get evaluation history for a workflow. Returns all historical goal evaluation records. */
+  async get(workflowId) {
+    return this.client.get(`/agent/goal/history/${workflowId}`);
+  }
+  /** Start scheduled goal evaluation. Automatically evaluates all active workflows at specified intervals. */
+  async createStart(data) {
+    return this.client.post("/agent/goal/schedule/start", data);
+  }
+  /** Stop scheduled goal evaluation. Cancels automatic workflow evaluations. */
+  async createStop(data) {
+    return this.client.post("/agent/goal/schedule/stop", data);
+  }
+  /** Evaluate all active workflows. Generates evaluation reports for all workflows with configured goals. */
+  async createEvaluateAll(data) {
+    return this.client.post("/agent/goal/evaluate-all", data);
+  }
+};
+
+// src/generated/google-drive.ts
+var GoogleDriveResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List files in Google Drive */
+  async list() {
+    return this.client.get("/api/google-drive/files");
+  }
+  /** Get file metadata from Google Drive */
+  async get(fileId) {
+    return this.client.get(`/api/google-drive/files/${fileId}`);
+  }
+  /** Update file metadata (rename, move) */
+  async patch(fileId, data) {
+    return this.client.patch(`/api/google-drive/files/${fileId}`, data);
+  }
+  /** Delete a file from Google Drive */
+  async delete(fileId) {
+    return this.client.delete(`/api/google-drive/files/${fileId}`);
+  }
+  /** Download file content from Google Drive */
+  async download(fileId) {
+    return this.client.get(`/api/google-drive/files/${fileId}/download`);
+  }
+  /** Search for PDF files in Google Drive */
+  async listPdfs() {
+    return this.client.get("/api/google-drive/pdfs");
+  }
+};
+
+// src/generated/jira.ts
+var JiraResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search JIRA issues using JQL */
+  async list() {
+    return this.client.get("/api/jira/issues/search");
+  }
+  /** Get JIRA issue details */
+  async get(issueKey) {
+    return this.client.get(`/api/jira/issues/${issueKey}`);
+  }
+  /** Update a JIRA issue */
+  async update(issueKey, data) {
+    return this.client.put(`/api/jira/issues/${issueKey}`, data);
+  }
+  /** Delete a JIRA issue */
+  async delete(issueKey) {
+    return this.client.delete(`/api/jira/issues/${issueKey}`);
+  }
+  /** Create a new JIRA issue */
+  async create(data) {
+    return this.client.post("/api/jira/issues", data);
+  }
+  /** Get available transitions for a JIRA issue */
+  async transitions(issueKey) {
+    return this.client.get(`/api/jira/issues/${issueKey}/transitions`);
+  }
+  /** Transition a JIRA issue to new status */
+  async createTransition(issueKey, data) {
+    return this.client.post(`/api/jira/issues/${issueKey}/transition`, data);
+  }
+  /** Get comments for a JIRA issue */
+  async comments(issueKey) {
+    return this.client.get(`/api/jira/issues/${issueKey}/comments`);
+  }
+  /** Add comment to a JIRA issue */
+  async createComment(issueKey, data) {
+    return this.client.post(`/api/jira/issues/${issueKey}/comments`, data);
+  }
+  /** Assign a JIRA issue to a user */
+  async updateAssign(issueKey, data) {
+    return this.client.put(`/api/jira/issues/${issueKey}/assign`, data);
+  }
+  /** Get all JIRA projects */
+  async listProjects() {
+    return this.client.get("/api/jira/projects");
+  }
+  /** Get JIRA project details */
+  async getProjects(projectKey) {
+    return this.client.get(`/api/jira/projects/${projectKey}`);
+  }
+  /** Get current authenticated JIRA user */
+  async listMe() {
+    return this.client.get("/api/jira/user/me");
+  }
+  /** Search JIRA users */
+  async listSearch() {
+    return this.client.get("/api/jira/users/search");
+  }
+  /** Get all JIRA issue types */
+  async listIssueTypes() {
+    return this.client.get("/api/jira/metadata/issue-types");
+  }
+  /** Get all JIRA priority levels */
+  async listPriorities() {
+    return this.client.get("/api/jira/metadata/priorities");
+  }
+};
+
+// src/generated/llm.ts
+var LlmResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** POST /llm/stream */
+  async create(data) {
+    return this.client.post("/llm/stream", data);
+  }
+  /** GET /llm/models */
+  async list() {
+    return this.client.get("/llm/models");
+  }
+};
+
+// src/generated/mcptools.ts
+var McpToolsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all available MCP tools from connected servers. Returns tools, connection status, and server information. */
+  async list() {
+    return this.client.get("/agent/mcp/tools");
+  }
+  /** Execute a Model Context Protocol (MCP) tool. MCP tools provide external capabilities like file system access, database queries, and API calls to LLM workflows. */
+  async create(data) {
+    return this.client.post("/agent/mcp/execute", data);
+  }
+};
+
+// src/generated/mfa.ts
+var MfaResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Initialize MFA setup for the authenticated user. Generates TOTP secret, QR code, and backup codes. Requires JWT authentication. */
+  async create(data) {
+    return this.client.post("/mfa/setup", data);
+  }
+  /** Verify MFA setup with a TOTP token from authenticator app and enable MFA for the account. Requires JWT authentication. */
+  async createVerify(data) {
+    return this.client.post("/mfa/verify", data);
+  }
+  /** Disable MFA for the authenticated user. Requires current valid MFA token for security verification. */
+  async createDisable(data) {
+    return this.client.post("/mfa/disable", data);
+  }
+  /** Check MFA status for the authenticated user. Returns whether MFA is enabled and setup dates. */
+  async list() {
+    return this.client.get("/mfa/status");
+  }
+  /** Generate new backup codes for MFA recovery. Invalidates all previous backup codes. Requires current MFA token for security. */
+  async createRegenerateBackupCodes(data) {
+    return this.client.post("/mfa/regenerate-backup-codes", data);
+  }
+  /** Validate an MFA token without side effects. Useful for protecting sensitive operations with MFA verification. */
+  async createValidate(data) {
+    return this.client.post("/mfa/validate", data);
+  }
+};
+
+// src/generated/migration.ts
+var MigrationResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get database migration SQL and instructions */
+  async list() {
+    return this.client.get("/migration");
+  }
+  /** Check if database migration has been applied */
+  async listStatus() {
+    return this.client.get("/migration/status");
+  }
+  /** Get quick migration with RLS disabled for development */
+  async listQuickFix() {
+    return this.client.get("/migration/quick-fix");
+  }
+};
+
+// src/generated/polar.ts
+var PolarResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a Polar checkout session */
+  async create(data) {
+    return this.client.post("/integrations/polar/checkouts", data);
+  }
+  /** Retrieve a Polar checkout session */
+  async get(checkoutId) {
+    return this.client.get(`/integrations/polar/checkouts/${checkoutId}`);
+  }
+  /** Create a Polar subscription */
+  async createSubscriptions(data) {
+    return this.client.post("/integrations/polar/subscriptions", data);
+  }
+  /** Cancel a Polar subscription */
+  async delete(subscriptionId) {
+    return this.client.delete(`/integrations/polar/subscriptions/${subscriptionId}`);
+  }
+  /** List Polar products */
+  async list() {
+    return this.client.get("/integrations/polar/products");
+  }
+  /** Create a Polar product */
+  async createProducts(data) {
+    return this.client.post("/integrations/polar/products", data);
+  }
+  /** Retrieve a Polar order */
+  async getOrders(orderId) {
+    return this.client.get(`/integrations/polar/orders/${orderId}`);
+  }
+  /** Create a Polar benefit */
+  async createBenefits(data) {
+    return this.client.post("/integrations/polar/benefits", data);
+  }
+  /** Grant a Polar benefit to a customer */
+  async createGrants(data) {
+    return this.client.post("/integrations/polar/benefits/grants", data);
+  }
+};
+
+// src/generated/projects.ts
+var ProjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List version history for a project with pagination and date range filter */
+  async versions(id) {
+    return this.client.get(`/projects/${id}/versions`);
+  }
+  /** Create a new project version record (Pro tier) */
+  async createVersion(id, data) {
+    return this.client.post(`/projects/${id}/versions`, data);
+  }
+  /** Delete all versions for a project and their R2 files (parallel) */
+  async deleteAllVersions(id) {
+    return this.client.delete(`/projects/${id}/versions`);
+  }
+  /** Get a specific version record */
+  async getVersion(id, versionId) {
+    return this.client.get(`/projects/${id}/versions/${versionId}`);
+  }
+  /** Delete a specific project version and its R2 files */
+  async deleteVersion(id, versionId) {
+    return this.client.delete(`/projects/${id}/versions/${versionId}`);
+  }
+  /** Rollback project to a previous version (Pro tier) */
+  async rollback(id, version, data) {
+    return this.client.post(`/projects/${id}/rollback/${version}`, data);
+  }
+  /** Save project with parallel R2 uploads and Firestore updates */
+  async updateSave(projectId, data) {
+    return this.client.put(`/projects/${projectId}/save`, data);
+  }
+  /** Save project and execute content as workflow */
+  async saveAndRun(projectId, data) {
+    return this.client.post(`/projects/${projectId}/save-and-run`, data);
+  }
+  /** Get project by ID */
+  async get(id) {
+    return this.client.get(`/projects/${id}`);
+  }
+  /** Update project metadata (title, description, etc.) */
+  async patch(id, data) {
+    return this.client.patch(`/projects/${id}`, data);
+  }
+  /** Delete project and all related files/versions (parallel) */
+  async delete(id) {
+    return this.client.delete(`/projects/${id}`);
+  }
+  /** List all shares for a project */
+  async shares(id) {
+    return this.client.get(`/projects/${id}/shares`);
+  }
+  /** Share a project with another user */
+  async share(id, data) {
+    return this.client.post(`/projects/${id}/share`, data);
+  }
+  /** Remove share access from a user */
+  async deleteShare(id, userId) {
+    return this.client.delete(`/projects/${id}/share/${userId}`);
+  }
+  /** Get public project by ID (no auth required) */
+  async public(projectId) {
+    return this.client.get(`/projects/${projectId}/public`);
+  }
+  /** Toggle project public/private status with optional email notification */
+  async patchPublic(id, data) {
+    return this.client.patch(`/projects/${id}/public`, data);
+  }
+  /** List all projects shared with the current user */
+  async list() {
+    return this.client.get("/projects/shared-with-me");
+  }
+  /** Update project files (add/remove attached assets) */
+  async patchFile(id, data) {
+    return this.client.patch(`/projects/${id}/files`, data);
+  }
+};
+
+// src/generated/publish.ts
+var PublishResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Initialize publishing system - checks database setup */
+  async create(data) {
+    return this.client.post("/publish/init", data);
+  }
+  /** Verify database migration was applied */
+  async createVerify(data) {
+    return this.client.post("/publish/verify", data);
+  }
+  /** Publish an entity (checks database readiness automatically) */
+  async createEntity(data) {
+    return this.client.post("/publish/entity", data);
+  }
+};
+
+// src/generated/queues.ts
+var QueuesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all queues and their statistics (tenant-isolated) */
+  async list() {
+    return this.client.get("/queues");
+  }
+  /** Get statistics for a specific queue (tenant-isolated) */
+  async stats(name) {
+    return this.client.get(`/queues/${name}/stats`);
+  }
+  /** Get jobs from a queue (tenant-isolated) */
+  async jobs(name) {
+    return this.client.get(`/queues/${name}/jobs`);
+  }
+  /** Add a job to the queue (with tenant isolation) */
+  async createJob(name, data) {
+    return this.client.post(`/queues/${name}/jobs`, data);
+  }
+  /** Get a specific job (tenant-isolated) */
+  async getJob(name, jobId) {
+    return this.client.get(`/queues/${name}/jobs/${jobId}`);
+  }
+  /** Retry a failed job (tenant-isolated) */
+  async retry(name, jobId, data) {
+    return this.client.post(`/queues/${name}/jobs/${jobId}/retry`, data);
+  }
+  /** Pause a queue (admin only - affects all tenants) */
+  async pause(name, data) {
+    return this.client.post(`/queues/${name}/pause`, data);
+  }
+  /** Resume a paused queue (admin only - affects all tenants) */
+  async resume(name, data) {
+    return this.client.post(`/queues/${name}/resume`, data);
+  }
+  /** Clean old jobs from queue (tenant-isolated) */
+  async createClean(name, data) {
+    return this.client.post(`/queues/${name}/clean`, data);
+  }
+  /** Get detailed performance metrics for a queue */
+  async metrics(name) {
+    return this.client.get(`/queues/${name}/metrics`);
+  }
+};
+
+// src/generated/search.ts
+var SearchResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Fast search across an entity with configurable modes (exact, fuzzy, hybrid) */
+  async get(entity) {
+    return this.client.get(`/search/${entity}`);
+  }
+  /** Index entity records for vector search */
+  async create(data) {
+    return this.client.post("/search/index", data);
+  }
+  /** Delete and reindex all records for an entity */
+  async createReindex(data) {
+    return this.client.post("/search/reindex", data);
+  }
+  /** Delete all indexed records for an entity */
+  async delete(entity) {
+    return this.client.delete(`/search/index/${entity}`);
+  }
+  /** Get search index statistics */
+  async list() {
+    return this.client.get("/search/stats");
+  }
+};
+
+// src/generated/secrets.ts
+var SecretsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List secrets */
+  async list() {
+    return this.client.get("/tenant/secrets");
+  }
+  /** Store a secret */
+  async create(data) {
+    return this.client.post("/tenant/secrets", data);
+  }
+  /** Delete a secret */
+  async delete(key) {
+    return this.client.delete(`/tenant/secrets/${key}`);
+  }
+  /** Rotate a secret */
+  async rotate(key, data) {
+    return this.client.post(`/tenant/secrets/${key}/rotate`, data);
+  }
+};
+
+// src/generated/stripe.ts
+var StripeResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a Stripe customer */
+  async create(data) {
+    return this.client.post("/integrations/stripe/customers", data);
+  }
+  /** Create a Stripe payment intent */
+  async createPaymentIntents(data) {
+    return this.client.post("/integrations/stripe/payment-intents", data);
+  }
+  /** Create a Stripe subscription */
+  async createSubscriptions(data) {
+    return this.client.post("/integrations/stripe/subscriptions", data);
+  }
+};
+
+// src/generated/system.ts
+var SystemResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get comprehensive system information including routes, providers, and integrations */
+  async list() {
+    return this.client.get("/info");
+  }
+  /** Get detailed information about all registered routes including tenant-specific custom routes */
+  async listRoutes() {
+    return this.client.get("/info/routes");
+  }
+  /** Get detailed information about all available integrations */
+  async listIntegrations() {
+    return this.client.get("/info/integrations");
+  }
+  /** Get information about the versioning system and how to use it */
+  async listVersioning() {
+    return this.client.get("/info/versioning");
+  }
+  /** Get information about the caching system */
+  async listCache() {
+    return this.client.get("/info/cache");
+  }
+  /** Get information about the multi-tenancy system */
+  async listMultiTenancy() {
+    return this.client.get("/info/multi-tenancy");
+  }
+  /** Get information about tenant configuration management */
+  async listTenantConfig() {
+    return this.client.get("/info/tenant-config");
+  }
+  /** Get information about role-based access control */
+  async listRbac() {
+    return this.client.get("/info/rbac");
+  }
+  /** Get information about rate limiting */
+  async listRateLimiting() {
+    return this.client.get("/info/rate-limiting");
+  }
+  /** Get information about the queue system */
+  async listQueues() {
+    return this.client.get("/info/queues");
+  }
+  /** Get information about the events system */
+  async listEvents() {
+    return this.client.get("/info/events");
+  }
+  /** Get information about webhooks */
+  async listWebhooks() {
+    return this.client.get("/info/webhooks");
+  }
+  /** Get information about file storage */
+  async listFileStorage() {
+    return this.client.get("/info/file-storage");
+  }
+  /** Get information about multi-factor authentication */
+  async listMfa() {
+    return this.client.get("/info/mfa");
+  }
+  /** Get information about analytics */
+  async listAnalytics() {
+    return this.client.get("/info/analytics");
+  }
+  /** Get information about billing and subscriptions */
+  async listBilling() {
+    return this.client.get("/info/billing");
+  }
+  /** Get information about notifications */
+  async listNotifications() {
+    return this.client.get("/info/notifications");
+  }
+  /** Get information about WebSocket and real-time features */
+  async listWebsocket() {
+    return this.client.get("/info/websocket");
+  }
+  /** Get information about the agent and AI system */
+  async listAgent() {
+    return this.client.get("/info/agent");
+  }
+  /** Get information about authentication */
+  async listAuth() {
+    return this.client.get("/info/auth");
+  }
+  /** Get information about encryption and security */
+  async listEncryption() {
+    return this.client.get("/info/encryption");
+  }
+  /** Get information about database migrations */
+  async listMigrations() {
+    return this.client.get("/info/migrations");
+  }
+  /** Get information about route aliasing */
+  async listRouteAliasing() {
+    return this.client.get("/info/route-aliasing");
+  }
+  /** Get information about the publishing system */
+  async listPublishing() {
+    return this.client.get("/info/publishing");
+  }
+  /** Get information about deployment tracking */
+  async listDeployment() {
+    return this.client.get("/info/deployment");
+  }
+  /** Get information about OpenAPI documentation */
+  async listOpenapi() {
+    return this.client.get("/info/openapi");
+  }
+  /** Get information about gRPC support */
+  async listGrpc() {
+    return this.client.get("/info/grpc");
+  }
+  /** Get information about microservices architecture */
+  async listMicroservices() {
+    return this.client.get("/info/microservices");
+  }
+  /** Get information about domain management */
+  async listDomains() {
+    return this.client.get("/info/domains");
+  }
+  /** Get information about LLM streaming */
+  async listLlmStreaming() {
+    return this.client.get("/info/llm-streaming");
+  }
+  /** Get information about user usage tracking */
+  async listUserUsage() {
+    return this.client.get("/info/user-usage");
+  }
+};
+
+// src/generated/teams.ts
+var TeamsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all teams */
+  async list() {
+    return this.client.get("/teams");
+  }
+  /** Create a new team */
+  async create(data) {
+    return this.client.post("/teams", data);
+  }
+  /** Get team by ID */
+  async get(id) {
+    return this.client.get(`/teams/${id}`);
+  }
+  /** Update team metadata (name, description, members) */
+  async update(id, data) {
+    return this.client.put(`/teams/${id}`, data);
+  }
+  /** Delete team */
+  async delete(id) {
+    return this.client.delete(`/teams/${id}`);
+  }
+  /** Get all projects for a team */
+  async projects(id) {
+    return this.client.get(`/teams/${id}/projects`);
+  }
+};
+
+// src/generated/tenant-integrations.ts
+var TenantIntegrationsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List integrations */
+  async list() {
+    return this.client.get("/tenant/integrations");
+  }
+  /** Create or update integration */
+  async create(data) {
+    return this.client.post("/tenant/integrations", data);
+  }
+  /** Get integration */
+  async get(integrationId) {
+    return this.client.get(`/tenant/integrations/${integrationId}`);
+  }
+  /** Delete integration */
+  async delete(integrationId) {
+    return this.client.delete(`/tenant/integrations/${integrationId}`);
+  }
+  /** Clone from default */
+  async createClone(integrationId, data) {
+    return this.client.post(`/tenant/integrations/${integrationId}/clone`, data);
+  }
+};
+
+// src/generated/tenant-jobs.ts
+var TenantJobsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List job definitions */
+  async list() {
+    return this.client.get("/tenant/jobs/definitions");
+  }
+  /** Create or update job definition */
+  async create(data) {
+    return this.client.post("/tenant/jobs/definitions", data);
+  }
+  /** Get job definition */
+  async get(jobDefId) {
+    return this.client.get(`/tenant/jobs/definitions/${jobDefId}`);
+  }
+  /** Delete job definition */
+  async delete(jobDefId) {
+    return this.client.delete(`/tenant/jobs/definitions/${jobDefId}`);
+  }
+  /** Enqueue job from definition */
+  async createEnqueue(data) {
+    return this.client.post("/tenant/jobs/enqueue", data);
+  }
+  /** Get job execution history */
+  async listHistory() {
+    return this.client.get("/tenant/jobs/history");
+  }
+};
+
+// src/generated/tenant-limits.ts
+var TenantLimitsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get user limits configuration */
+  async list() {
+    return this.client.get("/tenant/limits");
+  }
+  /** Update user limits configuration */
+  async update(data) {
+    return this.client.put("/tenant/limits", data);
+  }
+  /** Get usage statistics */
+  async listUsage() {
+    return this.client.get("/tenant/limits/usage");
+  }
+  /** Check if action is allowed */
+  async create(data) {
+    return this.client.post("/tenant/limits/check", data);
+  }
+  /** Get storage limits configuration */
+  async listStorage() {
+    return this.client.get("/tenant/limits/storage");
+  }
+  /** Update storage limits configuration */
+  async updateStorage(data) {
+    return this.client.put("/tenant/limits/storage", data);
+  }
+  /** Get storage usage statistics */
+  async listGET2() {
+    return this.client.get("/tenant/limits/storage/usage");
+  }
+  /** Check if file upload is allowed */
+  async createCheck(data) {
+    return this.client.post("/tenant/limits/storage/check", data);
+  }
+  /** Get storage usage by user */
+  async listByUser() {
+    return this.client.get("/tenant/limits/storage/by-user");
+  }
+  /** Get resource limits configuration */
+  async listResources() {
+    return this.client.get("/tenant/limits/resources");
+  }
+  /** Update resource limits configuration */
+  async updateResources(data) {
+    return this.client.put("/tenant/limits/resources", data);
+  }
+  /** Get available resource types */
+  async listDefinitions() {
+    return this.client.get("/tenant/limits/resources/definitions");
+  }
+  /** Get resource usage statistics */
+  async listGET3() {
+    return this.client.get("/tenant/limits/resources/usage");
+  }
+  /** Check if resource action is allowed */
+  async createPOST2(data) {
+    return this.client.post("/tenant/limits/resources/check", data);
+  }
+  /** Track resource usage */
+  async createTrack(data) {
+    return this.client.post("/tenant/limits/resources/track", data);
+  }
+  /** Get limit for specific collection */
+  async get(collection) {
+    return this.client.get(`/tenant/limits/${collection}`);
+  }
+  /** Set limit for specific collection */
+  async updateLimits(collection, data) {
+    return this.client.put(`/tenant/limits/${collection}`, data);
+  }
+  /** Remove limit for specific collection */
+  async delete(collection) {
+    return this.client.delete(`/tenant/limits/${collection}`);
+  }
+};
+
+// src/generated/tenant-rbac.ts
+var TenantRbacResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get RBAC configuration */
+  async list() {
+    return this.client.get("/tenant/rbac");
+  }
+  /** Update RBAC configuration */
+  async update(data) {
+    return this.client.put("/tenant/rbac", data);
+  }
+  /** List all roles */
+  async listRoles() {
+    return this.client.get("/tenant/rbac/roles");
+  }
+  /** Create a new role */
+  async create(data) {
+    return this.client.post("/tenant/rbac/roles", data);
+  }
+  /** Update a role */
+  async updateRoles(name, data) {
+    return this.client.put(`/tenant/rbac/roles/${name}`, data);
+  }
+  /** Delete a role */
+  async delete(name) {
+    return this.client.delete(`/tenant/rbac/roles/${name}`);
+  }
+};
+
+// src/generated/tenant-webhook-receivers.ts
+var TenantWebhookReceiversResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List webhook receivers */
+  async list() {
+    return this.client.get("/tenant/webhook-receivers");
+  }
+  /** Create webhook receiver */
+  async create(data) {
+    return this.client.post("/tenant/webhook-receivers", data);
+  }
+  /** Get webhook receiver */
+  async get(id) {
+    return this.client.get(`/tenant/webhook-receivers/${id}`);
+  }
+  /** Update webhook receiver */
+  async update(id, data) {
+    return this.client.put(`/tenant/webhook-receivers/${id}`, data);
+  }
+  /** Delete webhook receiver */
+  async delete(id) {
+    return this.client.delete(`/tenant/webhook-receivers/${id}`);
+  }
+};
+
+// src/generated/tenant-webhooks.ts
+var TenantWebhooksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List webhooks */
+  async list() {
+    return this.client.get("/tenant/webhooks");
+  }
+  /** Create webhook */
+  async create(data) {
+    return this.client.post("/tenant/webhooks", data);
+  }
+  /** Get webhook */
+  async get(id) {
+    return this.client.get(`/tenant/webhooks/${id}`);
+  }
+  /** Update webhook */
+  async update(id, data) {
+    return this.client.put(`/tenant/webhooks/${id}`, data);
+  }
+  /** Delete webhook */
+  async delete(id) {
+    return this.client.delete(`/tenant/webhooks/${id}`);
+  }
+};
+
+// src/generated/tenant-workflows.ts
+var TenantWorkflowsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List workflows */
+  async list() {
+    return this.client.get("/tenant/workflows");
+  }
+  /** Create or update workflow */
+  async create(data) {
+    return this.client.post("/tenant/workflows", data);
+  }
+  /** Get workflow */
+  async get(workflowId) {
+    return this.client.get(`/tenant/workflows/${workflowId}`);
+  }
+  /** Delete workflow */
+  async delete(workflowId) {
+    return this.client.delete(`/tenant/workflows/${workflowId}`);
+  }
+  /** Clone from default */
+  async createClone(workflowId, data) {
+    return this.client.post(`/tenant/workflows/${workflowId}/clone`, data);
+  }
+};
+
+// src/generated/tooldiscovery.ts
+var ToolDiscoveryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all registered tools including MCP, user-configured, and built-in tools */
+  async list() {
+    return this.client.get("/agent/tools");
+  }
+  /** Search for tools using text query, category, tags, capabilities, and performance filters */
+  async create(data) {
+    return this.client.post("/agent/tools/search", data);
+  }
+  /** Search for tools using natural language semantic similarity */
+  async createSemanticSearch(data) {
+    return this.client.post("/agent/tools/semantic-search", data);
+  }
+  /** Use AI to automatically select appropriate tools based on a natural language goal */
+  async createSelect(data) {
+    return this.client.post("/agent/tools/select", data);
+  }
+  /** Get tool recommendations based on goal and historical performance data */
+  async createRecommend(data) {
+    return this.client.post("/agent/tools/recommend", data);
+  }
+  /** Get performance metrics (success rate, latency, usage) for a specific tool */
+  async metrics(toolName) {
+    return this.client.get(`/agent/tools/${toolName}/metrics`);
+  }
+  /** Index all registered tools for semantic search using embeddings */
+  async createIndex(data) {
+    return this.client.post("/agent/tools/index", data);
+  }
+};
+
+// src/generated/tracking.ts
+var TrackingResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get MCP call statistics for the tenant */
+  async list() {
+    return this.client.get("/tracking/mcp/stats");
+  }
+  /** Get field-level change history for an entity */
+  async history(entityType, entityId) {
+    return this.client.get(`/tracking/entity/${entityType}/${entityId}/history`);
+  }
+  /** Get change history for a specific field */
+  async getField(entityType, entityId, fieldName) {
+    return this.client.get(`/tracking/entity/${entityType}/${entityId}/field/${fieldName}`);
+  }
+  /** Get tracking buffer status (AI usage buffer size) */
+  async listStatus() {
+    return this.client.get("/tracking/buffer/status");
+  }
+  /** Manually flush tracking buffers to database */
+  async create(data) {
+    return this.client.post("/tracking/buffer/flush", data);
+  }
+};
+
+// src/generated/twitter.ts
+var TwitterResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search X (Twitter) tweets by query */
+  async list() {
+    return this.client.get("/api/twitter/search");
+  }
+  /** Get details of a specific tweet */
+  async get(tweetId) {
+    return this.client.get(`/api/twitter/tweets/${tweetId}`);
+  }
+  /** Delete a tweet */
+  async delete(tweetId) {
+    return this.client.delete(`/api/twitter/tweets/${tweetId}`);
+  }
+  /** Post a new tweet */
+  async create(data) {
+    return this.client.post("/api/twitter/tweets", data);
+  }
+  /** Like a tweet */
+  async createLike(userId, data) {
+    return this.client.post(`/api/twitter/users/${userId}/likes`, data);
+  }
+  /** Unlike a tweet */
+  async deleteLike(userId, tweetId) {
+    return this.client.delete(`/api/twitter/users/${userId}/likes/${tweetId}`);
+  }
+  /** Retweet a tweet */
+  async createRetweet(userId, data) {
+    return this.client.post(`/api/twitter/users/${userId}/retweets`, data);
+  }
+  /** Remove a retweet */
+  async deleteRetweet(userId, tweetId) {
+    return this.client.delete(`/api/twitter/users/${userId}/retweets/${tweetId}`);
+  }
+  /** Get user information by username */
+  async getUsername(username) {
+    return this.client.get(`/api/twitter/users/by/username/${username}`);
+  }
+  /** Get user information by user ID */
+  async getUsers(userId) {
+    return this.client.get(`/api/twitter/users/${userId}`);
+  }
+  /** Get authenticated user information */
+  async listMe() {
+    return this.client.get("/api/twitter/user/me");
+  }
+  /** Get recent tweets from a user */
+  async tweets(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/tweets`);
+  }
+  /** Follow a user */
+  async createFollowing(userId, data) {
+    return this.client.post(`/api/twitter/users/${userId}/following`, data);
+  }
+  /** Unfollow a user */
+  async deleteFollowing(userId, targetUserId) {
+    return this.client.delete(`/api/twitter/users/${userId}/following/${targetUserId}`);
+  }
+  /** Get followers of a user */
+  async followers(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/followers`);
+  }
+  /** Get users that a user is following */
+  async followingList(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/following_list`);
+  }
+  /** Get users who liked a tweet */
+  async likedBy(tweetId) {
+    return this.client.get(`/api/twitter/tweets/${tweetId}/liked_by`);
+  }
+  /** Get users who retweeted a tweet */
+  async retweetedBy(tweetId) {
+    return this.client.get(`/api/twitter/tweets/${tweetId}/retweeted_by`);
+  }
+  /** Get tweets in a conversation thread */
+  async getConversations(conversationId) {
+    return this.client.get(`/api/twitter/conversations/${conversationId}`);
+  }
+  /** Get tweets liked by a user */
+  async likedTweets(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/liked_tweets`);
+  }
+};
+
+// src/generated/usage.ts
+var UsageResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get unified usage metrics for a user across AI, API, and integrations */
+  async get(userId) {
+    return this.client.get(`/usage/user/${userId}`);
+  }
+  /** Get a brief summary of user usage */
+  async summary(userId) {
+    return this.client.get(`/usage/user/${userId}/summary`);
+  }
+  /** Get usage metrics for the authenticated user */
+  async list() {
+    return this.client.get("/usage/me");
+  }
+};
+
+// src/generated/users.ts
+var UsersResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all users */
+  async list() {
+    return this.client.get("/users");
+  }
+  /** Get user by ID */
+  async get(id) {
+    return this.client.get(`/users/${id}`);
+  }
+  /** Create a new user */
+  async create(data) {
+    return this.client.post("/users", data);
+  }
+  /** Update user */
+  async update(id, data) {
+    return this.client.put(`/users/${id}`, data);
+  }
+  /** Delete user */
+  async delete(id) {
+    return this.client.delete(`/users/${id}`);
+  }
+};
+
+// src/generated/websocket.ts
+var WebsocketResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** WebSocket API Documentation */
+  async list() {
+    return this.client.get("/websocket/info");
+  }
+};
+
+// src/generated/workflows.ts
+var WorkflowsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Orchestrate a task by ID. Executes predefined task orchestration logic. */
+  async create(data) {
+    return this.client.post("/agent/orchestrate", data);
+  }
+  /** Execute an agentic workflow with tools and steps. Workflows define a series of actions that can call LLMs, APIs, shell commands, and MCP tools. */
+  async createWorkflow(data) {
+    return this.client.post("/agent/workflow", data);
+  }
+  /** List all workflow executions with date range filter and pagination. */
+  async list() {
+    return this.client.get("/agent/workflows/executions");
+  }
+  /** Delete all workflow executions and their activity records */
+  async delete() {
+    return this.client.delete("/agent/workflows/executions");
+  }
+  /** Delete a specific workflow execution and all its activity records */
+  async deleteExecutions(workflowId) {
+    return this.client.delete(`/agent/workflows/executions/${workflowId}`);
+  }
+  /** Get execution history for a workflow by ID. Returns all historical execution records. */
+  async history(workflowId) {
+    return this.client.get(`/agent/workflow/${workflowId}/history`);
+  }
+  /** Resume a paused workflow execution. Allows continuing or cancelling execution with optional user input. */
+  async createResume(data) {
+    return this.client.post("/agent/workflow/resume", data);
+  }
+  /** Request pause for a running workflow. The workflow will pause after the current step completes. */
+  async pause(executionId, data) {
+    return this.client.post(`/agent/workflow/${executionId}/pause`, data);
+  }
+  /** Cancel a running workflow. The workflow will stop after the current step completes. */
+  async cancel(executionId, data) {
+    return this.client.post(`/agent/workflow/${executionId}/cancel`, data);
+  }
+  /** Get background execution status for workflows that returned early */
+  async status(executionId) {
+    return this.client.get(`/agent/workflow/${executionId}/status`);
+  }
+  /** Retry a workflow execution. Can restart from beginning or resume from last checkpoint. */
+  async retry(executionId, data) {
+    return this.client.post(`/agent/workflow/${executionId}/retry`, data);
+  }
+  /** Health check endpoint with detailed component status. Returns status of embeddings, vector store, MCP servers, and database. */
+  async listHealth() {
+    return this.client.get("/agent/health");
+  }
+  /** Automatically generate and execute a workflow from a natural language goal using AI */
+  async createDynamic(data) {
+    return this.client.post("/agent/workflow/dynamic", data);
+  }
+};
+
+// src/generated/workspaces.ts
+var WorkspacesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all workspaces */
+  async list() {
+    return this.client.get("/workspaces");
+  }
+  /** Create a new workspace */
+  async create(data) {
+    return this.client.post("/workspaces", data);
+  }
+  /** Get workspace by ID */
+  async get(id) {
+    return this.client.get(`/workspaces/${id}`);
+  }
+  /** Update workspace */
+  async update(id, data) {
+    return this.client.put(`/workspaces/${id}`, data);
+  }
+  /** Delete workspace */
+  async delete(id) {
+    return this.client.delete(`/workspaces/${id}`);
+  }
+};
+
+// src/resources/ai.ts
+var AIResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async chat(options) {
+    return this.client.post("/ai/chat", options);
+  }
+};
+
+// src/resources/collaboration.ts
+var CollaborationResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async presence(data) {
+    return this.client.post("/collaboration/presence", data);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(client, projectId) {
+    this.client = client;
+    this.projectId = projectId;
+  }
+  async trigger(data) {
+    return this.client.post(`/webhooks/${this.projectId}/trigger`, data);
+  }
+};
+var WebhooksFactory = class {
+  constructor(client) {
+    this.client = client;
+  }
+  for(projectId) {
+    return new WebhooksResource(this.client, projectId);
+  }
+};
+
+// src/resources/exports.ts
+var ExportsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async highRes(options) {
+    const contentType = options.contentType || (options.format === "svg" ? "image/svg+xml" : options.format === "pdf" ? "application/pdf" : "image/png");
+    return this.client.post("/exports/high-res", {
+      ...options,
+      contentType
+    });
+  }
+};
+
+// src/resources/user.ts
+var UserResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async createMetrics(metrics) {
+    return this.client.post("/user/metrics", metrics);
+  }
+  async getMetrics() {
+    return this.client.get("/user/metrics");
+  }
+  async updateMetrics(metrics) {
+    return this.client.put("/user/metrics", metrics);
+  }
+  async getProfile() {
+    return this.client.get("/admin/users/me");
+  }
+  async updateProfile(options) {
+    return this.client.put("/admin/users/me/profile", options);
+  }
+};
+
+// src/resources/entities.ts
+var EntitiesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listCollections() {
+    const response = await this.client.get("/admin/entities");
+    return response.data || [];
+  }
+  async list(collection, options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    if (options?.includeDeleted) params.set("includeDeleted", "true");
+    const query = params.toString();
+    const url = `/admin/entities/${encodeURIComponent(collection)}${query ? `?${query}` : ""}`;
+    return this.client.get(url);
+  }
+  async get(collection, id, options) {
+    const params = new URLSearchParams();
+    if (options?.includeDeleted) params.set("includeDeleted", "true");
+    const query = params.toString();
+    const response = await this.client.get(
+      `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}${query ? `?${query}` : ""}`
+    );
+    return response.data;
+  }
+  async create(collection, data) {
+    const response = await this.client.post(
+      `/admin/entities/${encodeURIComponent(collection)}`,
+      data
+    );
+    return response.data;
+  }
+  async update(collection, id, data) {
+    const response = await this.client.put(
+      `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`,
+      data
+    );
+    return response.data;
+  }
+  async delete(collection, id, options) {
+    const params = new URLSearchParams();
+    if (options?.hard) params.set("hard", "true");
+    if (options?.softDelete === false) params.set("softDelete", "false");
+    const query = params.toString();
+    const url = `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}${query ? `?${query}` : ""}`;
+    return this.client.delete(url);
+  }
+  async restore(collection, id) {
+    return this.client.post(
+      `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}/restore`,
+      {}
+    );
+  }
+  async getSchema() {
+    const response = await this.client.get("/admin/schema");
+    return response.data || [];
+  }
+  /**
+   * Get schema for a specific collection
+   */
+  async getCollectionSchema(collection) {
+    const schemas = await this.getSchema();
+    return schemas.find((s) => s.collection === collection) || null;
+  }
+  /**
+   * Validate data against a collection's schema (client-side)
+   */
+  async validate(collection, data) {
+    const schema = await this.getCollectionSchema(collection);
+    if (!schema) {
+      return { valid: true };
+    }
+    const errors = [];
+    for (const field of schema.fields) {
+      if (field.source === "builtin") continue;
+      const value = data[field.name];
+      const hasValue = value !== void 0 && value !== null && value !== "";
+      if (field.required && !hasValue) {
+        errors.push({ field: field.name, message: `${field.name} is required` });
+        continue;
+      }
+      if (!hasValue) continue;
+      if (field.type === "integer" || field.type === "bigint") {
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          errors.push({ field: field.name, message: `${field.name} must be an integer` });
+          continue;
+        }
+      }
+      if (field.type === "decimal") {
+        if (typeof value !== "number") {
+          errors.push({ field: field.name, message: `${field.name} must be a number` });
+          continue;
+        }
+      }
+      if (field.type === "boolean") {
+        if (typeof value !== "boolean") {
+          errors.push({ field: field.name, message: `${field.name} must be a boolean` });
+          continue;
+        }
+      }
+      if (typeof value === "number") {
+        if (field.min !== void 0 && value < field.min) {
+          errors.push({ field: field.name, message: `${field.name} must be at least ${field.min}` });
+        }
+        if (field.max !== void 0 && value > field.max) {
+          errors.push({ field: field.name, message: `${field.name} must be at most ${field.max}` });
+        }
+      }
+      if (typeof value === "string") {
+        if (field.min !== void 0 && value.length < field.min) {
+          errors.push({ field: field.name, message: `${field.name} must be at least ${field.min} characters` });
+        }
+        if (field.max !== void 0 && value.length > field.max) {
+          errors.push({ field: field.name, message: `${field.name} must be at most ${field.max} characters` });
+        }
+      }
+      if (field.enum && field.enum.length > 0) {
+        if (!field.enum.includes(String(value))) {
+          errors.push({ field: field.name, message: `${field.name} must be one of: ${field.enum.join(", ")}` });
+        }
+      }
+      if (field.pattern && typeof value === "string") {
+        const regex = new RegExp(field.pattern);
+        if (!regex.test(value)) {
+          errors.push({ field: field.name, message: `${field.name} has invalid format` });
+        }
+      }
+      if (field.preset && typeof value === "string") {
+        const presetError = this.validatePreset(field.preset, value, field.name);
+        if (presetError) {
+          errors.push(presetError);
+        }
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  validatePreset(preset, value, fieldName) {
+    const patterns = {
+      email: { regex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/, message: "must be a valid email" },
+      url: { regex: /^https?:\/\/[^\s/$.?#].[^\s]*$/i, message: "must be a valid URL" },
+      "phone-us": { regex: /^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/, message: "must be a valid US phone" },
+      "phone-intl": { regex: /^\+?[\d\s\-().]{7,20}$/, message: "must be a valid phone number" },
+      uuid: { regex: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, message: "must be a valid UUID" },
+      slug: { regex: /^[a-z0-9]+(?:-[a-z0-9]+)*$/, message: "must be a valid slug" },
+      username: { regex: /^[a-zA-Z0-9_]{3,30}$/, message: "must be 3-30 chars, letters/numbers/underscores" },
+      password: { regex: /^.{8,}$/, message: "must be at least 8 characters" },
+      name: { regex: /^[\p{L}\s\-'.]{1,100}$/u, message: "must be a valid name" },
+      currency: { regex: /^\d+(\.\d{1,2})?$/, message: "must be a valid currency amount" },
+      percentage: { regex: /^(100(\.0{1,2})?|\d{1,2}(\.\d{1,2})?)$/, message: "must be 0-100" },
+      date: { regex: /^\d{4}-\d{2}-\d{2}$/, message: "must be YYYY-MM-DD format" },
+      datetime: { regex: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, message: "must be ISO datetime" },
+      time: { regex: /^\d{2}:\d{2}(:\d{2})?$/, message: "must be HH:MM or HH:MM:SS" },
+      ip: { regex: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/, message: "must be a valid IP" },
+      ipv4: { regex: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, message: "must be a valid IPv4" },
+      ipv6: { regex: /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/, message: "must be a valid IPv6" },
+      "mac-address": { regex: /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/, message: "must be a valid MAC address" },
+      "credit-card": { regex: /^\d{13,19}$/, message: "must be a valid card number" },
+      "postal-code-us": { regex: /^\d{5}(-\d{4})?$/, message: "must be a valid US postal code" },
+      ssn: { regex: /^\d{3}-\d{2}-\d{4}$/, message: "must be XXX-XX-XXXX format" },
+      "hex-color": { regex: /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, message: "must be #RGB or #RRGGBB" },
+      json: { regex: /^[\s\S]*$/, message: "must be valid JSON" }
+    };
+    const config = patterns[preset];
+    if (!config) return null;
+    if (preset === "json") {
+      try {
+        JSON.parse(value);
+        return null;
+      } catch {
+        return { field: fieldName, message: `${fieldName} ${config.message}` };
+      }
+    }
+    if (!config.regex.test(value)) {
+      return { field: fieldName, message: `${fieldName} ${config.message}` };
+    }
+    return null;
+  }
+  /**
+   * Create with validation (validates before sending to server)
+   */
+  async createValidated(collection, data) {
+    const validation = await this.validate(collection, data);
+    if (!validation.valid) {
+      return { errors: validation.errors };
+    }
+    const result = await this.create(collection, data);
+    return { data: result };
+  }
+  /**
+   * Update with validation (validates before sending to server)
+   */
+  async updateValidated(collection, id, data) {
+    const validation = await this.validate(collection, data);
+    if (!validation.valid) {
+      return { errors: validation.errors };
+    }
+    const result = await this.update(collection, id, data);
+    return { data: result };
+  }
+};
+
+// src/resources/files.ts
+var FilesResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upload(file, options = {}) {
+    return this.client.upload("/files/upload", file, {
+      bucket: options.bucket || "squeed-storage",
+      entityType: options.entityType || "project",
+      entityId: options.entityId || "default"
+    });
+  }
+  async uploadMultiple(files, options = {}) {
+    return this.client.upload("/files/upload-multiple", files, {
+      bucket: options.bucket || "squeed-storage",
+      entityType: options.entityType || "project",
+      entityId: options.entityId || "default"
+    });
+  }
+  async list(entityType, entityId, options) {
+    const params = {};
+    if (options?.limit) params.limit = options.limit;
+    if (options?.offset) params.offset = options.offset;
+    const response = await this.client.get(`/files/entity/${entityType}/${entityId}`, params);
+    return response.files || [];
+  }
+  async getSignedUrl(bucket, key, expiresIn = 600) {
+    return this.client.get(`/files/signed-url/${bucket}/${encodeURIComponent(key)}`, { expiresIn });
+  }
+  async download(bucket, key) {
+    const { signedUrl } = await this.getSignedUrl(bucket, key);
+    const response = await fetch(signedUrl);
+    return response.blob();
+  }
+  async delete(bucket, key) {
+    return this.client.delete(`/files/${bucket}/${encodeURIComponent(key)}`);
+  }
+  async deleteByEntity(entityType, entityId) {
+    return this.client.delete(`/files/entity/${entityType}/${entityId}`);
+  }
+  async uploadJson(options) {
+    return this.client.post("/files/upload-json", options);
+  }
+};
+
+// src/resources/workflows.ts
+var TOOL_TYPES = [
+  "llm_call",
+  "api_call",
+  "shell_command",
+  "web_search",
+  "file_edit",
+  "git_command",
+  "mcp_tool",
+  "storage",
+  "database",
+  "notification",
+  "workflow",
+  "rag",
+  "cache",
+  "emit_event"
+];
+var TRIGGER_TYPES = ["manual", "cron", "webhook", "event"];
+var NOTIFY_CHANNELS = ["email", "sms", "whatsapp", "push", "slack"];
+var NOTIFY_PRIORITIES = ["low", "normal", "high", "urgent"];
+var DB_OPERATIONS = ["get", "query", "insert", "update", "upsert", "delete", "deletewhere", "arrayRemove", "updateArrayElement", "count"];
+var STORAGE_OPERATIONS = ["get", "download", "put", "upload", "list", "signedUrl", "delete", "deleteByPrefix", "url", "publicUrl"];
+var CACHE_OPERATIONS = ["get", "set", "delete", "invalidate"];
+var LLM_PROVIDERS = ["openai", "anthropic", "google", "openrouter", "lmstudio", "custom", "claude", "ollama"];
+var CLI_PROVIDERS = ["claude", "openai", "aider", "anthropic", "claude-cli", "openai-cli", "ollama-cli"];
+var DB_PROVIDERS = ["firebase", "supabase", "sqlite", "custom"];
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+var RAG_MODES = ["single", "accumulate", "iterative"];
+var CHUNKING_STRATEGIES = ["fixed_size", "recursive", "token_based", "semantic"];
+var IMAGE_DETAILS = ["auto", "low", "high"];
+var CONDITION_OPERATORS = ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$exists"];
+var WORKFLOW_VALIDATION_SCHEMA = {
+  root: {
+    id: { type: "string", required: true, description: "Unique workflow identifier" },
+    name: { type: "string", required: true, description: "Human-readable workflow name" },
+    description: { type: "string", required: false, description: "Workflow purpose and details" },
+    tools: { type: "array", required: true, multiselect: true, description: "Tool definitions available to the workflow" },
+    workflows: { type: "array", required: true, multiselect: true, description: "Array of executable workflows" },
+    agent: {
+      type: "object",
+      required: false,
+      description: "Agent configuration with LLM instructions",
+      properties: {
+        id: { type: "string", required: false, description: "Unique agent identifier" },
+        name: { type: "string", required: false, description: "Agent display name" },
+        role: { type: "string", required: false, description: "Agent role/responsibility" },
+        llm_prompt: { type: "string", required: false, description: "System prompt for LLM" }
+      }
+    },
+    monitoring: {
+      type: "object",
+      required: false,
+      description: "KPI and performance tracking",
+      properties: {
+        kpis: {
+          type: "array",
+          required: false,
+          multiselect: true,
+          description: "Key performance indicators",
+          itemType: {
+            type: "object",
+            required: false,
+            properties: {
+              metric: { type: "string", required: true, description: "Metric name" },
+              target: { type: "string", required: false, description: "Target value" },
+              measurement: { type: "string", required: false, description: "Measurement source" }
+            }
+          }
+        }
+      }
+    },
+    working_directory: { type: "string", required: false, description: "Base directory for execution" },
+    context: { type: "object", required: false, description: "Initial context variables for template substitution" },
+    planOnly: { type: "boolean", required: false, default: false, description: "If true, only generate execution plan" },
+    allowPause: { type: "boolean", required: false, default: false, description: "Enable pause/resume capabilities" },
+    subscribable: { type: "boolean", required: false, default: false, description: "Enable real-time WebSocket progress updates" }
+  },
+  tool: {
+    name: { type: "string", required: true, description: "Unique tool identifier" },
+    type: { type: "enum", required: true, options: TOOL_TYPES, description: "Tool type" },
+    description: { type: "string", required: false, description: "What the tool does" },
+    endpoint: { type: "string", required: false, description: "API endpoint URL (for api_call type)" },
+    params: {
+      type: "object",
+      required: false,
+      description: "Configuration parameters",
+      properties: {
+        timeout: { type: "number", required: false, default: 3e4, description: "Timeout in milliseconds" },
+        method: { type: "enum", required: false, options: HTTP_METHODS, description: "HTTP method" },
+        headers: { type: "object", required: false, description: "HTTP headers" },
+        maxBuffer: { type: "number", required: false, description: "Max buffer size for shell commands" },
+        cwd: { type: "string", required: false, description: "Working directory" },
+        env: { type: "object", required: false, description: "Environment variables for shell commands" },
+        provider: { type: "enum", required: false, options: LLM_PROVIDERS, description: "LLM provider" },
+        model: { type: "string", required: false, description: "Model identifier" },
+        baseURL: { type: "string", required: false, description: "Custom API endpoint for LLM" },
+        temperature: { type: "number", required: false, default: 0.7, description: "LLM temperature (0-2)" },
+        max_tokens: { type: "number", required: false, default: 4e3, description: "Max tokens for LLM response" },
+        maxTokens: { type: "number", required: false, default: 4e3, description: "Max tokens (alias)" },
+        stop: { type: "array", required: false, multiselect: true, description: "Stop sequences for LLM" },
+        saveMedia: { type: "boolean", required: false, default: false, description: "Save generated images to storage" },
+        mediaBucket: { type: "string", required: false, description: "Storage bucket for media" },
+        mediaPrefix: { type: "string", required: false, description: "Path prefix for media files" },
+        cliProvider: { type: "enum", required: false, options: CLI_PROVIDERS, description: "CLI provider for shell commands" },
+        requireAuth: { type: "boolean", required: false, description: "Check CLI authentication" },
+        parseJSON: { type: "boolean", required: false, description: "Attempt to parse stdout as JSON" },
+        mcpServer: { type: "string", required: false, description: "MCP server name" },
+        toolName: { type: "string", required: false, description: "MCP tool name" },
+        operation: { type: "enum", required: false, options: [...DB_OPERATIONS, ...STORAGE_OPERATIONS, ...CACHE_OPERATIONS], description: "Database/storage/cache operation" },
+        bucket: { type: "string", required: false, description: "Storage bucket name" },
+        contentKey: { type: "string", required: false, description: "Storage content key/path" },
+        path: { type: "string", required: false, description: "File path (alias for contentKey)" },
+        entityType: { type: "string", required: false, description: "Entity type for storage linking" },
+        entityId: { type: "string", required: false, description: "Entity ID for storage linking" },
+        contentType: { type: "string", required: false, description: "MIME type" },
+        expiresIn: { type: "number", required: false, description: "Expiry in seconds for signed URLs" },
+        prefix: { type: "string", required: false, description: "Prefix for deleteByPrefix operation" },
+        dbProvider: { type: "enum", required: false, options: DB_PROVIDERS, default: "supabase", description: "Database provider" },
+        collection: { type: "string", required: false, description: "Database collection/table name" },
+        table: { type: "string", required: false, description: "Table name (alias for collection)" },
+        id: { type: "string", required: false, description: "Document/record ID" },
+        docId: { type: "string", required: false, description: "Document ID (alias)" },
+        data: { type: "object", required: false, description: "Data for insert/update" },
+        where: { type: "array", required: false, multiselect: true, description: "Query filters" },
+        filters: { type: "array", required: false, multiselect: true, description: "Query filters (alias)" },
+        orderBy: { type: "string", required: false, description: "Sort order" },
+        limit: { type: "number", required: false, description: "Result limit" },
+        offset: { type: "number", required: false, description: "Result offset" },
+        field: { type: "string", required: false, description: "Field name for array operations" },
+        value: { type: "string", required: false, description: "Value for array operations" },
+        arrayField: { type: "string", required: false, description: "Array field name" },
+        matchKey: { type: "string", required: false, description: "Key to match in array" },
+        matchValue: { type: "string", required: false, description: "Value to match in array" },
+        updates: { type: "object", required: false, description: "Partial update data" },
+        channels: { type: "array", required: false, multiselect: true, options: NOTIFY_CHANNELS, description: "Notification channels" },
+        title: { type: "string", required: false, description: "Notification title" },
+        body: { type: "string", required: false, description: "Notification message" },
+        userId: { type: "string", required: false, description: "Recipient user ID" },
+        email: { type: "string", required: false, description: "Recipient email" },
+        phone: { type: "string", required: false, description: "Recipient phone" },
+        priority: { type: "enum", required: false, options: NOTIFY_PRIORITIES, description: "Notification priority" },
+        category: { type: "string", required: false, description: "Notification category" },
+        actionUrl: { type: "string", required: false, description: "Action URL" },
+        actionText: { type: "string", required: false, description: "Action button text" },
+        imageUrl: { type: "string", required: false, description: "Image URL" },
+        respectUserPreferences: { type: "boolean", required: false, default: true, description: "Respect user notification preferences" },
+        silent: { type: "boolean", required: false, default: false, description: "Silent notification" },
+        saveToHistory: { type: "boolean", required: false, default: true, description: "Save to notification history" },
+        pattern: { type: "string", required: false, description: "Cache invalidation pattern" },
+        key: { type: "string", required: false, description: "Cache key" },
+        ttl: { type: "number", required: false, description: "Cache TTL in seconds" },
+        command: { type: "string", required: false, description: "Shell command to execute" }
+      }
+    }
+  },
+  step: {
+    id: { type: "string", required: true, description: "Unique step identifier within workflow" },
+    action: { type: "string", required: true, description: "Name of tool to execute" },
+    type: { type: "enum", required: false, options: TOOL_TYPES, description: "Step type override (e.g., for rag)" },
+    description: { type: "string", required: false, description: "Step purpose" },
+    input: {
+      type: "object",
+      required: false,
+      description: "Data passed to the step",
+      properties: {
+        query: { type: "string", required: false, description: "Search query for RAG" },
+        mode: { type: "enum", required: false, options: RAG_MODES, description: "RAG search mode" },
+        limit: { type: "number", required: false, default: 5, description: "Result limit" },
+        filter: { type: "object", required: false, description: "RAG filter criteria" },
+        contextKey: { type: "string", required: false, description: "Context key for RAG results" },
+        timeout: { type: "number", required: false, default: 3e4, description: "Step timeout" }
+      }
+    },
+    output: { type: "string", required: false, description: "Variable name to store output" },
+    params: { type: "object", required: false, description: "Step-specific parameter overrides (same as tool params)" },
+    conditions: {
+      type: "object",
+      required: false,
+      description: "Conditional execution logic",
+      properties: {
+        if: { type: "string", required: false, description: "Expression-based condition" }
+      }
+    },
+    files: {
+      type: "array",
+      required: false,
+      multiselect: true,
+      description: "File attachments for LLM steps",
+      itemType: {
+        type: "object",
+        required: false,
+        properties: {
+          id: { type: "string", required: false, description: "File ID" },
+          url: { type: "string", required: false, description: "File URL" },
+          data: { type: "string", required: false, description: "Base64 encoded data" },
+          mimeType: { type: "string", required: true, description: "MIME type" },
+          filename: { type: "string", required: false, description: "Original filename" }
+        }
+      }
+    },
+    images: {
+      type: "array",
+      required: false,
+      multiselect: true,
+      description: "Image attachments for vision tasks",
+      itemType: {
+        type: "object",
+        required: false,
+        properties: {
+          url: { type: "string", required: true, description: "Image URL" },
+          detail: { type: "enum", required: false, options: IMAGE_DETAILS, default: "auto", description: "Image detail level" }
+        }
+      }
+    },
+    dependsOn: { type: "array", required: false, multiselect: true, description: "Step IDs this step depends on" },
+    parallel: { type: "boolean", required: false, default: false, description: "Execute in parallel with other steps" },
+    earlyReturn: { type: "boolean", required: false, default: false, description: "Return immediately, continue in background" },
+    queueAsJob: { type: "boolean", required: false, default: false, description: "Queue background execution as a job (requires earlyReturn)" },
+    pausePoint: { type: "object", required: false, description: "Pause/approval control" },
+    retryCount: { type: "number", required: false, default: 0, description: "Current retry count" },
+    maxRetries: { type: "number", required: false, default: 0, description: "Maximum retry attempts" }
+  },
+  trigger: {
+    type: { type: "enum", required: true, options: TRIGGER_TYPES, description: "Trigger type" },
+    cron: { type: "string", required: false, description: "Cron expression for scheduled triggers" },
+    webhook: { type: "object", required: false, description: "Webhook configuration" },
+    event: { type: "string", required: false, description: "Event name or pattern for event triggers (e.g., posts.created, posts.*)" },
+    eventFilter: { type: "object", required: false, description: "Filter criteria for event data" }
+  },
+  pausePoint: {
+    requireApproval: { type: "boolean", required: false, default: false, description: "Manual approval required" },
+    message: { type: "string", required: false, description: "Message shown to user" },
+    metadata: { type: "object", required: false, description: "Custom metadata for pause state" },
+    notify: { type: "object", required: false, description: "Notification settings when paused" }
+  },
+  notify: {
+    enabled: { type: "boolean", required: false, default: false, description: "Enable notifications" },
+    channels: { type: "array", required: false, multiselect: true, options: NOTIFY_CHANNELS, description: "Notification channels" },
+    priority: { type: "enum", required: false, options: NOTIFY_PRIORITIES, default: "normal", description: "Notification priority" },
+    userId: { type: "string", required: false, description: "User ID to notify" }
+  },
+  workflow: {
+    name: { type: "string", required: true, description: "Workflow name" },
+    trigger: { type: "object", required: true, description: "Trigger configuration" },
+    steps: { type: "array", required: true, multiselect: true, description: "Array of workflow steps" },
+    config: {
+      type: "object",
+      required: false,
+      description: "Workflow-specific configuration",
+      properties: {
+        allowPause: { type: "boolean", required: false, description: "Override parent allowPause" },
+        maxAttempts: { type: "number", required: false, description: "Maximum retry attempts" }
+      }
+    }
+  },
+  fileAttachment: {
+    id: { type: "string", required: false, description: "File ID" },
+    url: { type: "string", required: false, description: "File URL" },
+    data: { type: "string", required: false, description: "Base64 encoded file data" },
+    mimeType: { type: "string", required: true, description: "MIME type of the file" },
+    filename: { type: "string", required: false, description: "Original filename" }
+  },
+  imageAttachment: {
+    url: { type: "string", required: true, description: "Image URL" },
+    detail: { type: "enum", required: false, options: IMAGE_DETAILS, default: "auto", description: "Image detail level for vision" }
+  },
+  conditionOperators: {
+    $eq: { type: "string", required: false, description: "Equal to value" },
+    $ne: { type: "string", required: false, description: "Not equal to value" },
+    $gt: { type: "number", required: false, description: "Greater than value" },
+    $gte: { type: "number", required: false, description: "Greater than or equal to value" },
+    $lt: { type: "number", required: false, description: "Less than value" },
+    $lte: { type: "number", required: false, description: "Less than or equal to value" },
+    $in: { type: "array", required: false, multiselect: true, description: "Value is in array" },
+    $exists: { type: "boolean", required: false, description: "Property exists" }
+  }
+};
+var WorkflowsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async execute(config) {
+    return this.client.post("/agent/workflow", config);
+  }
+  async get(executionId) {
+    return this.client.get(`/agent/workflow/${executionId}`);
+  }
+  async list(params) {
+    const response = await this.client.get("/agent/workflows/executions", params);
+    return { executions: response.executions || [], pagination: response.pagination };
+  }
+  async getHistory(workflowId) {
+    return this.client.get(`/agent/workflow/${workflowId}/history`);
+  }
+  async pause(executionId) {
+    return this.client.post(`/agent/workflow/${executionId}/pause`);
+  }
+  async resume(executionId, options) {
+    return this.client.post("/agent/workflow/resume", {
+      executionId,
+      continue: options?.continue ?? true,
+      userInput: options?.userInput
+    });
+  }
+  async cancel(executionId) {
+    return this.client.post(`/agent/workflow/${executionId}/cancel`);
+  }
+  async getStatus(executionId) {
+    const response = await this.client.get(`/agent/workflow/${executionId}/status`);
+    return response.execution;
+  }
+  async retry(executionId) {
+    return this.client.post(`/agent/workflow/${executionId}/retry`);
+  }
+  async rerun(workflowId) {
+    return this.client.post(`/agent/workflow/${workflowId}/rerun`);
+  }
+  async delete(workflowId) {
+    return this.client.delete(`/agent/workflows/executions/${workflowId}`);
+  }
+  async deleteAll() {
+    return this.client.delete("/agent/workflows/executions");
+  }
+  subscribe(executionId, handlers) {
+    const ws = this.client.createWebSocket(`workflow:${executionId}`);
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "workflow_progress" && handlers.onProgress) {
+          handlers.onProgress(data.payload);
+        } else if (data.type === "workflow_complete" && handlers.onComplete) {
+          handlers.onComplete(data.payload);
+        }
+      } catch (error) {
+        handlers.onError?.(error);
+      }
+    };
+    ws.onerror = (error) => handlers.onError?.(error);
+    return () => ws.close();
+  }
+  getValidationSchema() {
+    return WORKFLOW_VALIDATION_SCHEMA;
+  }
+  getSchemaFor(section) {
+    return WORKFLOW_VALIDATION_SCHEMA[section];
+  }
+  getToolTypes() {
+    return TOOL_TYPES;
+  }
+  getTriggerTypes() {
+    return TRIGGER_TYPES;
+  }
+  getNotifyChannels() {
+    return NOTIFY_CHANNELS;
+  }
+  getNotifyPriorities() {
+    return NOTIFY_PRIORITIES;
+  }
+  getDbOperations() {
+    return DB_OPERATIONS;
+  }
+  getStorageOperations() {
+    return STORAGE_OPERATIONS;
+  }
+  validateProperty(section, property, value) {
+    const schema = WORKFLOW_VALIDATION_SCHEMA[section];
+    const propSchema = schema[property];
+    if (!propSchema) {
+      return { valid: false, error: `Unknown property: ${property}` };
+    }
+    if (propSchema.required && (value === void 0 || value === null)) {
+      return { valid: false, error: `${property} is required` };
+    }
+    if (value === void 0 || value === null) {
+      return { valid: true };
+    }
+    if (propSchema.type === "enum" && propSchema.options) {
+      if (!propSchema.options.includes(value)) {
+        return { valid: false, error: `${property} must be one of: ${propSchema.options.join(", ")}` };
+      }
+    }
+    if (propSchema.type === "array" && !Array.isArray(value)) {
+      return { valid: false, error: `${property} must be an array` };
+    }
+    if (propSchema.type === "boolean" && typeof value !== "boolean") {
+      return { valid: false, error: `${property} must be a boolean` };
+    }
+    if (propSchema.type === "number" && typeof value !== "number") {
+      return { valid: false, error: `${property} must be a number` };
+    }
+    if (propSchema.type === "string" && typeof value !== "string") {
+      return { valid: false, error: `${property} must be a string` };
+    }
+    return { valid: true };
+  }
+};
+var TOOL_PARAM_CONTEXT = {
+  llm_call: ["provider", "model", "temperature", "max_tokens", "baseURL", "stop", "saveMedia", "mediaBucket"],
+  api_call: ["method", "headers", "timeout", "endpoint"],
+  shell_command: ["command", "cwd", "timeout", "env", "maxBuffer", "cliProvider", "parseJSON", "requireAuth"],
+  database: ["dbProvider", "operation", "collection", "id", "data", "where", "orderBy", "limit", "offset"],
+  storage: ["operation", "bucket", "contentKey", "path", "data", "contentType", "expiresIn", "prefix"],
+  notification: ["channels", "title", "body", "userId", "email", "phone", "priority", "silent"],
+  cache: ["operation", "key", "pattern", "ttl", "value"],
+  mcp_tool: ["mcpServer", "toolName", "timeout"],
+  rag: ["query", "mode", "limit", "filter", "contextKey"],
+  workflow: ["timeout"],
+  web_search: ["query", "limit"],
+  file_edit: ["path", "content"],
+  git_command: ["command", "cwd"]
+};
+function formatProp(key, val, indent = "") {
+  const req = val.required ? "*" : "";
+  const opts = val.options ? ` [${val.options.slice(0, 6).join("|")}${val.options.length > 6 ? "..." : ""}]` : "";
+  const multi = val.multiselect ? "[]" : "";
+  return `${indent}${key}${req}: ${val.type}${multi}${opts}`;
+}
+function toPromptContext(options = {}) {
+  const { sections, toolType, compact = false } = options;
+  const sectionsToInclude = sections || ["root", "tool", "step", "trigger", "pausePoint", "notify"];
+  let out = "# Workflow Schema\n\n";
+  if (!compact) {
+    out += `Tool types: ${TOOL_TYPES.join(", ")}
+`;
+    out += `Triggers: ${TRIGGER_TYPES.join(", ")}
+`;
+    out += `Notify channels: ${NOTIFY_CHANNELS.join(", ")}
+
+`;
+  }
+  for (const section of sectionsToInclude) {
+    const schema = WORKFLOW_VALIDATION_SCHEMA[section];
+    if (!schema) continue;
+    out += `## ${section}
+`;
+    for (const [key, val] of Object.entries(schema)) {
+      if (key === "params" && toolType && TOOL_PARAM_CONTEXT[toolType]) {
+        out += formatProp(key, val) + "\n";
+        const relevantParams = TOOL_PARAM_CONTEXT[toolType];
+        if (val.properties) {
+          for (const pk of relevantParams) {
+            const pv = val.properties[pk];
+            if (pv) out += formatProp(pk, pv, "  ") + "\n";
+          }
+        }
+      } else {
+        out += formatProp(key, val) + "\n";
+        if (!compact && val.properties) {
+          for (const [pk, pv] of Object.entries(val.properties)) {
+            out += formatProp(pk, pv, "  ") + "\n";
+          }
+        }
+      }
+    }
+    out += "\n";
+  }
+  return out;
+}
+function toCompactContext(toolType) {
+  return toPromptContext({ compact: true, toolType, sections: ["step", "tool"] });
+}
+
+// src/resources/cache.ts
+var CacheResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStats() {
+    return this.client.get("/cache/stats");
+  }
+  async flush() {
+    return this.client.delete(
+      "/cache/flush"
+    );
+  }
+  async invalidate(pattern) {
+    return this.client.post("/cache/invalidate", {
+      pattern
+    });
+  }
+  async invalidateRoute(method, path) {
+    return this.client.post("/cache/invalidate-route", {
+      method: method.toUpperCase(),
+      path
+    });
+  }
+  async resetStats() {
+    return this.client.post(
+      "/cache/reset-stats"
+    );
+  }
+};
+
+// src/resources/tenant.ts
+var TenantResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getConfig() {
+    return this.client.get("/tenant/config");
+  }
+  async updateConfig(config, options) {
+    return this.client.post("/tenant/config", {
+      config,
+      planTier: options?.planTier,
+      isolationLevel: options?.isolationLevel,
+      metadata: options?.metadata
+    });
+  }
+  async updateSettings(settings) {
+    return this.client.patch("/public/app/settings", settings);
+  }
+  get secrets() {
+    return new SecretsResource2(this.client);
+  }
+  get apiKeys() {
+    return new ApiKeysResource2(this.client);
+  }
+  get cache() {
+    return new CacheResource2(this.client);
+  }
+  get domains() {
+    return new DomainsResource2(this.client);
+  }
+  get apps() {
+    return new AppsResource2(this.client);
+  }
+  get limits() {
+    return new LimitsResource(this.client);
+  }
+  get workflows() {
+    return new TenantWorkflowsResource2(this.client);
+  }
+  get integrations() {
+    return new TenantIntegrationsResource2(this.client);
+  }
+  get jobs() {
+    return new TenantJobsResource2(this.client);
+  }
+  get rbac() {
+    return new RBACResource(this.client);
+  }
+};
+var SecretsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async set(key, value, metadata, expiresAt) {
+    return this.client.post("/tenant/secrets", {
+      key,
+      value,
+      metadata,
+      expiresAt
+    });
+  }
+  async list() {
+    const response = await this.client.get(
+      "/tenant/secrets"
+    );
+    return response.secrets || [];
+  }
+  async delete(key) {
+    return this.client.delete(
+      `/tenant/secrets/${encodeURIComponent(key)}`
+    );
+  }
+  async rotate(key, newValue, gracePeriodDays) {
+    return this.client.post(
+      `/tenant/secrets/${encodeURIComponent(key)}/rotate`,
+      {
+        newValue,
+        gracePeriodDays
+      }
+    );
+  }
+};
+var ApiKeysResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(name, options) {
+    return this.client.post("/tenant/api-keys", {
+      name,
+      scopes: options?.scopes,
+      expiresAt: options?.expiresAt?.toISOString()
+    });
+  }
+  async list() {
+    const response = await this.client.get("/tenant/api-keys");
+    return response.keys || [];
+  }
+  async revoke(keyId) {
+    return this.client.delete(`/tenant/api-keys/${encodeURIComponent(keyId)}`);
+  }
+  async rotate(keyId, gracePeriodDays) {
+    return this.client.post(
+      `/tenant/api-keys/${encodeURIComponent(keyId)}/rotate`,
+      { gracePeriodDays }
+    );
+  }
+};
+var DomainsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.get("/tenant/domains");
+    return response.domains || [];
+  }
+  async add(domain, type = "alias") {
+    return this.client.post("/tenant/domains", { domain, type });
+  }
+  async remove(domain) {
+    return this.client.delete(`/tenant/domains/${encodeURIComponent(domain)}`);
+  }
+  async verify(domain) {
+    return this.client.post(
+      `/tenant/domains/${encodeURIComponent(domain)}/verify`
+    );
+  }
+  async getVerificationInstructions(domain) {
+    return this.client.get(
+      `/tenant/domains/${encodeURIComponent(domain)}/verification`
+    );
+  }
+};
+var AppsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.get("/tenant/apps");
+    return response.apps || [];
+  }
+  async create(options) {
+    const response = await this.client.post("/public/apps/create", options);
+    return response.app;
+  }
+  async delete(appId) {
+    return this.client.delete(`/tenant/apps/${encodeURIComponent(appId)}`);
+  }
+  async getUsage() {
+    return this.client.get("/public/apps/usage");
+  }
+};
+var LimitsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    return this.client.get("/tenant/limits");
+  }
+  async update(config) {
+    return this.client.put("/tenant/limits", config);
+  }
+  async getLimit(collection) {
+    return this.client.get(`/tenant/limits/${encodeURIComponent(collection)}`);
+  }
+  async setLimit(collection, config) {
+    return this.client.put(
+      `/tenant/limits/${encodeURIComponent(collection)}`,
+      config
+    );
+  }
+  async deleteLimit(collection) {
+    return this.client.delete(
+      `/tenant/limits/${encodeURIComponent(collection)}`
+    );
+  }
+  async getUsage(userId) {
+    const query = userId ? `?userId=${encodeURIComponent(userId)}` : "";
+    return this.client.get(`/tenant/limits/usage${query}`);
+  }
+  async check(userId, collection, action, userTier) {
+    return this.client.post("/tenant/limits/check", {
+      userId,
+      collection,
+      action,
+      userTier
+    });
+  }
+  // Storage Limits Methods
+  get storage() {
+    return new StorageLimitsResource(this.client);
+  }
+  // Resource Limits Methods (workflows, LLM, API, etc.)
+  get resources() {
+    return new ResourceLimitsResource(this.client);
+  }
+};
+var StorageLimitsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getConfig() {
+    return this.client.get("/tenant/limits/storage");
+  }
+  async updateConfig(config) {
+    return this.client.put("/tenant/limits/storage", config);
+  }
+  async getUsage(userId, userTier) {
+    const params = new URLSearchParams();
+    if (userId) params.set("userId", userId);
+    if (userTier) params.set("userTier", userTier);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.client.get(`/tenant/limits/storage/usage${query}`);
+  }
+  async check(userId, fileSizeBytes, userTier) {
+    return this.client.post("/tenant/limits/storage/check", {
+      userId,
+      fileSizeBytes,
+      userTier
+    });
+  }
+  async getByUser() {
+    return this.client.get("/tenant/limits/storage/by-user");
+  }
+};
+var ResourceLimitsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getConfig() {
+    return this.client.get("/tenant/limits/resources");
+  }
+  async updateConfig(limits) {
+    return this.client.put("/tenant/limits/resources", limits);
+  }
+  async getDefinitions() {
+    return this.client.get("/tenant/limits/resources/definitions");
+  }
+  async getUsage(userId, resource) {
+    const params = new URLSearchParams();
+    if (userId) params.set("userId", userId);
+    if (resource) params.set("resource", resource);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.client.get(`/tenant/limits/resources/usage${query}`);
+  }
+  async check(resource, metric, options) {
+    return this.client.post("/tenant/limits/resources/check", {
+      resource,
+      metric,
+      userId: options?.userId,
+      amount: options?.amount ?? 1,
+      context: options?.context
+    });
+  }
+  async track(resource, metric, options) {
+    return this.client.post("/tenant/limits/resources/track", {
+      resource,
+      metric,
+      userId: options?.userId,
+      amount: options?.amount ?? 1
+    });
+  }
+};
+var TenantWorkflowsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.get("/tenant/workflows");
+    return response.workflows || [];
+  }
+  async get(workflowId) {
+    return this.client.get(`/tenant/workflows/${encodeURIComponent(workflowId)}`);
+  }
+  async save(definition) {
+    return this.client.post("/tenant/workflows", definition);
+  }
+  async delete(workflowId) {
+    return this.client.delete(`/tenant/workflows/${encodeURIComponent(workflowId)}`);
+  }
+  async cloneFromDefault(workflowId) {
+    return this.client.post(`/tenant/workflows/${encodeURIComponent(workflowId)}/clone`);
+  }
+};
+var TenantIntegrationsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.get("/tenant/integrations");
+    return response.integrations || [];
+  }
+  async get(integrationId) {
+    return this.client.get(`/tenant/integrations/${encodeURIComponent(integrationId)}`);
+  }
+  async save(definition) {
+    return this.client.post("/tenant/integrations", definition);
+  }
+  async delete(integrationId) {
+    return this.client.delete(`/tenant/integrations/${encodeURIComponent(integrationId)}`);
+  }
+  async cloneFromDefault(integrationId) {
+    return this.client.post(`/tenant/integrations/${encodeURIComponent(integrationId)}/clone`);
+  }
+};
+var TenantJobsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listDefinitions() {
+    const response = await this.client.get("/tenant/jobs/definitions");
+    return response.definitions || [];
+  }
+  async getDefinition(jobDefId) {
+    return this.client.get(`/tenant/jobs/definitions/${encodeURIComponent(jobDefId)}`);
+  }
+  async saveDefinition(definition) {
+    return this.client.post("/tenant/jobs/definitions", definition);
+  }
+  async deleteDefinition(jobDefId) {
+    return this.client.delete(`/tenant/jobs/definitions/${encodeURIComponent(jobDefId)}`);
+  }
+  async enqueue(jobDefId, payload, options) {
+    return this.client.post("/tenant/jobs/enqueue", {
+      jobDefId,
+      payload,
+      ...options
+    });
+  }
+  async listHistory(options) {
+    const params = new URLSearchParams();
+    if (options?.jobDefId) params.set("jobDefId", options.jobDefId);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    const query = params.toString() ? `?${params.toString()}` : "";
+    const response = await this.client.get(`/tenant/jobs/history${query}`);
+    return response.executions || [];
+  }
+};
+var RBACResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getConfig() {
+    return this.client.get("/tenant/rbac");
+  }
+  async updateConfig(config) {
+    return this.client.put("/tenant/rbac", config);
+  }
+  async listRoles() {
+    return this.client.get("/tenant/rbac/roles");
+  }
+  async createRole(role) {
+    return this.client.post("/tenant/rbac/roles", role);
+  }
+  async updateRole(name, updates) {
+    return this.client.put(
+      `/tenant/rbac/roles/${encodeURIComponent(name)}`,
+      updates
+    );
+  }
+  async deleteRole(name) {
+    return this.client.delete(
+      `/tenant/rbac/roles/${encodeURIComponent(name)}`
+    );
+  }
+};
+
+// src/resources/embeddings.ts
+var EmbeddingsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listDocuments(limit = 100) {
+    return this.client.get("/agent/embeddings/documents", { limit });
+  }
+  async embedDocument(options) {
+    return this.client.post("/agent/embeddings/document", options);
+  }
+  async embedBatch(documents, contentType) {
+    return this.client.post("/agent/embeddings/batch", {
+      documents,
+      contentType
+    });
+  }
+  async search(documentId, query, limit = 5) {
+    return this.client.get(`/agent/embeddings/document/${encodeURIComponent(documentId)}/search`, {
+      q: query,
+      limit
+    });
+  }
+  async delete(documentId) {
+    return this.client.delete(`/agent/embeddings/document/${encodeURIComponent(documentId)}`);
+  }
+  async semanticSearch(query, limit = 10) {
+    return this.client.post("/agent/tools/semantic-search", {
+      query,
+      limit
+    });
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getMyUsage() {
+    return this.client.get("/usage/me");
+  }
+  async getUserUsage(userId, options) {
+    return this.client.get(`/usage/user/${userId}`, options);
+  }
+  async getSummary(userId) {
+    return this.client.get(`/usage/user/${userId}/summary`);
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async project(projectId) {
+    return this.client.get(`/analytics/project/${projectId}`);
+  }
+};
+
+// src/resources/github.ts
+var GithubResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async import(owner, repo, options) {
+    return this.client.post(`/api/github/repos/${owner}/${repo}/import`, options);
+  }
+  async repos() {
+    return this.client.get("/api/github/repos");
+  }
+  async contents(owner, repo, path) {
+    const url = path ? `/api/github/repos/${owner}/${repo}/contents/${path}` : `/api/github/repos/${owner}/${repo}/contents`;
+    return this.client.get(url);
+  }
+  async branches(owner, repo) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/branches`);
+  }
+  async pulls(owner, repo) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls`);
+  }
+  async getPull(owner, repo, pullNumber) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pullNumber}`);
+  }
+  async files(owner, repo, pullNumber) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pullNumber}/files`);
+  }
+};
+
+// src/resources/queues.ts
+var QueuesResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all queues and their statistics (tenant-isolated) */
+  async list() {
+    return this.client.get("/queues");
+  }
+  /** Get statistics for a specific queue (tenant-isolated) */
+  async stats(name) {
+    return this.client.get(`/queues/${name}/stats`);
+  }
+  /** Get jobs from a queue (tenant-isolated) */
+  async jobs(name) {
+    return this.client.get(`/queues/${name}/jobs`);
+  }
+  /** Add a job to the queue (with tenant isolation) */
+  async createJob(name, data) {
+    return this.client.post(`/queues/${name}/jobs`, data);
+  }
+  /** Get a specific job (tenant-isolated) */
+  async getJob(name, jobId) {
+    return this.client.get(`/queues/${name}/jobs/${jobId}`);
+  }
+  /** Retry a failed job (tenant-isolated) */
+  async retry(name, jobId, data) {
+    return this.client.post(`/queues/${name}/jobs/${jobId}/retry`, data);
+  }
+  /** Pause a queue (admin only - affects all tenants) */
+  async pause(name, data) {
+    return this.client.post(`/queues/${name}/pause`, data);
+  }
+  /** Resume a paused queue (admin only - affects all tenants) */
+  async resume(name, data) {
+    return this.client.post(`/queues/${name}/resume`, data);
+  }
+  /** Clean old jobs from queue (tenant-isolated) */
+  async createClean(name, data) {
+    return this.client.post(`/queues/${name}/clean`, data);
+  }
+  /** Get detailed performance metrics for a queue */
+  async metrics(name) {
+    return this.client.get(`/queues/${name}/metrics`);
+  }
+  /** Subscribe to job updates via SSE. Returns unsubscribe function. */
+  subscribe(sseUrl, handlers) {
+    return this.client.subscribeSSE(sseUrl, handlers);
+  }
+};
+
+// src/resources/search.ts
+var SearchConfigValidator = class {
+  constructor() {
+    this.validOperators = ["eq", "neq", "gt", "gte", "lt", "lte", "like", "ilike", "in", "not_in", "is_null", "not_null"];
+    this.validModes = ["exact", "fuzzy", "hybrid"];
+  }
+  /**
+   * Validate search options for a query
+   */
+  validateSearchOptions(options) {
+    const errors = [];
+    if (!options.q || options.q.trim().length === 0) {
+      errors.push({ field: "q", message: "Search query is required and cannot be empty" });
+    }
+    if (options.mode && !this.validModes.includes(options.mode)) {
+      errors.push({ field: "mode", message: `Invalid mode. Must be one of: ${this.validModes.join(", ")}` });
+    }
+    if (options.limit !== void 0) {
+      if (options.limit < 1 || options.limit > 100) {
+        errors.push({ field: "limit", message: "Limit must be between 1 and 100" });
+      }
+    }
+    if (options.threshold !== void 0) {
+      if (options.threshold < 0 || options.threshold > 1) {
+        errors.push({ field: "threshold", message: "Threshold must be between 0 and 1" });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validate entity configuration
+   */
+  validateEntityConfig(entity, config) {
+    const errors = [];
+    if (!entity || entity.trim().length === 0) {
+      errors.push({ field: "entity", message: "Entity name is required" });
+    }
+    if (!config.searchFields || config.searchFields.length === 0) {
+      errors.push({ field: "searchFields", message: "At least one search field is required" });
+    } else {
+      config.searchFields.forEach((field, idx) => {
+        if (!field || field.trim().length === 0) {
+          errors.push({ field: `searchFields[${idx}]`, message: "Search field cannot be empty" });
+        }
+      });
+    }
+    if (config.filters) {
+      config.filters.forEach((filter, idx) => {
+        if (!filter.column) {
+          errors.push({ field: `filters[${idx}].column`, message: "Filter column is required" });
+        }
+        if (!filter.operator) {
+          errors.push({ field: `filters[${idx}].operator`, message: "Filter operator is required" });
+        } else if (!this.validOperators.includes(filter.operator)) {
+          errors.push({
+            field: `filters[${idx}].operator`,
+            message: `Invalid operator. Must be one of: ${this.validOperators.join(", ")}`
+          });
+        }
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validate full search configuration
+   */
+  validateConfig(config) {
+    const errors = [];
+    if (config.defaultMode && !this.validModes.includes(config.defaultMode)) {
+      errors.push({ field: "defaultMode", message: `Invalid mode. Must be one of: ${this.validModes.join(", ")}` });
+    }
+    if (config.defaultLimit !== void 0) {
+      if (config.defaultLimit < 1 || config.defaultLimit > 100) {
+        errors.push({ field: "defaultLimit", message: "Default limit must be between 1 and 100" });
+      }
+    }
+    if (config.cacheTTL !== void 0 && config.cacheTTL < 0) {
+      errors.push({ field: "cacheTTL", message: "Cache TTL cannot be negative" });
+    }
+    if (config.threshold !== void 0) {
+      if (config.threshold < 0 || config.threshold > 1) {
+        errors.push({ field: "threshold", message: "Threshold must be between 0 and 1" });
+      }
+    }
+    if (config.entities) {
+      Object.entries(config.entities).forEach(([entity, entityConfig]) => {
+        const entityResult = this.validateEntityConfig(entity, entityConfig);
+        entityResult.errors.forEach((err) => {
+          errors.push({ field: `entities.${entity}.${err.field}`, message: err.message });
+        });
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+};
+var SearchResource2 = class {
+  constructor(client) {
+    this.client = client;
+    this.validator = new SearchConfigValidator();
+  }
+  /**
+   * 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
+   * });
+   * ```
+   */
+  async query(entity, options) {
+    const validation = this.validator.validateSearchOptions(options);
+    if (!validation.valid) {
+      throw new Error(`Invalid search options: ${validation.errors.map((e) => e.message).join(", ")}`);
+    }
+    const params = { q: options.q };
+    if (options.mode) params.mode = options.mode;
+    if (options.limit) params.limit = options.limit;
+    if (options.threshold) params.threshold = options.threshold;
+    return this.client.get(`/search/${entity}`, params);
+  }
+  /**
+   * 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
+   * });
+   * ```
+   */
+  async index(options) {
+    return this.client.post("/search/index", options);
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async reindex(options) {
+    return this.client.post("/search/reindex", options);
+  }
+  /**
+   * Delete all indexed records for an entity
+   *
+   * @param entity - Entity name
+   * @returns Delete result
+   *
+   * @example
+   * ```typescript
+   * await backflow.search.delete('products');
+   * ```
+   */
+  async delete(entity) {
+    return this.client.delete(`/search/index/${entity}`);
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async stats() {
+    return this.client.get("/search/stats");
+  }
+};
+
+// src/sdk.ts
+var IntegrationsResource = class {
+  constructor(client) {
+    this.client = client;
+    this.stripe = new StripeResource(client);
+    this.polar = new PolarResource(client);
+  }
+};
+var BackflowSDK = class {
+  constructor(config) {
+    this.client = new BackflowClient(config);
+    this.agentAnalysis = new AgentAnalysisResource(this.client);
+    this.apikeys = new ApiKeysResource(this.client);
+    this.apps = new AppsResource(this.client);
+    this.assets = new AssetsResource(this.client);
+    this.authentication = new AuthenticationResource(this.client);
+    this.billing = new BillingResource(this.client);
+    this.cache = new CacheResource(this.client);
+    this.config = new ConfigResource(this.client);
+    this.default = new DefaultResource(this.client);
+    this.deployment = new DeploymentResource(this.client);
+    this.domains = new DomainsResource(this.client);
+    this.feedback = new FeedbackResource(this.client);
+    this.goals = new GoalsResource(this.client);
+    this.googleDrive = new GoogleDriveResource(this.client);
+    this.jira = new JiraResource(this.client);
+    this.llm = new LlmResource(this.client);
+    this.mcptools = new McpToolsResource(this.client);
+    this.mfa = new MfaResource(this.client);
+    this.migration = new MigrationResource(this.client);
+    this.projects = new ProjectsResource(this.client);
+    this.publish = new PublishResource(this.client);
+    this.secrets = new SecretsResource(this.client);
+    this.system = new SystemResource(this.client);
+    this.teams = new TeamsResource(this.client);
+    this.tenantIntegrations = new TenantIntegrationsResource(this.client);
+    this.tenantJobs = new TenantJobsResource(this.client);
+    this.tenantLimits = new TenantLimitsResource(this.client);
+    this.tenantRbac = new TenantRbacResource(this.client);
+    this.tenantWebhookReceivers = new TenantWebhookReceiversResource(this.client);
+    this.tenantWebhooks = new TenantWebhooksResource(this.client);
+    this.tenantWorkflows = new TenantWorkflowsResource(this.client);
+    this.tooldiscovery = new ToolDiscoveryResource(this.client);
+    this.tracking = new TrackingResource(this.client);
+    this.twitter = new TwitterResource(this.client);
+    this.users = new UsersResource(this.client);
+    this.websocket = new WebsocketResource(this.client);
+    this.workspaces = new WorkspacesResource(this.client);
+    this.integrations = new IntegrationsResource(this.client);
+    this.files = new FilesResource2(this.client);
+    this.workflows = new WorkflowsResource2(this.client);
+    this.tenant = new TenantResource(this.client);
+    this.embeddings = new EmbeddingsResource2(this.client);
+    this.usage = new UsageResource2(this.client);
+    this.analytics = new AnalyticsResource2(this.client);
+    this.github = new GithubResource2(this.client);
+    this.queues = new QueuesResource2(this.client);
+    this.search = new SearchResource2(this.client);
+    this.ai = new AIResource(this.client);
+    this.collaboration = new CollaborationResource(this.client);
+    this.webhooks = (projectId) => new WebhooksFactory(this.client).for(projectId);
+    this.exports = new ExportsResource(this.client);
+    this.user = new UserResource(this.client);
+    this.entities = new EntitiesResource(this.client);
+  }
+  get endpoint() {
+    return this.client.endpoint;
+  }
+  get(path, params) {
+    return this.client.get(path, params);
+  }
+  post(path, data, params) {
+    return this.client.post(path, data, params);
+  }
+  put(path, data, params) {
+    return this.client.put(path, data, params);
+  }
+  patch(path, data, params) {
+    return this.client.patch(path, data, params);
+  }
+  delete(path, params) {
+    return this.client.delete(path, params);
+  }
+};
+function createBackflow(config) {
+  return new BackflowSDK(config);
+}
+export {
+  AgentAnalysisResource,
+  AnalyticsResource,
+  ApiKeysResource,
+  AppsResource,
+  AssetsResource,
+  AuthenticationResource,
+  BackflowSDK as Backflow,
+  BackflowClient,
+  BackflowSDK,
+  BillingResource,
+  CACHE_OPERATIONS,
+  CHUNKING_STRATEGIES,
+  CLI_PROVIDERS,
+  CONDITION_OPERATORS,
+  CacheResource,
+  ConfigResource,
+  DB_OPERATIONS,
+  DB_PROVIDERS,
+  DefaultResource,
+  DeploymentResource,
+  DomainsResource,
+  EmbeddingsResource,
+  FeedbackResource,
+  FilesResource,
+  GithubResource,
+  GoalsResource,
+  GoogleDriveResource,
+  HTTP_METHODS,
+  IMAGE_DETAILS,
+  JiraResource,
+  LLM_PROVIDERS,
+  LlmResource,
+  McpToolsResource,
+  MfaResource,
+  MigrationResource,
+  NOTIFY_CHANNELS,
+  NOTIFY_PRIORITIES,
+  PolarResource,
+  ProjectsResource,
+  PublishResource,
+  QueuesResource,
+  RAG_MODES,
+  STORAGE_OPERATIONS,
+  SearchResource,
+  SecretsResource,
+  StripeResource,
+  SystemResource,
+  TOOL_PARAM_CONTEXT,
+  TOOL_TYPES,
+  TRIGGER_TYPES,
+  TeamsResource,
+  TenantIntegrationsResource,
+  TenantJobsResource,
+  TenantLimitsResource,
+  TenantRbacResource,
+  TenantWebhookReceiversResource,
+  TenantWebhooksResource,
+  TenantWorkflowsResource,
+  ToolDiscoveryResource,
+  TrackingResource,
+  TwitterResource,
+  UsageResource,
+  UsersResource,
+  WORKFLOW_VALIDATION_SCHEMA,
+  WebsocketResource,
+  WorkflowsResource,
+  WorkspacesResource,
+  createBackflow,
+  toCompactContext,
+  toPromptContext
+};