@xata.io/client 0.29.5 → 0.30.0

package/dist/index.cjs

@@ -2026,14 +2026,14 @@ function getPreviewBranch() {
   }
 }
 
-var __typeError$8 = (msg) => {
+var __typeError$7 = (msg) => {
   throw TypeError(msg);
 };
-var __accessCheck$8 = (obj, member, msg) => member.has(obj) || __typeError$8("Cannot " + msg);
-var __privateGet$7 = (obj, member, getter) => (__accessCheck$8(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$8 = (obj, member, value) => member.has(obj) ? __typeError$8("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$6 = (obj, member, value, setter) => (__accessCheck$8(obj, member, "write to private field"), member.set(obj, value), value);
-var __privateMethod$4 = (obj, member, method) => (__accessCheck$8(obj, member, "access private method"), method);
+var __accessCheck$7 = (obj, member, msg) => member.has(obj) || __typeError$7("Cannot " + msg);
+var __privateGet$6 = (obj, member, getter) => (__accessCheck$7(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$7 = (obj, member, value) => member.has(obj) ? __typeError$7("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$5 = (obj, member, value, setter) => (__accessCheck$7(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod$4 = (obj, member, method) => (__accessCheck$7(obj, member, "access private method"), method);
 var _fetch, _queue, _concurrency, _ApiRequestPool_instances, enqueue_fn;
 const REQUEST_TIMEOUT = 5 * 60 * 1e3;
 function getFetchImplementation(userFetch) {
@@ -2047,23 +2047,23 @@ function getFetchImplementation(userFetch) {
 }
 class ApiRequestPool {
   constructor(concurrency = 10) {
-    __privateAdd$8(this, _ApiRequestPool_instances);
-    __privateAdd$8(this, _fetch);
-    __privateAdd$8(this, _queue);
-    __privateAdd$8(this, _concurrency);
-    __privateSet$6(this, _queue, []);
-    __privateSet$6(this, _concurrency, concurrency);
+    __privateAdd$7(this, _ApiRequestPool_instances);
+    __privateAdd$7(this, _fetch);
+    __privateAdd$7(this, _queue);
+    __privateAdd$7(this, _concurrency);
+    __privateSet$5(this, _queue, []);
+    __privateSet$5(this, _concurrency, concurrency);
     this.running = 0;
     this.started = 0;
   }
   setFetch(fetch2) {
-    __privateSet$6(this, _fetch, fetch2);
+    __privateSet$5(this, _fetch, fetch2);
   }
   getFetch() {
-    if (!__privateGet$7(this, _fetch)) {
+    if (!__privateGet$6(this, _fetch)) {
       throw new Error("Fetch not set");
     }
-    return __privateGet$7(this, _fetch);
+    return __privateGet$6(this, _fetch);
   }
   request(url, options) {
     const start = /* @__PURE__ */ new Date();
@@ -2095,19 +2095,19 @@ _queue = new WeakMap();
 _concurrency = new WeakMap();
 _ApiRequestPool_instances = new WeakSet();
 enqueue_fn = function(task) {
-  const promise = new Promise((resolve) => __privateGet$7(this, _queue).push(resolve)).finally(() => {
+  const promise = new Promise((resolve) => __privateGet$6(this, _queue).push(resolve)).finally(() => {
     this.started--;
     this.running++;
   }).then(() => task()).finally(() => {
     this.running--;
-    const next = __privateGet$7(this, _queue).shift();
+    const next = __privateGet$6(this, _queue).shift();
     if (next !== void 0) {
       this.started++;
       next();
     }
   });
-  if (this.running + this.started < __privateGet$7(this, _concurrency)) {
-    const next = __privateGet$7(this, _queue).shift();
+  if (this.running + this.started < __privateGet$6(this, _concurrency)) {
+    const next = __privateGet$6(this, _queue).shift();
     if (next !== void 0) {
       this.started++;
       next();
@@ -2296,7 +2296,7 @@ function defaultOnOpen(response) {
   }
 }
 
-const VERSION = "0.29.5";
+const VERSION = "0.30.0";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -2608,6 +2608,36 @@ function parseUrl(url) {
 
 const dataPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "dataPlane" });
 
+const listClusterBranches = (variables, signal) => dataPlaneFetch({
+  url: "/cluster/{clusterId}/branches",
+  method: "get",
+  ...variables,
+  signal
+});
+const listClusterExtensions = (variables, signal) => dataPlaneFetch({
+  url: "/cluster/{clusterId}/extensions",
+  method: "get",
+  ...variables,
+  signal
+});
+const installClusterExtension = (variables, signal) => dataPlaneFetch({
+  url: "/cluster/{clusterId}/extensions",
+  method: "post",
+  ...variables,
+  signal
+});
+const dropClusterExtension = (variables, signal) => dataPlaneFetch({
+  url: "/cluster/{clusterId}/extensions",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getClusterMetrics = (variables, signal) => dataPlaneFetch({
+  url: "/cluster/{clusterId}/metrics",
+  method: "get",
+  ...variables,
+  signal
+});
 const applyMigration = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/migrations/apply",
   method: "post",
@@ -2650,6 +2680,12 @@ const getBranchMigrationJobStatus = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+const getMigrationJobs = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/jobs",
+  method: "get",
+  ...variables,
+  signal
+});
 const getMigrationJobStatus = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/migrations/jobs/{jobId}",
   method: "get",
@@ -2694,12 +2730,25 @@ const getSchema = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+const getSchemas = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schemas",
+  method: "get",
+  ...variables,
+  signal
+});
 const copyBranch = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/copy",
   method: "post",
   ...variables,
   signal
 });
+const getBranchMoveStatus = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/move", method: "get", ...variables, signal });
+const moveBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/move",
+  method: "put",
+  ...variables,
+  signal
+});
 const updateBranchMetadata = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/metadata",
   method: "put",
@@ -3054,6 +3103,13 @@ const sqlBatchQuery = (variables, signal) => dataPlaneFetch({
   signal
 });
 const operationsByTag$2 = {
+  cluster: {
+    listClusterBranches,
+    listClusterExtensions,
+    installClusterExtension,
+    dropClusterExtension,
+    getClusterMetrics
+  },
   migrations: {
     applyMigration,
     startMigration,
@@ -3062,9 +3118,11 @@ const operationsByTag$2 = {
     adaptTable,
     adaptAllTables,
     getBranchMigrationJobStatus,
+    getMigrationJobs,
     getMigrationJobStatus,
     getMigrationHistory,
     getSchema,
+    getSchemas,
     getBranchMigrationHistory,
     getBranchMigrationPlan,
     executeBranchMigrationPlan,
@@ -3082,6 +3140,8 @@ const operationsByTag$2 = {
     createBranch,
     deleteBranch,
     copyBranch,
+    getBranchMoveStatus,
+    moveBranch,
     updateBranchMetadata,
     getBranchMetadata,
     getBranchStats,
@@ -3450,18 +3510,8 @@ const operationsByTag$1 = {
 
 const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
 
-var __typeError$7 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$7 = (obj, member, msg) => member.has(obj) || __typeError$7("Cannot " + msg);
-var __privateGet$6 = (obj, member, getter) => (__accessCheck$7(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$7 = (obj, member, value) => member.has(obj) ? __typeError$7("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$5 = (obj, member, value, setter) => (__accessCheck$7(obj, member, "write to private field"), member.set(obj, value), value);
-var _extraProps, _namespaces;
-class XataApiClient {
+const buildApiClient = () => class {
   constructor(options = {}) {
-    __privateAdd$7(this, _extraProps);
-    __privateAdd$7(this, _namespaces, {});
     const provider = options.host ?? "production";
     const apiKey = options.apiKey ?? getAPIKey();
     const trace = options.trace ?? defaultTrace;
@@ -3469,7 +3519,7 @@ class XataApiClient {
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
-    __privateSet$5(this, _extraProps, {
+    const extraProps = {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
       fetch: getFetchImplementation(options.fetch),
@@ -3478,1304 +3528,31 @@ class XataApiClient {
       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 });
+              };
+            }
+          }
+        );
+      }
     });
   }
-  get user() {
-    if (!__privateGet$6(this, _namespaces).user) __privateGet$6(this, _namespaces).user = new UserApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).user;
-  }
-  get authentication() {
-    if (!__privateGet$6(this, _namespaces).authentication) __privateGet$6(this, _namespaces).authentication = new AuthenticationApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).authentication;
-  }
-  get workspaces() {
-    if (!__privateGet$6(this, _namespaces).workspaces) __privateGet$6(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).workspaces;
-  }
-  get invites() {
-    if (!__privateGet$6(this, _namespaces).invites) __privateGet$6(this, _namespaces).invites = new InvitesApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).invites;
-  }
-  get database() {
-    if (!__privateGet$6(this, _namespaces).database) __privateGet$6(this, _namespaces).database = new DatabaseApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).database;
-  }
-  get branches() {
-    if (!__privateGet$6(this, _namespaces).branches) __privateGet$6(this, _namespaces).branches = new BranchApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).branches;
-  }
-  get migrations() {
-    if (!__privateGet$6(this, _namespaces).migrations) __privateGet$6(this, _namespaces).migrations = new MigrationsApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).migrations;
-  }
-  get migrationRequests() {
-    if (!__privateGet$6(this, _namespaces).migrationRequests)
-      __privateGet$6(this, _namespaces).migrationRequests = new MigrationRequestsApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).migrationRequests;
-  }
-  get tables() {
-    if (!__privateGet$6(this, _namespaces).tables) __privateGet$6(this, _namespaces).tables = new TableApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).tables;
-  }
-  get records() {
-    if (!__privateGet$6(this, _namespaces).records) __privateGet$6(this, _namespaces).records = new RecordsApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).records;
-  }
-  get files() {
-    if (!__privateGet$6(this, _namespaces).files) __privateGet$6(this, _namespaces).files = new FilesApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).files;
-  }
-  get searchAndFilter() {
-    if (!__privateGet$6(this, _namespaces).searchAndFilter) __privateGet$6(this, _namespaces).searchAndFilter = new SearchAndFilterApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(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
-    });
-  }
-  pgRollMigrationHistory({
-    workspace,
-    region,
-    database,
-    branch
-  }) {
-    return operationsByTag.migrations.getMigrationHistory({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      ...this.extraProps
-    });
-  }
-  applyMigration({
-    workspace,
-    region,
-    database,
-    branch,
-    migration
-  }) {
-    return operationsByTag.migrations.applyMigration({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: migration,
-      ...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
-    });
-  }
-  getSchema({
-    workspace,
-    region,
-    database,
-    branch
-  }) {
-    return operationsByTag.migrations.getSchema({
-      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      ...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
-    });
-  }
-  listRegions({ workspace }) {
-    return operationsByTag.databases.listRegions({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
-    });
-  }
+};
+class XataApiClient extends buildApiClient() {
 }
 
 class XataApiPlugin {
@@ -6551,16 +5328,13 @@ class SQLPlugin extends XataPlugin {
         throw new Error("Invalid usage of `xata.sql`. Please use it as a tagged template or with an object.");
       }
       const { statement, params, consistency, responseType } = prepareParams(query, parameters);
-      const {
-        records,
-        rows,
-        warning,
-        columns = []
-      } = await sqlQuery({
+      const { warning, columns, ...response } = await sqlQuery({
         pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
         body: { statement, params, consistency, responseType },
         ...pluginOptions
       });
+      const records = "records" in response ? response.records : void 0;
+      const rows = "rows" in response ? response.rows : void 0;
       return { records, rows, warning, columns };
     };
     sqlFunction.connectionString = buildConnectionString(pluginOptions);
@@ -6889,6 +5663,7 @@ exports.deleteUserAPIKey = deleteUserAPIKey;
 exports.deleteUserOAuthClient = deleteUserOAuthClient;
 exports.deleteWorkspace = deleteWorkspace;
 exports.deserialize = deserialize;
+exports.dropClusterExtension = dropClusterExtension;
 exports.endsWith = endsWith;
 exports.equals = equals;
 exports.executeBranchMigrationPlan = executeBranchMigrationPlan;
@@ -6905,9 +5680,11 @@ exports.getBranchMetadata = getBranchMetadata;
 exports.getBranchMigrationHistory = getBranchMigrationHistory;
 exports.getBranchMigrationJobStatus = getBranchMigrationJobStatus;
 exports.getBranchMigrationPlan = getBranchMigrationPlan;
+exports.getBranchMoveStatus = getBranchMoveStatus;
 exports.getBranchSchemaHistory = getBranchSchemaHistory;
 exports.getBranchStats = getBranchStats;
 exports.getCluster = getCluster;
+exports.getClusterMetrics = getClusterMetrics;
 exports.getColumn = getColumn;
 exports.getDatabaseGithubSettings = getDatabaseGithubSettings;
 exports.getDatabaseList = getDatabaseList;
@@ -6920,11 +5697,13 @@ exports.getGitBranchesMapping = getGitBranchesMapping;
 exports.getHostUrl = getHostUrl;
 exports.getMigrationHistory = getMigrationHistory;
 exports.getMigrationJobStatus = getMigrationJobStatus;
+exports.getMigrationJobs = getMigrationJobs;
 exports.getMigrationRequest = getMigrationRequest;
 exports.getMigrationRequestIsMerged = getMigrationRequestIsMerged;
 exports.getPreviewBranch = getPreviewBranch;
 exports.getRecord = getRecord;
 exports.getSchema = getSchema;
+exports.getSchemas = getSchemas;
 exports.getTableColumns = getTableColumns;
 exports.getTableSchema = getTableSchema;
 exports.getUser = getUser;
@@ -6949,6 +5728,7 @@ exports.includesAny = includesAny;
 exports.includesNone = includesNone;
 exports.insertRecord = insertRecord;
 exports.insertRecordWithID = insertRecordWithID;
+exports.installClusterExtension = installClusterExtension;
 exports.inviteWorkspaceMember = inviteWorkspaceMember;
 exports.is = is;
 exports.isCursorPaginationOptions = isCursorPaginationOptions;
@@ -6963,12 +5743,15 @@ exports.le = le;
 exports.lessEquals = lessEquals;
 exports.lessThan = lessThan;
 exports.lessThanEquals = lessThanEquals;
+exports.listClusterBranches = listClusterBranches;
+exports.listClusterExtensions = listClusterExtensions;
 exports.listClusters = listClusters;
 exports.listMigrationRequestsCommits = listMigrationRequestsCommits;
 exports.listRegions = listRegions;
 exports.lt = lt;
 exports.lte = lte;
 exports.mergeMigrationRequest = mergeMigrationRequest;
+exports.moveBranch = moveBranch;
 exports.notExists = notExists;
 exports.operationsByTag = operationsByTag;
 exports.parseProviderString = parseProviderString;