@xata.io/client 0.0.0-alpha.vfdc5c07 → 0.0.0-alpha.vfdd8c9fa700ee4d676771b5b8b8052b7734cb8c4

package/dist/index.cjs

@@ -244,26 +244,26 @@ function getPreviewBranch() {
   }
 }
 
-var __accessCheck$8 = (obj, member, msg) => {
+var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$8 = (obj, member, getter) => {
-  __accessCheck$8(obj, member, "read from private field");
+var __privateGet$7 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$8 = (obj, member, value) => {
+var __privateAdd$7 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$8 = (obj, member, value, setter) => {
-  __accessCheck$8(obj, member, "write to private field");
+var __privateSet$7 = (obj, member, value, setter) => {
+  __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var __privateMethod$4 = (obj, member, method) => {
-  __accessCheck$8(obj, member, "access private method");
+  __accessCheck$7(obj, member, "access private method");
   return method;
 };
 var _fetch, _queue, _concurrency, _enqueue, enqueue_fn;
@@ -279,23 +279,23 @@ function getFetchImplementation(userFetch) {
 }
 class ApiRequestPool {
   constructor(concurrency = 10) {
-    __privateAdd$8(this, _enqueue);
-    __privateAdd$8(this, _fetch, void 0);
-    __privateAdd$8(this, _queue, void 0);
-    __privateAdd$8(this, _concurrency, void 0);
-    __privateSet$8(this, _queue, []);
-    __privateSet$8(this, _concurrency, concurrency);
+    __privateAdd$7(this, _enqueue);
+    __privateAdd$7(this, _fetch, void 0);
+    __privateAdd$7(this, _queue, void 0);
+    __privateAdd$7(this, _concurrency, void 0);
+    __privateSet$7(this, _queue, []);
+    __privateSet$7(this, _concurrency, concurrency);
     this.running = 0;
     this.started = 0;
   }
   setFetch(fetch2) {
-    __privateSet$8(this, _fetch, fetch2);
+    __privateSet$7(this, _fetch, fetch2);
   }
   getFetch() {
-    if (!__privateGet$8(this, _fetch)) {
+    if (!__privateGet$7(this, _fetch)) {
       throw new Error("Fetch not set");
     }
-    return __privateGet$8(this, _fetch);
+    return __privateGet$7(this, _fetch);
   }
   request(url, options) {
     const start = /* @__PURE__ */ new Date();
@@ -327,19 +327,19 @@ _queue = new WeakMap();
 _concurrency = new WeakMap();
 _enqueue = new WeakSet();
 enqueue_fn = function(task) {
-  const promise = new Promise((resolve) => __privateGet$8(this, _queue).push(resolve)).finally(() => {
+  const promise = new Promise((resolve) => __privateGet$7(this, _queue).push(resolve)).finally(() => {
     this.started--;
     this.running++;
   }).then(() => task()).finally(() => {
     this.running--;
-    const next = __privateGet$8(this, _queue).shift();
+    const next = __privateGet$7(this, _queue).shift();
     if (next !== void 0) {
       this.started++;
       next();
     }
   });
-  if (this.running + this.started < __privateGet$8(this, _concurrency)) {
-    const next = __privateGet$8(this, _queue).shift();
+  if (this.running + this.started < __privateGet$7(this, _concurrency)) {
+    const next = __privateGet$7(this, _queue).shift();
     if (next !== void 0) {
       this.started++;
       next();
@@ -528,7 +528,7 @@ function defaultOnOpen(response) {
   }
 }
 
-const VERSION = "0.26.8";
+const VERSION = "0.28.3";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -571,6 +571,67 @@ function getMessage(data) {
   }
 }
 
+function getHostUrl(provider, type) {
+  if (isHostProviderAlias(provider)) {
+    return providers[provider][type];
+  } else if (isHostProviderBuilder(provider)) {
+    return provider[type];
+  }
+  throw new Error("Invalid API provider");
+}
+const providers = {
+  production: {
+    main: "https://api.xata.io",
+    workspaces: "https://{workspaceId}.{region}.xata.sh"
+  },
+  staging: {
+    main: "https://api.staging-xata.dev",
+    workspaces: "https://{workspaceId}.{region}.staging-xata.dev"
+  },
+  dev: {
+    main: "https://api.dev-xata.dev",
+    workspaces: "https://{workspaceId}.{region}.dev-xata.dev"
+  },
+  local: {
+    main: "http://localhost:6001",
+    workspaces: "http://{workspaceId}.{region}.localhost:6001"
+  }
+};
+function isHostProviderAlias(alias) {
+  return isString(alias) && Object.keys(providers).includes(alias);
+}
+function isHostProviderBuilder(builder) {
+  return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
+}
+function parseProviderString(provider = "production") {
+  if (isHostProviderAlias(provider)) {
+    return provider;
+  }
+  const [main, workspaces] = provider.split(",");
+  if (!main || !workspaces)
+    return null;
+  return { main, workspaces };
+}
+function buildProviderString(provider) {
+  if (isHostProviderAlias(provider))
+    return provider;
+  return `${provider.main},${provider.workspaces}`;
+}
+function parseWorkspacesUrlParts(url) {
+  if (!isString(url))
+    return null;
+  const matches = {
+    production: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.sh.*/),
+    staging: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.staging-xata\.dev.*/),
+    dev: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.dev-xata\.dev.*/),
+    local: url.match(/(?:https?:\/\/)?([^.]+)(?:\.([^.]+))\.localhost:(\d+)/)
+  };
+  const [host, match] = Object.entries(matches).find(([, match2]) => match2 !== null) ?? [];
+  if (!isHostProviderAlias(host) || !match)
+    return null;
+  return { workspace: match[1], region: match[2], host };
+}
+
 const pool = new ApiRequestPool();
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   const cleanQueryParams = Object.entries(queryParams).reduce((acc, [key, value]) => {
@@ -586,6 +647,7 @@ const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   return url.replace(/\{\w*\}/g, (key) => cleanPathParams[key.slice(1, -1)]) + queryString;
 };
 function buildBaseUrl({
+  method,
   endpoint,
   path,
   workspacesApiUrl,
@@ -593,7 +655,24 @@ function buildBaseUrl({
   pathParams = {}
 }) {
   if (endpoint === "dataPlane") {
-    const url = isString(workspacesApiUrl) ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
+    let url = isString(workspacesApiUrl) ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
+    if (method.toUpperCase() === "PUT" && [
+      "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file",
+      "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file/{fileId}"
+    ].includes(path)) {
+      const { host } = parseWorkspacesUrlParts(url) ?? {};
+      switch (host) {
+        case "production":
+          url = url.replace("xata.sh", "upload.xata.sh");
+          break;
+        case "staging":
+          url = url.replace("staging-xata.dev", "upload.staging-xata.dev");
+          break;
+        case "dev":
+          url = url.replace("dev-xata.dev", "upload.dev-xata.dev");
+          break;
+      }
+    }
     const urlWithWorkspace = isString(pathParams.workspace) ? url.replace("{workspaceId}", String(pathParams.workspace)) : url;
     return isString(pathParams.region) ? urlWithWorkspace.replace("{region}", String(pathParams.region)) : urlWithWorkspace;
   }
@@ -642,9 +721,9 @@ async function fetch$1({
   return await trace(
     `${method.toUpperCase()} ${path}`,
     async ({ setAttributes }) => {
-      const baseUrl = buildBaseUrl({ endpoint, path, workspacesApiUrl, pathParams, apiUrl });
+      const baseUrl = buildBaseUrl({ method, endpoint, path, workspacesApiUrl, pathParams, apiUrl });
       const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
-      const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
+      const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\.[^.]+\./, "http://") : fullUrl;
       setAttributes({
         [TraceAttributes.HTTP_URL]: url,
         [TraceAttributes.HTTP_TARGET]: resolveUrl(path, queryParams, pathParams)
@@ -725,7 +804,7 @@ function fetchSSERequest({
   clientName,
   xataAgentExtra
 }) {
-  const baseUrl = buildBaseUrl({ endpoint, path, workspacesApiUrl, pathParams, apiUrl });
+  const baseUrl = buildBaseUrl({ method, endpoint, path, workspacesApiUrl, pathParams, apiUrl });
   const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
   const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
   void fetchEventSource(url, {
@@ -768,6 +847,20 @@ function parseUrl(url) {
 
 const dataPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "dataPlane" });
 
+const applyMigration = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/pgroll/apply", method: "post", ...variables, signal });
+const pgRollStatus = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/pgroll/status",
+  method: "get",
+  ...variables,
+  signal
+});
+const pgRollJobStatus = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/pgroll/jobs/{jobId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const pgRollMigrationHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/pgroll/migrations", method: "get", ...variables, signal });
 const getBranchList = (variables, signal) => dataPlaneFetch({
   url: "/dbs/{dbName}",
   method: "get",
@@ -974,6 +1067,12 @@ const fileAccess = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+const fileUpload = (variables, signal) => dataPlaneFetch({
+  url: "/file/{fileId}",
+  method: "put",
+  ...variables,
+  signal
+});
 const sqlQuery = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/sql",
   method: "post",
@@ -982,6 +1081,10 @@ const sqlQuery = (variables, signal) => dataPlaneFetch({
 });
 const operationsByTag$2 = {
   branch: {
+    applyMigration,
+    pgRollStatus,
+    pgRollJobStatus,
+    pgRollMigrationHistory,
     getBranchList,
     getBranchDetails,
     createBranch,
@@ -1019,1602 +1122,272 @@ const operationsByTag$2 = {
     mergeMigrationRequest
   },
   table: {
-    createTable,
-    deleteTable,
-    updateTable,
-    getTableSchema,
-    setTableSchema,
-    getTableColumns,
-    addTableColumn,
-    getColumn,
-    updateColumn,
-    deleteColumn
-  },
-  records: {
-    branchTransaction,
-    insertRecord,
-    getRecord,
-    insertRecordWithID,
-    updateRecordWithID,
-    upsertRecordWithID,
-    deleteRecord,
-    bulkInsertTableRecords
-  },
-  files: { getFileItem, putFileItem, deleteFileItem, getFile, putFile, deleteFile, fileAccess },
-  searchAndFilter: {
-    queryTable,
-    searchBranch,
-    searchTable,
-    vectorSearchTable,
-    askTable,
-    askTableSession,
-    summarizeTable,
-    aggregateTable
-  },
-  sql: { sqlQuery }
-};
-
-const controlPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "controlPlane" });
-
-const getAuthorizationCode = (variables, signal) => controlPlaneFetch({ url: "/oauth/authorize", method: "get", ...variables, signal });
-const grantAuthorizationCode = (variables, signal) => controlPlaneFetch({ url: "/oauth/authorize", method: "post", ...variables, signal });
-const getUser = (variables, signal) => controlPlaneFetch({
-  url: "/user",
-  method: "get",
-  ...variables,
-  signal
-});
-const updateUser = (variables, signal) => controlPlaneFetch({
-  url: "/user",
-  method: "put",
-  ...variables,
-  signal
-});
-const deleteUser = (variables, signal) => controlPlaneFetch({
-  url: "/user",
-  method: "delete",
-  ...variables,
-  signal
-});
-const getUserAPIKeys = (variables, signal) => controlPlaneFetch({
-  url: "/user/keys",
-  method: "get",
-  ...variables,
-  signal
-});
-const createUserAPIKey = (variables, signal) => controlPlaneFetch({
-  url: "/user/keys/{keyName}",
-  method: "post",
-  ...variables,
-  signal
-});
-const deleteUserAPIKey = (variables, signal) => controlPlaneFetch({
-  url: "/user/keys/{keyName}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const getUserOAuthClients = (variables, signal) => controlPlaneFetch({
-  url: "/user/oauth/clients",
-  method: "get",
-  ...variables,
-  signal
-});
-const deleteUserOAuthClient = (variables, signal) => controlPlaneFetch({
-  url: "/user/oauth/clients/{clientId}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const getUserOAuthAccessTokens = (variables, signal) => controlPlaneFetch({
-  url: "/user/oauth/tokens",
-  method: "get",
-  ...variables,
-  signal
-});
-const deleteOAuthAccessToken = (variables, signal) => controlPlaneFetch({
-  url: "/user/oauth/tokens/{token}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const updateOAuthAccessToken = (variables, signal) => controlPlaneFetch({ url: "/user/oauth/tokens/{token}", method: "patch", ...variables, signal });
-const getWorkspacesList = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces",
-  method: "get",
-  ...variables,
-  signal
-});
-const createWorkspace = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces",
-  method: "post",
-  ...variables,
-  signal
-});
-const getWorkspace = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}",
-  method: "get",
-  ...variables,
-  signal
-});
-const updateWorkspace = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}",
-  method: "put",
-  ...variables,
-  signal
-});
-const deleteWorkspace = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const getWorkspaceMembersList = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members", method: "get", ...variables, signal });
-const updateWorkspaceMemberRole = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables, signal });
-const removeWorkspaceMember = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}/members/{userId}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const inviteWorkspaceMember = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables, signal });
-const updateWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables, signal });
-const cancelWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "delete", ...variables, signal });
-const acceptWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept", method: "post", ...variables, signal });
-const resendWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}/resend", method: "post", ...variables, signal });
-const listClusters = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}/clusters",
-  method: "get",
-  ...variables,
-  signal
-});
-const createCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "post", ...variables, signal });
-const getCluster = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}/clusters/{clusterId}",
-  method: "get",
-  ...variables,
-  signal
-});
-const updateCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters/{clusterId}", method: "patch", ...variables, signal });
-const getDatabaseList = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}/dbs",
-  method: "get",
-  ...variables,
-  signal
-});
-const createDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "put", ...variables, signal });
-const deleteDatabase = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}/dbs/{dbName}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const getDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "get", ...variables, signal });
-const updateDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "patch", ...variables, signal });
-const renameDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/rename", method: "post", ...variables, signal });
-const getDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "get", ...variables, signal });
-const updateDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "put", ...variables, signal });
-const deleteDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "delete", ...variables, signal });
-const listRegions = (variables, signal) => controlPlaneFetch({
-  url: "/workspaces/{workspaceId}/regions",
-  method: "get",
-  ...variables,
-  signal
-});
-const operationsByTag$1 = {
-  oAuth: {
-    getAuthorizationCode,
-    grantAuthorizationCode,
-    getUserOAuthClients,
-    deleteUserOAuthClient,
-    getUserOAuthAccessTokens,
-    deleteOAuthAccessToken,
-    updateOAuthAccessToken
-  },
-  users: { getUser, updateUser, deleteUser },
-  authentication: { getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
-  workspaces: {
-    getWorkspacesList,
-    createWorkspace,
-    getWorkspace,
-    updateWorkspace,
-    deleteWorkspace,
-    getWorkspaceMembersList,
-    updateWorkspaceMemberRole,
-    removeWorkspaceMember
-  },
-  invites: {
-    inviteWorkspaceMember,
-    updateWorkspaceMemberInvite,
-    cancelWorkspaceMemberInvite,
-    acceptWorkspaceMemberInvite,
-    resendWorkspaceMemberInvite
-  },
-  xbcontrolOther: { listClusters, createCluster, getCluster, updateCluster },
-  databases: {
-    getDatabaseList,
-    createDatabase,
-    deleteDatabase,
-    getDatabaseMetadata,
-    updateDatabaseMetadata,
-    renameDatabase,
-    getDatabaseGithubSettings,
-    updateDatabaseGithubSettings,
-    deleteDatabaseGithubSettings,
-    listRegions
-  }
-};
-
-const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
-
-function getHostUrl(provider, type) {
-  if (isHostProviderAlias(provider)) {
-    return providers[provider][type];
-  } else if (isHostProviderBuilder(provider)) {
-    return provider[type];
-  }
-  throw new Error("Invalid API provider");
-}
-const providers = {
-  production: {
-    main: "https://api.xata.io",
-    workspaces: "https://{workspaceId}.{region}.xata.sh"
-  },
-  staging: {
-    main: "https://api.staging-xata.dev",
-    workspaces: "https://{workspaceId}.{region}.staging-xata.dev"
-  },
-  dev: {
-    main: "https://api.dev-xata.dev",
-    workspaces: "https://{workspaceId}.{region}.dev-xata.dev"
-  }
-};
-function isHostProviderAlias(alias) {
-  return isString(alias) && Object.keys(providers).includes(alias);
-}
-function isHostProviderBuilder(builder) {
-  return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
-}
-function parseProviderString(provider = "production") {
-  if (isHostProviderAlias(provider)) {
-    return provider;
-  }
-  const [main, workspaces] = provider.split(",");
-  if (!main || !workspaces)
-    return null;
-  return { main, workspaces };
-}
-function buildProviderString(provider) {
-  if (isHostProviderAlias(provider))
-    return provider;
-  return `${provider.main},${provider.workspaces}`;
-}
-function parseWorkspacesUrlParts(url) {
-  if (!isString(url))
-    return null;
-  const regex = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.sh.*/;
-  const regexDev = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.dev-xata\.dev.*/;
-  const regexStaging = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.staging-xata\.dev.*/;
-  const regexProdTesting = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.tech.*/;
-  const match = url.match(regex) || url.match(regexDev) || url.match(regexStaging) || url.match(regexProdTesting);
-  if (!match)
-    return null;
-  return { workspace: match[1], region: match[2] };
-}
-
-var __accessCheck$7 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$7 = (obj, member, getter) => {
-  __accessCheck$7(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$7 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$7 = (obj, member, value, setter) => {
-  __accessCheck$7(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var _extraProps, _namespaces;
-class XataApiClient {
-  constructor(options = {}) {
-    __privateAdd$7(this, _extraProps, void 0);
-    __privateAdd$7(this, _namespaces, {});
-    const provider = options.host ?? "production";
-    const apiKey = options.apiKey ?? getAPIKey();
-    const trace = options.trace ?? defaultTrace;
-    const clientID = generateUUID();
-    if (!apiKey) {
-      throw new Error("Could not resolve a valid apiKey");
-    }
-    __privateSet$7(this, _extraProps, {
-      apiUrl: getHostUrl(provider, "main"),
-      workspacesApiUrl: getHostUrl(provider, "workspaces"),
-      fetch: getFetchImplementation(options.fetch),
-      apiKey,
-      trace,
-      clientName: options.clientName,
-      xataAgentExtra: options.xataAgentExtra,
-      clientID
-    });
-  }
-  get user() {
-    if (!__privateGet$7(this, _namespaces).user)
-      __privateGet$7(this, _namespaces).user = new UserApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).user;
-  }
-  get authentication() {
-    if (!__privateGet$7(this, _namespaces).authentication)
-      __privateGet$7(this, _namespaces).authentication = new AuthenticationApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).authentication;
-  }
-  get workspaces() {
-    if (!__privateGet$7(this, _namespaces).workspaces)
-      __privateGet$7(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).workspaces;
-  }
-  get invites() {
-    if (!__privateGet$7(this, _namespaces).invites)
-      __privateGet$7(this, _namespaces).invites = new InvitesApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).invites;
-  }
-  get database() {
-    if (!__privateGet$7(this, _namespaces).database)
-      __privateGet$7(this, _namespaces).database = new DatabaseApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).database;
-  }
-  get branches() {
-    if (!__privateGet$7(this, _namespaces).branches)
-      __privateGet$7(this, _namespaces).branches = new BranchApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).branches;
-  }
-  get migrations() {
-    if (!__privateGet$7(this, _namespaces).migrations)
-      __privateGet$7(this, _namespaces).migrations = new MigrationsApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).migrations;
-  }
-  get migrationRequests() {
-    if (!__privateGet$7(this, _namespaces).migrationRequests)
-      __privateGet$7(this, _namespaces).migrationRequests = new MigrationRequestsApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).migrationRequests;
-  }
-  get tables() {
-    if (!__privateGet$7(this, _namespaces).tables)
-      __privateGet$7(this, _namespaces).tables = new TableApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).tables;
-  }
-  get records() {
-    if (!__privateGet$7(this, _namespaces).records)
-      __privateGet$7(this, _namespaces).records = new RecordsApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).records;
-  }
-  get files() {
-    if (!__privateGet$7(this, _namespaces).files)
-      __privateGet$7(this, _namespaces).files = new FilesApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).files;
-  }
-  get searchAndFilter() {
-    if (!__privateGet$7(this, _namespaces).searchAndFilter)
-      __privateGet$7(this, _namespaces).searchAndFilter = new SearchAndFilterApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).searchAndFilter;
-  }
-}
-_extraProps = new WeakMap();
-_namespaces = new WeakMap();
-class UserApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getUser() {
-    return operationsByTag.users.getUser({ ...this.extraProps });
-  }
-  updateUser({ user }) {
-    return operationsByTag.users.updateUser({ body: user, ...this.extraProps });
-  }
-  deleteUser() {
-    return operationsByTag.users.deleteUser({ ...this.extraProps });
-  }
-}
-class AuthenticationApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getUserAPIKeys() {
-    return operationsByTag.authentication.getUserAPIKeys({ ...this.extraProps });
-  }
-  createUserAPIKey({ name }) {
-    return operationsByTag.authentication.createUserAPIKey({
-      pathParams: { keyName: name },
-      ...this.extraProps
-    });
-  }
-  deleteUserAPIKey({ name }) {
-    return operationsByTag.authentication.deleteUserAPIKey({
-      pathParams: { keyName: name },
-      ...this.extraProps
-    });
-  }
-}
-class WorkspaceApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getWorkspacesList() {
-    return operationsByTag.workspaces.getWorkspacesList({ ...this.extraProps });
-  }
-  createWorkspace({ data }) {
-    return operationsByTag.workspaces.createWorkspace({
-      body: data,
-      ...this.extraProps
-    });
-  }
-  getWorkspace({ workspace }) {
-    return operationsByTag.workspaces.getWorkspace({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
-    });
-  }
-  updateWorkspace({
-    workspace,
-    update
-  }) {
-    return operationsByTag.workspaces.updateWorkspace({
-      pathParams: { workspaceId: workspace },
-      body: update,
-      ...this.extraProps
-    });
-  }
-  deleteWorkspace({ workspace }) {
-    return operationsByTag.workspaces.deleteWorkspace({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
-    });
-  }
-  getWorkspaceMembersList({ workspace }) {
-    return operationsByTag.workspaces.getWorkspaceMembersList({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
-    });
-  }
-  updateWorkspaceMemberRole({
-    workspace,
-    user,
-    role
-  }) {
-    return operationsByTag.workspaces.updateWorkspaceMemberRole({
-      pathParams: { workspaceId: workspace, userId: user },
-      body: { role },
-      ...this.extraProps
-    });
-  }
-  removeWorkspaceMember({
-    workspace,
-    user
-  }) {
-    return operationsByTag.workspaces.removeWorkspaceMember({
-      pathParams: { workspaceId: workspace, userId: user },
-      ...this.extraProps
-    });
-  }
-}
-class InvitesApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  inviteWorkspaceMember({
-    workspace,
-    email,
-    role
-  }) {
-    return operationsByTag.invites.inviteWorkspaceMember({
-      pathParams: { workspaceId: workspace },
-      body: { email, role },
-      ...this.extraProps
-    });
-  }
-  updateWorkspaceMemberInvite({
-    workspace,
-    invite,
-    role
-  }) {
-    return operationsByTag.invites.updateWorkspaceMemberInvite({
-      pathParams: { workspaceId: workspace, inviteId: invite },
-      body: { role },
-      ...this.extraProps
-    });
-  }
-  cancelWorkspaceMemberInvite({
-    workspace,
-    invite
-  }) {
-    return operationsByTag.invites.cancelWorkspaceMemberInvite({
-      pathParams: { workspaceId: workspace, inviteId: invite },
-      ...this.extraProps
-    });
-  }
-  acceptWorkspaceMemberInvite({
-    workspace,
-    key
-  }) {
-    return operationsByTag.invites.acceptWorkspaceMemberInvite({
-      pathParams: { workspaceId: workspace, inviteKey: key },
-      ...this.extraProps
-    });
-  }
-  resendWorkspaceMemberInvite({
-    workspace,
-    invite
-  }) {
-    return operationsByTag.invites.resendWorkspaceMemberInvite({
-      pathParams: { workspaceId: workspace, inviteId: invite },
-      ...this.extraProps
-    });
-  }
-}
-class BranchApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getBranchList({
-    workspace,
-    region,
-    database
-  }) {
-    return operationsByTag.branch.getBranchList({
-      pathParams: { workspace, region, dbName: database },
-      ...this.extraProps
-    });
-  }
-  getBranchDetails({
-    workspace,
-    region,
-    database,
-    branch
-  }) {
-    return operationsByTag.branch.getBranchDetails({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      ...this.extraProps
-    });
-  }
-  createBranch({
-    workspace,
-    region,
-    database,
-    branch,
-    from,
-    metadata
-  }) {
-    return operationsByTag.branch.createBranch({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { from, metadata },
-      ...this.extraProps
-    });
-  }
-  deleteBranch({
-    workspace,
-    region,
-    database,
-    branch
-  }) {
-    return operationsByTag.branch.deleteBranch({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      ...this.extraProps
-    });
-  }
-  copyBranch({
-    workspace,
-    region,
-    database,
-    branch,
-    destinationBranch,
-    limit
-  }) {
-    return operationsByTag.branch.copyBranch({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { destinationBranch, limit },
-      ...this.extraProps
-    });
-  }
-  updateBranchMetadata({
-    workspace,
-    region,
-    database,
-    branch,
-    metadata
-  }) {
-    return operationsByTag.branch.updateBranchMetadata({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: metadata,
-      ...this.extraProps
-    });
-  }
-  getBranchMetadata({
-    workspace,
-    region,
-    database,
-    branch
-  }) {
-    return operationsByTag.branch.getBranchMetadata({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      ...this.extraProps
-    });
-  }
-  getBranchStats({
-    workspace,
-    region,
-    database,
-    branch
-  }) {
-    return operationsByTag.branch.getBranchStats({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      ...this.extraProps
-    });
-  }
-  getGitBranchesMapping({
-    workspace,
-    region,
-    database
-  }) {
-    return operationsByTag.branch.getGitBranchesMapping({
-      pathParams: { workspace, region, dbName: database },
-      ...this.extraProps
-    });
-  }
-  addGitBranchesEntry({
-    workspace,
-    region,
-    database,
-    gitBranch,
-    xataBranch
-  }) {
-    return operationsByTag.branch.addGitBranchesEntry({
-      pathParams: { workspace, region, dbName: database },
-      body: { gitBranch, xataBranch },
-      ...this.extraProps
-    });
-  }
-  removeGitBranchesEntry({
-    workspace,
-    region,
-    database,
-    gitBranch
-  }) {
-    return operationsByTag.branch.removeGitBranchesEntry({
-      pathParams: { workspace, region, dbName: database },
-      queryParams: { gitBranch },
-      ...this.extraProps
-    });
-  }
-  resolveBranch({
-    workspace,
-    region,
-    database,
-    gitBranch,
-    fallbackBranch
-  }) {
-    return operationsByTag.branch.resolveBranch({
-      pathParams: { workspace, region, dbName: database },
-      queryParams: { gitBranch, fallbackBranch },
-      ...this.extraProps
-    });
-  }
-}
-class TableApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  createTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table
-  }) {
-    return operationsByTag.table.createTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      ...this.extraProps
-    });
-  }
-  deleteTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table
-  }) {
-    return operationsByTag.table.deleteTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      ...this.extraProps
-    });
-  }
-  updateTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    update
-  }) {
-    return operationsByTag.table.updateTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: update,
-      ...this.extraProps
-    });
-  }
-  getTableSchema({
-    workspace,
-    region,
-    database,
-    branch,
-    table
-  }) {
-    return operationsByTag.table.getTableSchema({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      ...this.extraProps
-    });
-  }
-  setTableSchema({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    schema
-  }) {
-    return operationsByTag.table.setTableSchema({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: schema,
-      ...this.extraProps
-    });
-  }
-  getTableColumns({
-    workspace,
-    region,
-    database,
-    branch,
-    table
-  }) {
-    return operationsByTag.table.getTableColumns({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      ...this.extraProps
-    });
-  }
-  addTableColumn({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    column
-  }) {
-    return operationsByTag.table.addTableColumn({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: column,
-      ...this.extraProps
-    });
-  }
-  getColumn({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    column
-  }) {
-    return operationsByTag.table.getColumn({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
-      ...this.extraProps
-    });
-  }
-  updateColumn({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    column,
-    update
-  }) {
-    return operationsByTag.table.updateColumn({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
-      body: update,
-      ...this.extraProps
-    });
-  }
-  deleteColumn({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    column
-  }) {
-    return operationsByTag.table.deleteColumn({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
-      ...this.extraProps
-    });
-  }
-}
-class RecordsApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  insertRecord({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    columns
-  }) {
-    return operationsByTag.records.insertRecord({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      queryParams: { columns },
-      body: record,
-      ...this.extraProps
-    });
-  }
-  getRecord({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    id,
-    columns
-  }) {
-    return operationsByTag.records.getRecord({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
-      queryParams: { columns },
-      ...this.extraProps
-    });
-  }
-  insertRecordWithID({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    id,
-    record,
-    columns,
-    createOnly,
-    ifVersion
-  }) {
-    return operationsByTag.records.insertRecordWithID({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
-      queryParams: { columns, createOnly, ifVersion },
-      body: record,
-      ...this.extraProps
-    });
-  }
-  updateRecordWithID({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    id,
-    record,
-    columns,
-    ifVersion
-  }) {
-    return operationsByTag.records.updateRecordWithID({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
-      queryParams: { columns, ifVersion },
-      body: record,
-      ...this.extraProps
-    });
-  }
-  upsertRecordWithID({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    id,
-    record,
-    columns,
-    ifVersion
-  }) {
-    return operationsByTag.records.upsertRecordWithID({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
-      queryParams: { columns, ifVersion },
-      body: record,
-      ...this.extraProps
-    });
-  }
-  deleteRecord({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    id,
-    columns
-  }) {
-    return operationsByTag.records.deleteRecord({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
-      queryParams: { columns },
-      ...this.extraProps
-    });
-  }
-  bulkInsertTableRecords({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    records,
-    columns
-  }) {
-    return operationsByTag.records.bulkInsertTableRecords({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      queryParams: { columns },
-      body: { records },
-      ...this.extraProps
-    });
-  }
-  branchTransaction({
-    workspace,
-    region,
-    database,
-    branch,
-    operations
-  }) {
-    return operationsByTag.records.branchTransaction({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { operations },
-      ...this.extraProps
-    });
-  }
-}
-class FilesApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getFileItem({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    column,
-    fileId
-  }) {
-    return operationsByTag.files.getFileItem({
-      pathParams: {
-        workspace,
-        region,
-        dbBranchName: `${database}:${branch}`,
-        tableName: table,
-        recordId: record,
-        columnName: column,
-        fileId
-      },
-      ...this.extraProps
-    });
-  }
-  putFileItem({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    column,
-    fileId,
-    file
-  }) {
-    return operationsByTag.files.putFileItem({
-      pathParams: {
-        workspace,
-        region,
-        dbBranchName: `${database}:${branch}`,
-        tableName: table,
-        recordId: record,
-        columnName: column,
-        fileId
-      },
-      // @ts-ignore
-      body: file,
-      ...this.extraProps
-    });
-  }
-  deleteFileItem({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    column,
-    fileId
-  }) {
-    return operationsByTag.files.deleteFileItem({
-      pathParams: {
-        workspace,
-        region,
-        dbBranchName: `${database}:${branch}`,
-        tableName: table,
-        recordId: record,
-        columnName: column,
-        fileId
-      },
-      ...this.extraProps
-    });
-  }
-  getFile({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    column
-  }) {
-    return operationsByTag.files.getFile({
-      pathParams: {
-        workspace,
-        region,
-        dbBranchName: `${database}:${branch}`,
-        tableName: table,
-        recordId: record,
-        columnName: column
-      },
-      ...this.extraProps
-    });
-  }
-  putFile({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    column,
-    file
-  }) {
-    return operationsByTag.files.putFile({
-      pathParams: {
-        workspace,
-        region,
-        dbBranchName: `${database}:${branch}`,
-        tableName: table,
-        recordId: record,
-        columnName: column
-      },
-      body: file,
-      ...this.extraProps
-    });
-  }
-  deleteFile({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    record,
-    column
-  }) {
-    return operationsByTag.files.deleteFile({
-      pathParams: {
-        workspace,
-        region,
-        dbBranchName: `${database}:${branch}`,
-        tableName: table,
-        recordId: record,
-        columnName: column
-      },
-      ...this.extraProps
-    });
-  }
-  fileAccess({
-    workspace,
-    region,
-    fileId,
-    verify
-  }) {
-    return operationsByTag.files.fileAccess({
-      pathParams: {
-        workspace,
-        region,
-        fileId
-      },
-      queryParams: { verify },
-      ...this.extraProps
-    });
-  }
-}
-class SearchAndFilterApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  queryTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    filter,
-    sort,
-    page,
-    columns,
-    consistency
-  }) {
-    return operationsByTag.searchAndFilter.queryTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: { filter, sort, page, columns, consistency },
-      ...this.extraProps
-    });
-  }
-  searchTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    query,
-    fuzziness,
-    target,
-    prefix,
-    filter,
-    highlight,
-    boosters
-  }) {
-    return operationsByTag.searchAndFilter.searchTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: { query, fuzziness, target, prefix, filter, highlight, boosters },
-      ...this.extraProps
-    });
-  }
-  searchBranch({
-    workspace,
-    region,
-    database,
-    branch,
-    tables,
-    query,
-    fuzziness,
-    prefix,
-    highlight
-  }) {
-    return operationsByTag.searchAndFilter.searchBranch({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { tables, query, fuzziness, prefix, highlight },
-      ...this.extraProps
-    });
-  }
-  vectorSearchTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    queryVector,
-    column,
-    similarityFunction,
-    size,
-    filter
-  }) {
-    return operationsByTag.searchAndFilter.vectorSearchTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: { queryVector, column, similarityFunction, size, filter },
-      ...this.extraProps
-    });
-  }
-  askTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    options
-  }) {
-    return operationsByTag.searchAndFilter.askTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: { ...options },
-      ...this.extraProps
-    });
-  }
-  askTableSession({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    sessionId,
-    message
-  }) {
-    return operationsByTag.searchAndFilter.askTableSession({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, sessionId },
-      body: { message },
-      ...this.extraProps
-    });
-  }
-  summarizeTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    filter,
-    columns,
-    summaries,
-    sort,
-    summariesFilter,
-    page,
-    consistency
-  }) {
-    return operationsByTag.searchAndFilter.summarizeTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: { filter, columns, summaries, sort, summariesFilter, page, consistency },
-      ...this.extraProps
-    });
-  }
-  aggregateTable({
-    workspace,
-    region,
-    database,
-    branch,
-    table,
-    filter,
-    aggs
-  }) {
-    return operationsByTag.searchAndFilter.aggregateTable({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
-      body: { filter, aggs },
-      ...this.extraProps
-    });
-  }
-}
-class MigrationRequestsApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  queryMigrationRequests({
-    workspace,
-    region,
-    database,
-    filter,
-    sort,
-    page,
-    columns
-  }) {
-    return operationsByTag.migrationRequests.queryMigrationRequests({
-      pathParams: { workspace, region, dbName: database },
-      body: { filter, sort, page, columns },
-      ...this.extraProps
-    });
-  }
-  createMigrationRequest({
-    workspace,
-    region,
-    database,
-    migration
-  }) {
-    return operationsByTag.migrationRequests.createMigrationRequest({
-      pathParams: { workspace, region, dbName: database },
-      body: migration,
-      ...this.extraProps
-    });
-  }
-  getMigrationRequest({
-    workspace,
-    region,
-    database,
-    migrationRequest
-  }) {
-    return operationsByTag.migrationRequests.getMigrationRequest({
-      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
-      ...this.extraProps
-    });
-  }
-  updateMigrationRequest({
-    workspace,
-    region,
-    database,
-    migrationRequest,
-    update
-  }) {
-    return operationsByTag.migrationRequests.updateMigrationRequest({
-      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
-      body: update,
-      ...this.extraProps
-    });
-  }
-  listMigrationRequestsCommits({
-    workspace,
-    region,
-    database,
-    migrationRequest,
-    page
-  }) {
-    return operationsByTag.migrationRequests.listMigrationRequestsCommits({
-      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
-      body: { page },
-      ...this.extraProps
-    });
-  }
-  compareMigrationRequest({
-    workspace,
-    region,
-    database,
-    migrationRequest
-  }) {
-    return operationsByTag.migrationRequests.compareMigrationRequest({
-      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
-      ...this.extraProps
-    });
-  }
-  getMigrationRequestIsMerged({
-    workspace,
-    region,
-    database,
-    migrationRequest
-  }) {
-    return operationsByTag.migrationRequests.getMigrationRequestIsMerged({
-      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
-      ...this.extraProps
-    });
-  }
-  mergeMigrationRequest({
-    workspace,
-    region,
-    database,
-    migrationRequest
-  }) {
-    return operationsByTag.migrationRequests.mergeMigrationRequest({
-      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
-      ...this.extraProps
-    });
-  }
-}
-class MigrationsApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getBranchMigrationHistory({
-    workspace,
-    region,
-    database,
-    branch,
-    limit,
-    startFrom
-  }) {
-    return operationsByTag.migrations.getBranchMigrationHistory({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { limit, startFrom },
-      ...this.extraProps
-    });
-  }
-  getBranchMigrationPlan({
-    workspace,
-    region,
-    database,
-    branch,
-    schema
-  }) {
-    return operationsByTag.migrations.getBranchMigrationPlan({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: schema,
-      ...this.extraProps
-    });
-  }
-  executeBranchMigrationPlan({
-    workspace,
-    region,
-    database,
-    branch,
-    plan
-  }) {
-    return operationsByTag.migrations.executeBranchMigrationPlan({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: plan,
-      ...this.extraProps
-    });
-  }
-  getBranchSchemaHistory({
-    workspace,
-    region,
-    database,
-    branch,
-    page
-  }) {
-    return operationsByTag.migrations.getBranchSchemaHistory({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { page },
-      ...this.extraProps
-    });
-  }
-  compareBranchWithUserSchema({
-    workspace,
-    region,
-    database,
-    branch,
-    schema,
-    schemaOperations,
-    branchOperations
-  }) {
-    return operationsByTag.migrations.compareBranchWithUserSchema({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { schema, schemaOperations, branchOperations },
-      ...this.extraProps
-    });
-  }
-  compareBranchSchemas({
-    workspace,
-    region,
-    database,
-    branch,
-    compare,
-    sourceBranchOperations,
-    targetBranchOperations
-  }) {
-    return operationsByTag.migrations.compareBranchSchemas({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, branchName: compare },
-      body: { sourceBranchOperations, targetBranchOperations },
-      ...this.extraProps
-    });
-  }
-  updateBranchSchema({
-    workspace,
-    region,
-    database,
-    branch,
-    migration
-  }) {
-    return operationsByTag.migrations.updateBranchSchema({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: migration,
-      ...this.extraProps
-    });
-  }
-  previewBranchSchemaEdit({
-    workspace,
-    region,
-    database,
-    branch,
-    data
-  }) {
-    return operationsByTag.migrations.previewBranchSchemaEdit({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: data,
-      ...this.extraProps
-    });
-  }
-  applyBranchSchemaEdit({
-    workspace,
-    region,
-    database,
-    branch,
-    edits
-  }) {
-    return operationsByTag.migrations.applyBranchSchemaEdit({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { edits },
-      ...this.extraProps
-    });
-  }
-  pushBranchMigrations({
-    workspace,
-    region,
-    database,
-    branch,
-    migrations
-  }) {
-    return operationsByTag.migrations.pushBranchMigrations({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { migrations },
-      ...this.extraProps
-    });
-  }
-}
-class DatabaseApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getDatabaseList({ workspace }) {
-    return operationsByTag.databases.getDatabaseList({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
-    });
-  }
-  createDatabase({
-    workspace,
-    database,
-    data,
-    headers
-  }) {
-    return operationsByTag.databases.createDatabase({
-      pathParams: { workspaceId: workspace, dbName: database },
-      body: data,
-      headers,
-      ...this.extraProps
-    });
-  }
-  deleteDatabase({
-    workspace,
-    database
-  }) {
-    return operationsByTag.databases.deleteDatabase({
-      pathParams: { workspaceId: workspace, dbName: database },
-      ...this.extraProps
-    });
-  }
-  getDatabaseMetadata({
-    workspace,
-    database
-  }) {
-    return operationsByTag.databases.getDatabaseMetadata({
-      pathParams: { workspaceId: workspace, dbName: database },
-      ...this.extraProps
-    });
-  }
-  updateDatabaseMetadata({
-    workspace,
-    database,
-    metadata
-  }) {
-    return operationsByTag.databases.updateDatabaseMetadata({
-      pathParams: { workspaceId: workspace, dbName: database },
-      body: metadata,
-      ...this.extraProps
-    });
-  }
-  renameDatabase({
-    workspace,
-    database,
-    newName
-  }) {
-    return operationsByTag.databases.renameDatabase({
-      pathParams: { workspaceId: workspace, dbName: database },
-      body: { newName },
-      ...this.extraProps
-    });
-  }
-  getDatabaseGithubSettings({
-    workspace,
-    database
-  }) {
-    return operationsByTag.databases.getDatabaseGithubSettings({
-      pathParams: { workspaceId: workspace, dbName: database },
-      ...this.extraProps
-    });
-  }
-  updateDatabaseGithubSettings({
-    workspace,
-    database,
-    settings
-  }) {
-    return operationsByTag.databases.updateDatabaseGithubSettings({
-      pathParams: { workspaceId: workspace, dbName: database },
-      body: settings,
-      ...this.extraProps
-    });
-  }
-  deleteDatabaseGithubSettings({
-    workspace,
-    database
-  }) {
-    return operationsByTag.databases.deleteDatabaseGithubSettings({
-      pathParams: { workspaceId: workspace, dbName: database },
-      ...this.extraProps
-    });
+    createTable,
+    deleteTable,
+    updateTable,
+    getTableSchema,
+    setTableSchema,
+    getTableColumns,
+    addTableColumn,
+    getColumn,
+    updateColumn,
+    deleteColumn
+  },
+  records: {
+    branchTransaction,
+    insertRecord,
+    getRecord,
+    insertRecordWithID,
+    updateRecordWithID,
+    upsertRecordWithID,
+    deleteRecord,
+    bulkInsertTableRecords
+  },
+  files: { getFileItem, putFileItem, deleteFileItem, getFile, putFile, deleteFile, fileAccess, fileUpload },
+  searchAndFilter: {
+    queryTable,
+    searchBranch,
+    searchTable,
+    vectorSearchTable,
+    askTable,
+    askTableSession,
+    summarizeTable,
+    aggregateTable
+  },
+  sql: { sqlQuery }
+};
+
+const controlPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "controlPlane" });
+
+const getAuthorizationCode = (variables, signal) => controlPlaneFetch({ url: "/oauth/authorize", method: "get", ...variables, signal });
+const grantAuthorizationCode = (variables, signal) => controlPlaneFetch({ url: "/oauth/authorize", method: "post", ...variables, signal });
+const getUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getUserAPIKeys = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys",
+  method: "get",
+  ...variables,
+  signal
+});
+const createUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "post",
+  ...variables,
+  signal
+});
+const deleteUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getUserOAuthClients = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/clients",
+  method: "get",
+  ...variables,
+  signal
+});
+const deleteUserOAuthClient = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/clients/{clientId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getUserOAuthAccessTokens = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/tokens",
+  method: "get",
+  ...variables,
+  signal
+});
+const deleteOAuthAccessToken = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/tokens/{token}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const updateOAuthAccessToken = (variables, signal) => controlPlaneFetch({ url: "/user/oauth/tokens/{token}", method: "patch", ...variables, signal });
+const getWorkspacesList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces",
+  method: "get",
+  ...variables,
+  signal
+});
+const createWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces",
+  method: "post",
+  ...variables,
+  signal
+});
+const getWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getWorkspaceMembersList = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members", method: "get", ...variables, signal });
+const updateWorkspaceMemberRole = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables, signal });
+const removeWorkspaceMember = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/members/{userId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const inviteWorkspaceMember = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables, signal });
+const updateWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables, signal });
+const cancelWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "delete", ...variables, signal });
+const acceptWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept", method: "post", ...variables, signal });
+const resendWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}/resend", method: "post", ...variables, signal });
+const listClusters = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "get", ...variables, signal });
+const createCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "post", ...variables, signal });
+const getCluster = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/clusters/{clusterId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters/{clusterId}", method: "patch", ...variables, signal });
+const getDatabaseList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/dbs",
+  method: "get",
+  ...variables,
+  signal
+});
+const createDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "put", ...variables, signal });
+const deleteDatabase = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/dbs/{dbName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "get", ...variables, signal });
+const updateDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "patch", ...variables, signal });
+const renameDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/rename", method: "post", ...variables, signal });
+const getDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "get", ...variables, signal });
+const updateDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "put", ...variables, signal });
+const deleteDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "delete", ...variables, signal });
+const listRegions = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/regions",
+  method: "get",
+  ...variables,
+  signal
+});
+const operationsByTag$1 = {
+  oAuth: {
+    getAuthorizationCode,
+    grantAuthorizationCode,
+    getUserOAuthClients,
+    deleteUserOAuthClient,
+    getUserOAuthAccessTokens,
+    deleteOAuthAccessToken,
+    updateOAuthAccessToken
+  },
+  users: { getUser, updateUser, deleteUser },
+  authentication: { getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
+  workspaces: {
+    getWorkspacesList,
+    createWorkspace,
+    getWorkspace,
+    updateWorkspace,
+    deleteWorkspace,
+    getWorkspaceMembersList,
+    updateWorkspaceMemberRole,
+    removeWorkspaceMember
+  },
+  invites: {
+    inviteWorkspaceMember,
+    updateWorkspaceMemberInvite,
+    cancelWorkspaceMemberInvite,
+    acceptWorkspaceMemberInvite,
+    resendWorkspaceMemberInvite
+  },
+  xbcontrolOther: { listClusters, createCluster, getCluster, updateCluster },
+  databases: {
+    getDatabaseList,
+    createDatabase,
+    deleteDatabase,
+    getDatabaseMetadata,
+    updateDatabaseMetadata,
+    renameDatabase,
+    getDatabaseGithubSettings,
+    updateDatabaseGithubSettings,
+    deleteDatabaseGithubSettings,
+    listRegions
   }
-  listRegions({ workspace }) {
-    return operationsByTag.databases.listRegions({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
+};
+
+const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
+
+const buildApiClient = () => class {
+  constructor(options = {}) {
+    const provider = options.host ?? "production";
+    const apiKey = options.apiKey ?? getAPIKey();
+    const trace = options.trace ?? defaultTrace;
+    const clientID = generateUUID();
+    if (!apiKey) {
+      throw new Error("Could not resolve a valid apiKey");
+    }
+    const extraProps = {
+      apiUrl: getHostUrl(provider, "main"),
+      workspacesApiUrl: getHostUrl(provider, "workspaces"),
+      fetch: getFetchImplementation(options.fetch),
+      apiKey,
+      trace,
+      clientName: options.clientName,
+      xataAgentExtra: options.xataAgentExtra,
+      clientID
+    };
+    return new Proxy(this, {
+      get: (_target, namespace) => {
+        if (operationsByTag[namespace] === void 0) {
+          return void 0;
+        }
+        return new Proxy(
+          {},
+          {
+            get: (_target2, operation) => {
+              if (operationsByTag[namespace][operation] === void 0) {
+                return void 0;
+              }
+              const method = operationsByTag[namespace][operation];
+              return async (params) => {
+                return await method({ ...params, ...extraProps });
+              };
+            }
+          }
+        );
+      }
     });
   }
+};
+class XataApiClient extends buildApiClient() {
 }
 
 class XataApiPlugin {
@@ -2657,16 +1430,18 @@ function transformImage(url, ...transformations) {
 class XataFile {
   constructor(file) {
     this.id = file.id;
-    this.name = file.name || "";
-    this.mediaType = file.mediaType || "application/octet-stream";
+    this.name = file.name;
+    this.mediaType = file.mediaType;
     this.base64Content = file.base64Content;
-    this.enablePublicUrl = file.enablePublicUrl ?? false;
-    this.signedUrlTimeout = file.signedUrlTimeout ?? 300;
-    this.size = file.size ?? 0;
-    this.version = file.version ?? 1;
-    this.url = file.url || "";
+    this.enablePublicUrl = file.enablePublicUrl;
+    this.signedUrlTimeout = file.signedUrlTimeout;
+    this.uploadUrlTimeout = file.uploadUrlTimeout;
+    this.size = file.size;
+    this.version = file.version;
+    this.url = file.url;
     this.signedUrl = file.signedUrl;
-    this.attributes = file.attributes || {};
+    this.uploadUrl = file.uploadUrl;
+    this.attributes = file.attributes;
   }
   static fromBuffer(buffer, options = {}) {
     const base64Content = buffer.toString("base64");
@@ -2756,7 +1531,7 @@ class XataFile {
 const parseInputFileEntry = async (entry) => {
   if (!isDefined(entry))
     return null;
-  const { id, name, mediaType, base64Content, enablePublicUrl, signedUrlTimeout } = await entry;
+  const { id, name, mediaType, base64Content, enablePublicUrl, signedUrlTimeout, uploadUrlTimeout } = await entry;
   return compactObject({
     id,
     // Name cannot be an empty string in our API
@@ -2764,7 +1539,8 @@ const parseInputFileEntry = async (entry) => {
     mediaType,
     base64Content,
     enablePublicUrl,
-    signedUrlTimeout
+    signedUrlTimeout,
+    uploadUrlTimeout
   });
 };
 
@@ -3635,7 +2411,7 @@ class RestRepository extends Query {
   }
   async search(query, options = {}) {
     return __privateGet$4(this, _trace).call(this, "search", async () => {
-      const { records } = await searchTable({
+      const { records, totalCount } = await searchTable({
         pathParams: {
           workspace: "{workspaceId}",
           dbBranchName: "{dbBranch}",
@@ -3655,12 +2431,15 @@ class RestRepository extends Query {
         ...__privateGet$4(this, _getFetchProps).call(this)
       });
       const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-      return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"]));
+      return {
+        records: records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"])),
+        totalCount
+      };
     });
   }
   async vectorSearch(column, query, options) {
     return __privateGet$4(this, _trace).call(this, "vectorSearch", async () => {
-      const { records } = await vectorSearchTable({
+      const { records, totalCount } = await vectorSearchTable({
         pathParams: {
           workspace: "{workspaceId}",
           dbBranchName: "{dbBranch}",
@@ -3677,7 +2456,10 @@ class RestRepository extends Query {
         ...__privateGet$4(this, _getFetchProps).call(this)
       });
       const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-      return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"]));
+      return {
+        records: records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"])),
+        totalCount
+      };
     });
   }
   async aggregate(aggs, filter) {
@@ -4357,7 +3139,7 @@ function getContentType(file) {
   if (typeof file === "string") {
     return "text/plain";
   }
-  if ("mediaType" in file) {
+  if ("mediaType" in file && file.mediaType !== void 0) {
     return file.mediaType;
   }
   if (isBlob(file)) {
@@ -4405,22 +3187,26 @@ class SearchPlugin extends XataPlugin {
   build(pluginOptions) {
     return {
       all: async (query, options = {}) => {
-        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const { records, totalCount } = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
         const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, pluginOptions);
-        return records.map((record) => {
-          const { table = "orphan" } = record.xata;
-          return { table, record: initObject(this.db, schemaTables, table, record, ["*"]) };
-        });
+        return {
+          totalCount,
+          records: records.map((record) => {
+            const { table = "orphan" } = record.xata;
+            return { table, record: initObject(this.db, schemaTables, table, record, ["*"]) };
+          })
+        };
       },
       byTable: async (query, options = {}) => {
-        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const { records: rawRecords, totalCount } = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
         const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, pluginOptions);
-        return records.reduce((acc, record) => {
+        const records = rawRecords.reduce((acc, record) => {
           const { table = "orphan" } = record.xata;
           const items = acc[table] ?? [];
           const item = initObject(this.db, schemaTables, table, record, ["*"]);
           return { ...acc, [table]: [...items, item] };
         }, {});
+        return { totalCount, records };
       }
     };
   }
@@ -4429,13 +3215,13 @@ _schemaTables = new WeakMap();
 _search = new WeakSet();
 search_fn = async function(query, options, pluginOptions) {
   const { tables, fuzziness, highlight, prefix, page } = options ?? {};
-  const { records } = await searchBranch({
+  const { records, totalCount } = await searchBranch({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
     // @ts-ignore https://github.com/xataio/client-ts/issues/313
     body: { tables, query, fuzziness, prefix, highlight, page },
     ...pluginOptions
   });
-  return records;
+  return { records, totalCount };
 };
 _getSchemaTables = new WeakSet();
 getSchemaTables_fn = async function(pluginOptions) {
@@ -4745,21 +3531,6 @@ const deserialize = (json) => {
   return defaultSerializer.fromJSON(json);
 };
 
-function buildWorkerRunner(config) {
-  return function xataWorker(name, worker) {
-    return async (...args) => {
-      const url = process.env.NODE_ENV === "development" ? `http://localhost:64749/${name}` : `https://dispatcher.xata.workers.dev/${config.workspace}/${config.worker}/${name}`;
-      const result = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: serialize({ args })
-      });
-      const text = await result.text();
-      return deserialize(text);
-    };
-  };
-}
-
 class XataError extends Error {
   constructor(message, status) {
     super(message);
@@ -4797,13 +3568,13 @@ exports.addGitBranchesEntry = addGitBranchesEntry;
 exports.addTableColumn = addTableColumn;
 exports.aggregateTable = aggregateTable;
 exports.applyBranchSchemaEdit = applyBranchSchemaEdit;
+exports.applyMigration = applyMigration;
 exports.askTable = askTable;
 exports.askTableSession = askTableSession;
 exports.branchTransaction = branchTransaction;
 exports.buildClient = buildClient;
 exports.buildPreviewBranchName = buildPreviewBranchName;
 exports.buildProviderString = buildProviderString;
-exports.buildWorkerRunner = buildWorkerRunner;
 exports.bulkInsertTableRecords = bulkInsertTableRecords;
 exports.cancelWorkspaceMemberInvite = cancelWorkspaceMemberInvite;
 exports.compareBranchSchemas = compareBranchSchemas;
@@ -4837,6 +3608,7 @@ exports.equals = equals;
 exports.executeBranchMigrationPlan = executeBranchMigrationPlan;
 exports.exists = exists;
 exports.fileAccess = fileAccess;
+exports.fileUpload = fileUpload;
 exports.ge = ge;
 exports.getAPIKey = getAPIKey;
 exports.getAuthorizationCode = getAuthorizationCode;
@@ -4911,6 +3683,9 @@ exports.operationsByTag = operationsByTag;
 exports.parseProviderString = parseProviderString;
 exports.parseWorkspacesUrlParts = parseWorkspacesUrlParts;
 exports.pattern = pattern;
+exports.pgRollJobStatus = pgRollJobStatus;
+exports.pgRollMigrationHistory = pgRollMigrationHistory;
+exports.pgRollStatus = pgRollStatus;
 exports.previewBranchSchemaEdit = previewBranchSchemaEdit;
 exports.pushBranchMigrations = pushBranchMigrations;
 exports.putFile = putFile;