@xata.io/client 0.0.0-alpha.vecd13ea → 0.0.0-alpha.vecdf10f

package/dist/index.cjs

@@ -60,6 +60,9 @@ function isString(value) {
 function isStringArray(value) {
   return isDefined(value) && Array.isArray(value) && value.every(isString);
 }
+function isNumber(value) {
+  return isDefined(value) && typeof value === "number";
+}
 function toBase64(value) {
   try {
     return btoa(value);
@@ -68,6 +71,17 @@ function toBase64(value) {
     return buf.from(value).toString("base64");
   }
 }
+function deepMerge(a, b) {
+  const result = { ...a };
+  for (const [key, value] of Object.entries(b)) {
+    if (isObject(value) && isObject(result[key])) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 
 function getEnvironment() {
   try {
@@ -172,7 +186,7 @@ function getFetchImplementation(userFetch) {
   return fetchImpl;
 }
 
-const VERSION = "0.0.0-alpha.vecd13ea";
+const VERSION = "0.0.0-alpha.vecdf10f";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -229,15 +243,18 @@ const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   return url.replace(/\{\w*\}/g, (key) => cleanPathParams[key.slice(1, -1)]) + queryString;
 };
 function buildBaseUrl({
+  endpoint,
   path,
   workspacesApiUrl,
   apiUrl,
-  pathParams
+  pathParams = {}
 }) {
-  if (pathParams?.workspace === void 0)
-    return `${apiUrl}${path}`;
-  const url = typeof workspacesApiUrl === "string" ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
-  return url.replace("{workspaceId}", String(pathParams.workspace));
+  if (endpoint === "dataPlane") {
+    const url = isString(workspacesApiUrl) ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
+    const urlWithWorkspace = isString(pathParams.workspace) ? url.replace("{workspaceId}", String(pathParams.workspace)) : url;
+    return isString(pathParams.region) ? urlWithWorkspace.replace("{region}", String(pathParams.region)) : urlWithWorkspace;
+  }
+  return `${apiUrl}${path}`;
 }
 function hostHeader(url) {
   const pattern = /.*:\/\/(?<host>[^/]+).*/;
@@ -253,15 +270,18 @@ async function fetch$1({
   queryParams,
   fetchImpl,
   apiKey,
+  endpoint,
   apiUrl,
   workspacesApiUrl,
   trace,
-  signal
+  signal,
+  clientID,
+  sessionID
 }) {
   return trace(
     `${method.toUpperCase()} ${path}`,
     async ({ setAttributes }) => {
-      const baseUrl = buildBaseUrl({ path, workspacesApiUrl, pathParams, apiUrl });
+      const baseUrl = buildBaseUrl({ endpoint, path, workspacesApiUrl, pathParams, apiUrl });
       const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
       const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
       setAttributes({
@@ -274,6 +294,8 @@ async function fetch$1({
         headers: {
           "Content-Type": "application/json",
           "User-Agent": `Xata client-ts/${VERSION}`,
+          "X-Xata-Client-ID": clientID ?? "",
+          "X-Xata-Session-ID": sessionID ?? "",
           ...headers,
           ...hostHeader(fullUrl),
           Authorization: `Bearer ${apiKey}`
@@ -314,391 +336,355 @@ function parseUrl(url) {
   }
 }
 
-const getUser = (variables, signal) => fetch$1({ url: "/user", method: "get", ...variables, signal });
-const updateUser = (variables, signal) => fetch$1({
-  url: "/user",
-  method: "put",
-  ...variables,
-  signal
-});
-const deleteUser = (variables, signal) => fetch$1({ url: "/user", method: "delete", ...variables, signal });
-const getUserAPIKeys = (variables, signal) => fetch$1({
-  url: "/user/keys",
+const dataPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "dataPlane" });
+
+const dEPRECATEDgetDatabaseList = (variables, signal) => dataPlaneFetch({ url: "/dbs", method: "get", ...variables, signal });
+const getBranchList = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}",
   method: "get",
   ...variables,
   signal
 });
-const createUserAPIKey = (variables, signal) => fetch$1({
-  url: "/user/keys/{keyName}",
-  method: "post",
+const dEPRECATEDcreateDatabase = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}", method: "put", ...variables, signal });
+const dEPRECATEDdeleteDatabase = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}", method: "delete", ...variables, signal });
+const dEPRECATEDgetDatabaseMetadata = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/metadata", method: "get", ...variables, signal });
+const dEPRECATEDupdateDatabaseMetadata = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/metadata", method: "patch", ...variables, signal });
+const getBranchDetails = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}",
+  method: "get",
   ...variables,
   signal
 });
-const deleteUserAPIKey = (variables, signal) => fetch$1({
-  url: "/user/keys/{keyName}",
+const createBranch = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}", method: "put", ...variables, signal });
+const deleteBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}",
   method: "delete",
   ...variables,
   signal
 });
-const createWorkspace = (variables, signal) => fetch$1({
-  url: "/workspaces",
-  method: "post",
+const updateBranchMetadata = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/metadata",
+  method: "put",
   ...variables,
   signal
 });
-const getWorkspacesList = (variables, signal) => fetch$1({
-  url: "/workspaces",
+const getBranchMetadata = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/metadata",
   method: "get",
   ...variables,
   signal
 });
-const getWorkspace = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}",
+const getBranchStats = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/stats",
   method: "get",
   ...variables,
   signal
 });
-const updateWorkspace = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}",
-  method: "put",
-  ...variables,
-  signal
-});
-const deleteWorkspace = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const getWorkspaceMembersList = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}/members",
+const getGitBranchesMapping = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables, signal });
+const addGitBranchesEntry = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables, signal });
+const removeGitBranchesEntry = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables, signal });
+const resolveBranch = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/resolveBranch", method: "get", ...variables, signal });
+const getBranchMigrationHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations", method: "get", ...variables, signal });
+const getBranchMigrationPlan = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/plan", method: "post", ...variables, signal });
+const executeBranchMigrationPlan = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/execute", method: "post", ...variables, signal });
+const queryMigrationRequests = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/query", method: "post", ...variables, signal });
+const createMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations", method: "post", ...variables, signal });
+const getMigrationRequest = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}",
   method: "get",
   ...variables,
   signal
 });
-const updateWorkspaceMemberRole = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables, signal });
-const removeWorkspaceMember = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}/members/{userId}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const inviteWorkspaceMember = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables, signal });
-const updateWorkspaceMemberInvite = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables, signal });
-const cancelWorkspaceMemberInvite = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteId}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const resendWorkspaceMemberInvite = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteId}/resend",
-  method: "post",
-  ...variables,
-  signal
-});
-const acceptWorkspaceMemberInvite = (variables, signal) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept",
+const updateMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}", method: "patch", ...variables, signal });
+const listMigrationRequestsCommits = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}/commits", method: "post", ...variables, signal });
+const compareMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}/compare", method: "post", ...variables, signal });
+const getMigrationRequestIsMerged = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}/merge", method: "get", ...variables, signal });
+const mergeMigrationRequest = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}/merge",
   method: "post",
   ...variables,
   signal
 });
-const getDatabaseList = (variables, signal) => fetch$1({
-  url: "/dbs",
-  method: "get",
-  ...variables,
-  signal
-});
-const getBranchList = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}",
-  method: "get",
-  ...variables,
-  signal
-});
-const createDatabase = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}",
+const getBranchSchemaHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/history", method: "post", ...variables, signal });
+const compareBranchWithUserSchema = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/compare", method: "post", ...variables, signal });
+const compareBranchSchemas = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/compare/{branchName}", method: "post", ...variables, signal });
+const updateBranchSchema = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/update", method: "post", ...variables, signal });
+const previewBranchSchemaEdit = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/preview", method: "post", ...variables, signal });
+const applyBranchSchemaEdit = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/apply", method: "post", ...variables, signal });
+const createTable = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}",
   method: "put",
   ...variables,
   signal
 });
-const deleteDatabase = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}",
+const deleteTable = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}",
   method: "delete",
   ...variables,
   signal
 });
-const getDatabaseMetadata = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}/metadata",
+const updateTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}", method: "patch", ...variables, signal });
+const getTableSchema = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/schema",
   method: "get",
   ...variables,
   signal
 });
-const updateDatabaseMetadata = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/metadata", method: "patch", ...variables, signal });
-const getGitBranchesMapping = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables, signal });
-const addGitBranchesEntry = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables, signal });
-const removeGitBranchesEntry = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables, signal });
-const resolveBranch = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}/resolveBranch",
+const setTableSchema = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/schema", method: "put", ...variables, signal });
+const getTableColumns = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/columns",
   method: "get",
   ...variables,
   signal
 });
-const queryMigrationRequests = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/query", method: "post", ...variables, signal });
-const createMigrationRequest = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations", method: "post", ...variables, signal });
-const getMigrationRequest = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}/migrations/{mrNumber}",
+const addTableColumn = (variables, signal) => dataPlaneFetch(
+  { url: "/db/{dbBranchName}/tables/{tableName}/columns", method: "post", ...variables, signal }
+);
+const getColumn = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
   method: "get",
   ...variables,
   signal
 });
-const updateMigrationRequest = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}", method: "patch", ...variables, signal });
-const listMigrationRequestsCommits = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}/commits", method: "post", ...variables, signal });
-const compareMigrationRequest = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}/compare", method: "post", ...variables, signal });
-const getMigrationRequestIsMerged = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}/merge", method: "get", ...variables, signal });
-const mergeMigrationRequest = (variables, signal) => fetch$1({
-  url: "/dbs/{dbName}/migrations/{mrNumber}/merge",
-  method: "post",
+const updateColumn = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}", method: "patch", ...variables, signal });
+const deleteColumn = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
+  method: "delete",
   ...variables,
   signal
 });
-const getBranchDetails = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}",
+const insertRecord = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data", method: "post", ...variables, signal });
+const getRecord = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
   method: "get",
   ...variables,
   signal
 });
-const createBranch = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}", method: "put", ...variables, signal });
-const deleteBranch = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}",
-  method: "delete",
-  ...variables,
-  signal
-});
-const updateBranchMetadata = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/metadata",
-  method: "put",
+const insertRecordWithID = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "put", ...variables, signal });
+const updateRecordWithID = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "patch", ...variables, signal });
+const upsertRecordWithID = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "post", ...variables, signal });
+const deleteRecord = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "delete", ...variables, signal });
+const bulkInsertTableRecords = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables, signal });
+const queryTable = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/query",
+  method: "post",
   ...variables,
   signal
 });
-const getBranchMetadata = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/metadata",
-  method: "get",
+const searchBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/search",
+  method: "post",
   ...variables,
   signal
 });
-const getBranchMigrationHistory = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/migrations", method: "get", ...variables, signal });
-const executeBranchMigrationPlan = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/migrations/execute", method: "post", ...variables, signal });
-const getBranchMigrationPlan = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/migrations/plan", method: "post", ...variables, signal });
-const compareBranchWithUserSchema = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/compare", method: "post", ...variables, signal });
-const compareBranchSchemas = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/compare/{branchName}", method: "post", ...variables, signal });
-const updateBranchSchema = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/schema/update",
+const searchTable = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/search",
   method: "post",
   ...variables,
   signal
 });
-const previewBranchSchemaEdit = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/preview", method: "post", ...variables, signal });
-const applyBranchSchemaEdit = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/apply", method: "post", ...variables, signal });
-const getBranchSchemaHistory = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/history", method: "post", ...variables, signal });
-const getBranchStats = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/stats",
+const summarizeTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/summarize", method: "post", ...variables, signal });
+const aggregateTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/aggregate", method: "post", ...variables, signal });
+const operationsByTag$2 = {
+  database: {
+    dEPRECATEDgetDatabaseList,
+    dEPRECATEDcreateDatabase,
+    dEPRECATEDdeleteDatabase,
+    dEPRECATEDgetDatabaseMetadata,
+    dEPRECATEDupdateDatabaseMetadata
+  },
+  branch: {
+    getBranchList,
+    getBranchDetails,
+    createBranch,
+    deleteBranch,
+    updateBranchMetadata,
+    getBranchMetadata,
+    getBranchStats,
+    getGitBranchesMapping,
+    addGitBranchesEntry,
+    removeGitBranchesEntry,
+    resolveBranch
+  },
+  migrations: {
+    getBranchMigrationHistory,
+    getBranchMigrationPlan,
+    executeBranchMigrationPlan,
+    getBranchSchemaHistory,
+    compareBranchWithUserSchema,
+    compareBranchSchemas,
+    updateBranchSchema,
+    previewBranchSchemaEdit,
+    applyBranchSchemaEdit
+  },
+  migrationRequests: {
+    queryMigrationRequests,
+    createMigrationRequest,
+    getMigrationRequest,
+    updateMigrationRequest,
+    listMigrationRequestsCommits,
+    compareMigrationRequest,
+    getMigrationRequestIsMerged,
+    mergeMigrationRequest
+  },
+  table: {
+    createTable,
+    deleteTable,
+    updateTable,
+    getTableSchema,
+    setTableSchema,
+    getTableColumns,
+    addTableColumn,
+    getColumn,
+    updateColumn,
+    deleteColumn
+  },
+  records: {
+    insertRecord,
+    getRecord,
+    insertRecordWithID,
+    updateRecordWithID,
+    upsertRecordWithID,
+    deleteRecord,
+    bulkInsertTableRecords
+  },
+  searchAndFilter: { queryTable, searchBranch, searchTable, summarizeTable, aggregateTable }
+};
+
+const controlPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "controlPlane" });
+
+const getUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
   method: "get",
   ...variables,
   signal
 });
-const createTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}",
+const updateUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
   method: "put",
   ...variables,
   signal
 });
-const deleteTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}",
+const deleteUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
   method: "delete",
   ...variables,
   signal
 });
-const updateTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}",
-  method: "patch",
+const getUserAPIKeys = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys",
+  method: "get",
   ...variables,
   signal
 });
-const getTableSchema = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/schema",
-  method: "get",
+const createUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "post",
   ...variables,
   signal
 });
-const setTableSchema = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/schema",
-  method: "put",
+const deleteUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "delete",
   ...variables,
   signal
 });
-const getTableColumns = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns",
+const getWorkspacesList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces",
   method: "get",
   ...variables,
   signal
 });
-const addTableColumn = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns",
+const createWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces",
   method: "post",
   ...variables,
   signal
 });
-const getColumn = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
+const getWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
   method: "get",
   ...variables,
   signal
 });
-const deleteColumn = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
-  method: "delete",
+const updateWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "put",
   ...variables,
   signal
 });
-const updateColumn = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
-  method: "patch",
+const deleteWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "delete",
   ...variables,
   signal
 });
-const insertRecord = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data", method: "post", ...variables, signal });
-const insertRecordWithID = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "put", ...variables, signal });
-const updateRecordWithID = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "patch", ...variables, signal });
-const upsertRecordWithID = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "post", ...variables, signal });
-const deleteRecord = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+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 getRecord = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+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 getDatabaseList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/dbs",
   method: "get",
   ...variables,
   signal
 });
-const bulkInsertTableRecords = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables, signal });
-const queryTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/query",
-  method: "post",
-  ...variables,
-  signal
-});
-const searchTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/search",
-  method: "post",
-  ...variables,
-  signal
-});
-const searchBranch = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/search",
-  method: "post",
-  ...variables,
-  signal
-});
-const summarizeTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/summarize",
-  method: "post",
+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 aggregateTable = (variables, signal) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/aggregate",
-  method: "post",
+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 listRegions = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/regions",
+  method: "get",
   ...variables,
   signal
 });
-const operationsByTag = {
-  users: { getUser, updateUser, deleteUser, getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
+const operationsByTag$1 = {
+  users: { getUser, updateUser, deleteUser },
+  authentication: { getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
   workspaces: {
-    createWorkspace,
     getWorkspacesList,
+    createWorkspace,
     getWorkspace,
     updateWorkspace,
     deleteWorkspace,
     getWorkspaceMembersList,
     updateWorkspaceMemberRole,
-    removeWorkspaceMember,
+    removeWorkspaceMember
+  },
+  invites: {
     inviteWorkspaceMember,
     updateWorkspaceMemberInvite,
     cancelWorkspaceMemberInvite,
-    resendWorkspaceMemberInvite,
-    acceptWorkspaceMemberInvite
+    acceptWorkspaceMemberInvite,
+    resendWorkspaceMemberInvite
   },
-  database: {
+  databases: {
     getDatabaseList,
     createDatabase,
     deleteDatabase,
     getDatabaseMetadata,
     updateDatabaseMetadata,
-    getGitBranchesMapping,
-    addGitBranchesEntry,
-    removeGitBranchesEntry,
-    resolveBranch
-  },
-  branch: {
-    getBranchList,
-    getBranchDetails,
-    createBranch,
-    deleteBranch,
-    updateBranchMetadata,
-    getBranchMetadata,
-    getBranchStats
-  },
-  migrationRequests: {
-    queryMigrationRequests,
-    createMigrationRequest,
-    getMigrationRequest,
-    updateMigrationRequest,
-    listMigrationRequestsCommits,
-    compareMigrationRequest,
-    getMigrationRequestIsMerged,
-    mergeMigrationRequest
-  },
-  branchSchema: {
-    getBranchMigrationHistory,
-    executeBranchMigrationPlan,
-    getBranchMigrationPlan,
-    compareBranchWithUserSchema,
-    compareBranchSchemas,
-    updateBranchSchema,
-    previewBranchSchemaEdit,
-    applyBranchSchemaEdit,
-    getBranchSchemaHistory
-  },
-  table: {
-    createTable,
-    deleteTable,
-    updateTable,
-    getTableSchema,
-    setTableSchema,
-    getTableColumns,
-    addTableColumn,
-    getColumn,
-    deleteColumn,
-    updateColumn
-  },
-  records: {
-    insertRecord,
-    insertRecordWithID,
-    updateRecordWithID,
-    upsertRecordWithID,
-    deleteRecord,
-    getRecord,
-    bulkInsertTableRecords,
-    queryTable,
-    searchTable,
-    searchBranch,
-    summarizeTable,
-    aggregateTable
+    listRegions
   }
 };
 
+const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
+
 function getHostUrl(provider, type) {
   if (isHostProviderAlias(provider)) {
     return providers[provider][type];
@@ -710,11 +696,11 @@ function getHostUrl(provider, type) {
 const providers = {
   production: {
     main: "https://api.xata.io",
-    workspaces: "https://{workspaceId}.xata.sh"
+    workspaces: "https://{workspaceId}.{region}.xata.sh"
   },
   staging: {
     main: "https://staging.xatabase.co",
-    workspaces: "https://{workspaceId}.staging.xatabase.co"
+    workspaces: "https://{workspaceId}.staging.{region}.xatabase.co"
   }
 };
 function isHostProviderAlias(alias) {
@@ -732,6 +718,16 @@ function parseProviderString(provider = "production") {
     return null;
   return { main, workspaces };
 }
+function parseWorkspacesUrlParts(url) {
+  if (!isString(url))
+    return null;
+  const regex = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))?\.xata\.sh.*/;
+  const regexStaging = /(?:https:\/\/)?([^.]+)\.staging(?:\.([^.]+))?\.xatabase\.co.*/;
+  const match = url.match(regex) || url.match(regexStaging);
+  if (!match)
+    return null;
+  return { workspace: match[1], region: match[2] ?? "eu-west-1" };
+}
 
 var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -775,21 +771,41 @@ class XataApiClient {
       __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 databases() {
-    if (!__privateGet$7(this, _namespaces).databases)
-      __privateGet$7(this, _namespaces).databases = new DatabaseApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).databases;
+  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));
@@ -800,15 +816,10 @@ class XataApiClient {
       __privateGet$7(this, _namespaces).records = new RecordsApi(__privateGet$7(this, _extraProps));
     return __privateGet$7(this, _namespaces).records;
   }
-  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 branchSchema() {
-    if (!__privateGet$7(this, _namespaces).branchSchema)
-      __privateGet$7(this, _namespaces).branchSchema = new BranchSchemaApi(__privateGet$7(this, _extraProps));
-    return __privateGet$7(this, _namespaces).branchSchema;
+  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();
@@ -820,24 +831,29 @@ class UserApi {
   getUser() {
     return operationsByTag.users.getUser({ ...this.extraProps });
   }
-  updateUser(user) {
+  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.users.getUserAPIKeys({ ...this.extraProps });
+    return operationsByTag.authentication.getUserAPIKeys({ ...this.extraProps });
   }
-  createUserAPIKey(keyName) {
-    return operationsByTag.users.createUserAPIKey({
-      pathParams: { keyName },
+  createUserAPIKey({ name }) {
+    return operationsByTag.authentication.createUserAPIKey({
+      pathParams: { keyName: name },
       ...this.extraProps
     });
   }
-  deleteUserAPIKey(keyName) {
-    return operationsByTag.users.deleteUserAPIKey({
-      pathParams: { keyName },
+  deleteUserAPIKey({ name }) {
+    return operationsByTag.authentication.deleteUserAPIKey({
+      pathParams: { keyName: name },
       ...this.extraProps
     });
   }
@@ -846,196 +862,248 @@ class WorkspaceApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  createWorkspace(workspaceMeta) {
+  getWorkspacesList() {
+    return operationsByTag.workspaces.getWorkspacesList({ ...this.extraProps });
+  }
+  createWorkspace({ data }) {
     return operationsByTag.workspaces.createWorkspace({
-      body: workspaceMeta,
+      body: data,
       ...this.extraProps
     });
   }
-  getWorkspacesList() {
-    return operationsByTag.workspaces.getWorkspacesList({ ...this.extraProps });
-  }
-  getWorkspace(workspaceId) {
+  getWorkspace({ workspace }) {
     return operationsByTag.workspaces.getWorkspace({
-      pathParams: { workspaceId },
+      pathParams: { workspaceId: workspace },
       ...this.extraProps
     });
   }
-  updateWorkspace(workspaceId, workspaceMeta) {
+  updateWorkspace({
+    workspace,
+    update
+  }) {
     return operationsByTag.workspaces.updateWorkspace({
-      pathParams: { workspaceId },
-      body: workspaceMeta,
+      pathParams: { workspaceId: workspace },
+      body: update,
       ...this.extraProps
     });
   }
-  deleteWorkspace(workspaceId) {
+  deleteWorkspace({ workspace }) {
     return operationsByTag.workspaces.deleteWorkspace({
-      pathParams: { workspaceId },
+      pathParams: { workspaceId: workspace },
       ...this.extraProps
     });
   }
-  getWorkspaceMembersList(workspaceId) {
+  getWorkspaceMembersList({ workspace }) {
     return operationsByTag.workspaces.getWorkspaceMembersList({
-      pathParams: { workspaceId },
+      pathParams: { workspaceId: workspace },
       ...this.extraProps
     });
   }
-  updateWorkspaceMemberRole(workspaceId, userId, role) {
+  updateWorkspaceMemberRole({
+    workspace,
+    user,
+    role
+  }) {
     return operationsByTag.workspaces.updateWorkspaceMemberRole({
-      pathParams: { workspaceId, userId },
+      pathParams: { workspaceId: workspace, userId: user },
       body: { role },
       ...this.extraProps
     });
   }
-  removeWorkspaceMember(workspaceId, userId) {
+  removeWorkspaceMember({
+    workspace,
+    user
+  }) {
     return operationsByTag.workspaces.removeWorkspaceMember({
-      pathParams: { workspaceId, userId },
+      pathParams: { workspaceId: workspace, userId: user },
       ...this.extraProps
     });
   }
-  inviteWorkspaceMember(workspaceId, email, role) {
-    return operationsByTag.workspaces.inviteWorkspaceMember({
-      pathParams: { workspaceId },
+}
+class InvitesApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
+  inviteWorkspaceMember({
+    workspace,
+    email,
+    role
+  }) {
+    return operationsByTag.invites.inviteWorkspaceMember({
+      pathParams: { workspaceId: workspace },
       body: { email, role },
       ...this.extraProps
     });
   }
-  updateWorkspaceMemberInvite(workspaceId, inviteId, role) {
-    return operationsByTag.workspaces.updateWorkspaceMemberInvite({
-      pathParams: { workspaceId, inviteId },
+  updateWorkspaceMemberInvite({
+    workspace,
+    invite,
+    role
+  }) {
+    return operationsByTag.invites.updateWorkspaceMemberInvite({
+      pathParams: { workspaceId: workspace, inviteId: invite },
       body: { role },
       ...this.extraProps
     });
   }
-  cancelWorkspaceMemberInvite(workspaceId, inviteId) {
-    return operationsByTag.workspaces.cancelWorkspaceMemberInvite({
-      pathParams: { workspaceId, inviteId },
+  cancelWorkspaceMemberInvite({
+    workspace,
+    invite
+  }) {
+    return operationsByTag.invites.cancelWorkspaceMemberInvite({
+      pathParams: { workspaceId: workspace, inviteId: invite },
       ...this.extraProps
     });
   }
-  resendWorkspaceMemberInvite(workspaceId, inviteId) {
-    return operationsByTag.workspaces.resendWorkspaceMemberInvite({
-      pathParams: { workspaceId, inviteId },
+  acceptWorkspaceMemberInvite({
+    workspace,
+    key
+  }) {
+    return operationsByTag.invites.acceptWorkspaceMemberInvite({
+      pathParams: { workspaceId: workspace, inviteKey: key },
       ...this.extraProps
     });
   }
-  acceptWorkspaceMemberInvite(workspaceId, inviteKey) {
-    return operationsByTag.workspaces.acceptWorkspaceMemberInvite({
-      pathParams: { workspaceId, inviteKey },
+  resendWorkspaceMemberInvite({
+    workspace,
+    invite
+  }) {
+    return operationsByTag.invites.resendWorkspaceMemberInvite({
+      pathParams: { workspaceId: workspace, inviteId: invite },
       ...this.extraProps
     });
   }
 }
-class DatabaseApi {
+class BranchApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  getDatabaseList(workspace) {
-    return operationsByTag.database.getDatabaseList({
-      pathParams: { workspace },
-      ...this.extraProps
-    });
-  }
-  createDatabase(workspace, dbName, options = {}) {
-    return operationsByTag.database.createDatabase({
-      pathParams: { workspace, dbName },
-      body: options,
-      ...this.extraProps
-    });
-  }
-  deleteDatabase(workspace, dbName) {
-    return operationsByTag.database.deleteDatabase({
-      pathParams: { workspace, dbName },
-      ...this.extraProps
-    });
-  }
-  getDatabaseMetadata(workspace, dbName) {
-    return operationsByTag.database.getDatabaseMetadata({
-      pathParams: { workspace, dbName },
-      ...this.extraProps
-    });
-  }
-  updateDatabaseMetadata(workspace, dbName, options = {}) {
-    return operationsByTag.database.updateDatabaseMetadata({
-      pathParams: { workspace, dbName },
-      body: options,
-      ...this.extraProps
-    });
-  }
-  getGitBranchesMapping(workspace, dbName) {
-    return operationsByTag.database.getGitBranchesMapping({
-      pathParams: { workspace, dbName },
+  getBranchList({
+    workspace,
+    region,
+    database
+  }) {
+    return operationsByTag.branch.getBranchList({
+      pathParams: { workspace, region, dbName: database },
       ...this.extraProps
     });
   }
-  addGitBranchesEntry(workspace, dbName, body) {
-    return operationsByTag.database.addGitBranchesEntry({
-      pathParams: { workspace, dbName },
-      body,
+  getBranchDetails({
+    workspace,
+    region,
+    database,
+    branch
+  }) {
+    return operationsByTag.branch.getBranchDetails({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       ...this.extraProps
     });
   }
-  removeGitBranchesEntry(workspace, dbName, gitBranch) {
-    return operationsByTag.database.removeGitBranchesEntry({
-      pathParams: { workspace, dbName },
-      queryParams: { gitBranch },
+  createBranch({
+    workspace,
+    region,
+    database,
+    branch,
+    from,
+    metadata
+  }) {
+    return operationsByTag.branch.createBranch({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { from, metadata },
       ...this.extraProps
     });
   }
-  resolveBranch(workspace, dbName, gitBranch, fallbackBranch) {
-    return operationsByTag.database.resolveBranch({
-      pathParams: { workspace, dbName },
-      queryParams: { gitBranch, fallbackBranch },
+  deleteBranch({
+    workspace,
+    region,
+    database,
+    branch
+  }) {
+    return operationsByTag.branch.deleteBranch({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       ...this.extraProps
     });
   }
-}
-class BranchApi {
-  constructor(extraProps) {
-    this.extraProps = extraProps;
-  }
-  getBranchList(workspace, dbName) {
-    return operationsByTag.branch.getBranchList({
-      pathParams: { workspace, dbName },
+  updateBranchMetadata({
+    workspace,
+    region,
+    database,
+    branch,
+    metadata
+  }) {
+    return operationsByTag.branch.updateBranchMetadata({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: metadata,
       ...this.extraProps
     });
   }
-  getBranchDetails(workspace, database, branch) {
-    return operationsByTag.branch.getBranchDetails({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  getBranchMetadata({
+    workspace,
+    region,
+    database,
+    branch
+  }) {
+    return operationsByTag.branch.getBranchMetadata({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       ...this.extraProps
     });
   }
-  createBranch(workspace, database, branch, from, options = {}) {
-    return operationsByTag.branch.createBranch({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      queryParams: isString(from) ? { from } : void 0,
-      body: options,
+  getBranchStats({
+    workspace,
+    region,
+    database,
+    branch
+  }) {
+    return operationsByTag.branch.getBranchStats({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       ...this.extraProps
     });
   }
-  deleteBranch(workspace, database, branch) {
-    return operationsByTag.branch.deleteBranch({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  getGitBranchesMapping({
+    workspace,
+    region,
+    database
+  }) {
+    return operationsByTag.branch.getGitBranchesMapping({
+      pathParams: { workspace, region, dbName: database },
       ...this.extraProps
     });
   }
-  updateBranchMetadata(workspace, database, branch, metadata = {}) {
-    return operationsByTag.branch.updateBranchMetadata({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: metadata,
+  addGitBranchesEntry({
+    workspace,
+    region,
+    database,
+    gitBranch,
+    xataBranch
+  }) {
+    return operationsByTag.branch.addGitBranchesEntry({
+      pathParams: { workspace, region, dbName: database },
+      body: { gitBranch, xataBranch },
       ...this.extraProps
     });
   }
-  getBranchMetadata(workspace, database, branch) {
-    return operationsByTag.branch.getBranchMetadata({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  removeGitBranchesEntry({
+    workspace,
+    region,
+    database,
+    gitBranch
+  }) {
+    return operationsByTag.branch.removeGitBranchesEntry({
+      pathParams: { workspace, region, dbName: database },
+      queryParams: { gitBranch },
       ...this.extraProps
     });
   }
-  getBranchStats(workspace, database, branch) {
-    return operationsByTag.branch.getBranchStats({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  resolveBranch({
+    workspace,
+    region,
+    database,
+    gitBranch,
+    fallbackBranch
+  }) {
+    return operationsByTag.branch.resolveBranch({
+      pathParams: { workspace, region, dbName: database },
+      queryParams: { gitBranch, fallbackBranch },
       ...this.extraProps
     });
   }
@@ -1044,67 +1112,134 @@ class TableApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  createTable(workspace, database, branch, tableName) {
+  createTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
     return operationsByTag.table.createTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  deleteTable(workspace, database, branch, tableName) {
+  deleteTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
     return operationsByTag.table.deleteTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  updateTable(workspace, database, branch, tableName, options) {
+  updateTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    update
+  }) {
     return operationsByTag.table.updateTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: update,
       ...this.extraProps
     });
   }
-  getTableSchema(workspace, database, branch, tableName) {
+  getTableSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
     return operationsByTag.table.getTableSchema({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  setTableSchema(workspace, database, branch, tableName, options) {
+  setTableSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    schema
+  }) {
     return operationsByTag.table.setTableSchema({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: schema,
       ...this.extraProps
     });
   }
-  getTableColumns(workspace, database, branch, tableName) {
+  getTableColumns({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
     return operationsByTag.table.getTableColumns({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  addTableColumn(workspace, database, branch, tableName, column) {
+  addTableColumn({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    column
+  }) {
     return operationsByTag.table.addTableColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       body: column,
       ...this.extraProps
     });
   }
-  getColumn(workspace, database, branch, tableName, columnName) {
+  getColumn({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    column
+  }) {
     return operationsByTag.table.getColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
       ...this.extraProps
     });
   }
-  deleteColumn(workspace, database, branch, tableName, columnName) {
-    return operationsByTag.table.deleteColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
+  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
     });
   }
-  updateColumn(workspace, database, branch, tableName, columnName, options) {
-    return operationsByTag.table.updateColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
-      body: options,
+  deleteColumn({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    column
+  }) {
+    return operationsByTag.table.deleteColumn({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
       ...this.extraProps
     });
   }
@@ -1113,92 +1248,213 @@ class RecordsApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  insertRecord(workspace, database, branch, tableName, record, options = {}) {
+  insertRecord({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    columns
+  }) {
     return operationsByTag.records.insertRecord({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      queryParams: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      queryParams: { columns },
       body: record,
       ...this.extraProps
     });
   }
-  insertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+  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, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
+      queryParams: { columns, createOnly, ifVersion },
       body: record,
       ...this.extraProps
     });
   }
-  updateRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+  updateRecordWithID({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    id,
+    record,
+    columns,
+    ifVersion
+  }) {
     return operationsByTag.records.updateRecordWithID({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
+      queryParams: { columns, ifVersion },
       body: record,
       ...this.extraProps
     });
   }
-  upsertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+  upsertRecordWithID({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    id,
+    record,
+    columns,
+    ifVersion
+  }) {
     return operationsByTag.records.upsertRecordWithID({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
+      queryParams: { columns, ifVersion },
       body: record,
       ...this.extraProps
     });
   }
-  deleteRecord(workspace, database, branch, tableName, recordId, options = {}) {
+  deleteRecord({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    id,
+    columns
+  }) {
     return operationsByTag.records.deleteRecord({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
-      ...this.extraProps
-    });
-  }
-  getRecord(workspace, database, branch, tableName, recordId, options = {}) {
-    return operationsByTag.records.getRecord({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, recordId: id },
+      queryParams: { columns },
       ...this.extraProps
     });
   }
-  bulkInsertTableRecords(workspace, database, branch, tableName, records, options = {}) {
+  bulkInsertTableRecords({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    records,
+    columns
+  }) {
     return operationsByTag.records.bulkInsertTableRecords({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      queryParams: options,
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      queryParams: { columns },
       body: { records },
       ...this.extraProps
     });
   }
-  queryTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.queryTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: query,
-      ...this.extraProps
-    });
-  }
-  searchTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.searchTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: query,
-      ...this.extraProps
-    });
-  }
-  searchBranch(workspace, database, branch, query) {
-    return operationsByTag.records.searchBranch({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: query,
-      ...this.extraProps
-    });
-  }
-  summarizeTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.summarizeTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: query,
-      ...this.extraProps
-    });
+}
+class SearchAndFilterApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
   }
-  aggregateTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.aggregateTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: query,
+  queryTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    filter,
+    sort,
+    page,
+    columns
+  }) {
+    return operationsByTag.searchAndFilter.queryTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: { filter, sort, page, columns },
+      ...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
+    });
+  }
+  summarizeTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    filter,
+    columns,
+    summaries,
+    sort,
+    summariesFilter,
+    page
+  }) {
+    return operationsByTag.searchAndFilter.summarizeTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: { filter, columns, summaries, sort, summariesFilter, page },
+      ...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
     });
   }
@@ -1207,123 +1463,281 @@ class MigrationRequestsApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  queryMigrationRequests(workspace, database, options = {}) {
+  queryMigrationRequests({
+    workspace,
+    region,
+    database,
+    filter,
+    sort,
+    page,
+    columns
+  }) {
     return operationsByTag.migrationRequests.queryMigrationRequests({
-      pathParams: { workspace, dbName: database },
-      body: options,
+      pathParams: { workspace, region, dbName: database },
+      body: { filter, sort, page, columns },
       ...this.extraProps
     });
   }
-  createMigrationRequest(workspace, database, options) {
+  createMigrationRequest({
+    workspace,
+    region,
+    database,
+    migration
+  }) {
     return operationsByTag.migrationRequests.createMigrationRequest({
-      pathParams: { workspace, dbName: database },
-      body: options,
+      pathParams: { workspace, region, dbName: database },
+      body: migration,
       ...this.extraProps
     });
   }
-  getMigrationRequest(workspace, database, migrationRequest) {
+  getMigrationRequest({
+    workspace,
+    region,
+    database,
+    migrationRequest
+  }) {
     return operationsByTag.migrationRequests.getMigrationRequest({
-      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
       ...this.extraProps
     });
   }
-  updateMigrationRequest(workspace, database, migrationRequest, options) {
+  updateMigrationRequest({
+    workspace,
+    region,
+    database,
+    migrationRequest,
+    update
+  }) {
     return operationsByTag.migrationRequests.updateMigrationRequest({
-      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
-      body: options,
+      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
+      body: update,
       ...this.extraProps
     });
   }
-  listMigrationRequestsCommits(workspace, database, migrationRequest, options = {}) {
+  listMigrationRequestsCommits({
+    workspace,
+    region,
+    database,
+    migrationRequest,
+    page
+  }) {
     return operationsByTag.migrationRequests.listMigrationRequestsCommits({
-      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
-      body: options,
+      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
+      body: { page },
       ...this.extraProps
     });
   }
-  compareMigrationRequest(workspace, database, migrationRequest) {
+  compareMigrationRequest({
+    workspace,
+    region,
+    database,
+    migrationRequest
+  }) {
     return operationsByTag.migrationRequests.compareMigrationRequest({
-      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
       ...this.extraProps
     });
   }
-  getMigrationRequestIsMerged(workspace, database, migrationRequest) {
+  getMigrationRequestIsMerged({
+    workspace,
+    region,
+    database,
+    migrationRequest
+  }) {
     return operationsByTag.migrationRequests.getMigrationRequestIsMerged({
-      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
       ...this.extraProps
     });
   }
-  mergeMigrationRequest(workspace, database, migrationRequest) {
+  mergeMigrationRequest({
+    workspace,
+    region,
+    database,
+    migrationRequest
+  }) {
     return operationsByTag.migrationRequests.mergeMigrationRequest({
-      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      pathParams: { workspace, region, dbName: database, mrNumber: migrationRequest },
       ...this.extraProps
     });
   }
 }
-class BranchSchemaApi {
+class MigrationsApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  getBranchMigrationHistory(workspace, database, branch, options = {}) {
-    return operationsByTag.branchSchema.getBranchMigrationHistory({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: options,
+  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, database, branch, migrationPlan) {
-    return operationsByTag.branchSchema.executeBranchMigrationPlan({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: migrationPlan,
+  executeBranchMigrationPlan({
+    workspace,
+    region,
+    database,
+    branch,
+    plan
+  }) {
+    return operationsByTag.migrations.executeBranchMigrationPlan({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: plan,
       ...this.extraProps
     });
   }
-  getBranchMigrationPlan(workspace, database, branch, schema) {
-    return operationsByTag.branchSchema.getBranchMigrationPlan({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: schema,
+  getBranchSchemaHistory({
+    workspace,
+    region,
+    database,
+    branch,
+    page
+  }) {
+    return operationsByTag.migrations.getBranchSchemaHistory({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { page },
       ...this.extraProps
     });
   }
-  compareBranchWithUserSchema(workspace, database, branch, schema) {
-    return operationsByTag.branchSchema.compareBranchWithUserSchema({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  compareBranchWithUserSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    schema
+  }) {
+    return operationsByTag.migrations.compareBranchWithUserSchema({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       body: { schema },
       ...this.extraProps
     });
   }
-  compareBranchSchemas(workspace, database, branch, branchName, schema) {
-    return operationsByTag.branchSchema.compareBranchSchemas({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, branchName },
+  compareBranchSchemas({
+    workspace,
+    region,
+    database,
+    branch,
+    compare,
+    schema
+  }) {
+    return operationsByTag.migrations.compareBranchSchemas({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, branchName: compare },
       body: { schema },
       ...this.extraProps
     });
   }
-  updateBranchSchema(workspace, database, branch, migration) {
-    return operationsByTag.branchSchema.updateBranchSchema({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  updateBranchSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    migration
+  }) {
+    return operationsByTag.migrations.updateBranchSchema({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       body: migration,
       ...this.extraProps
     });
   }
-  previewBranchSchemaEdit(workspace, database, branch, migration) {
-    return operationsByTag.branchSchema.previewBranchSchemaEdit({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: migration,
+  previewBranchSchemaEdit({
+    workspace,
+    region,
+    database,
+    branch,
+    data
+  }) {
+    return operationsByTag.migrations.previewBranchSchemaEdit({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: data,
       ...this.extraProps
     });
   }
-  applyBranchSchemaEdit(workspace, database, branch, edits) {
-    return operationsByTag.branchSchema.applyBranchSchemaEdit({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  applyBranchSchemaEdit({
+    workspace,
+    region,
+    database,
+    branch,
+    edits
+  }) {
+    return operationsByTag.migrations.applyBranchSchemaEdit({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       body: { edits },
       ...this.extraProps
     });
   }
-  getBranchSchemaHistory(workspace, database, branch, options = {}) {
-    return operationsByTag.branchSchema.getBranchSchemaHistory({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: options,
+}
+class DatabaseApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
+  getDatabaseList({ workspace }) {
+    return operationsByTag.databases.getDatabaseList({
+      pathParams: { workspaceId: workspace },
+      ...this.extraProps
+    });
+  }
+  createDatabase({
+    workspace,
+    database,
+    data
+  }) {
+    return operationsByTag.databases.createDatabase({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: data,
+      ...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
+    });
+  }
+  listRegions({ workspace }) {
+    return operationsByTag.databases.listRegions({
+      pathParams: { workspaceId: workspace },
       ...this.extraProps
     });
   }
@@ -1339,6 +1753,13 @@ class XataApiPlugin {
 class XataPlugin {
 }
 
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
 function cleanFilter(filter) {
   if (!filter)
     return void 0;
@@ -1647,7 +2068,7 @@ cleanFilterConstraint_fn = function(column, value) {
 };
 function cleanParent(data, parent) {
   if (isCursorPaginationOptions(data.pagination)) {
-    return { ...parent, sorting: void 0, filter: void 0 };
+    return { ...parent, sort: void 0, filter: void 0 };
   }
   return parent;
 }
@@ -1732,10 +2153,13 @@ class RestRepository extends Query {
     __privateAdd$4(this, _schemaTables$2, void 0);
     __privateAdd$4(this, _trace, void 0);
     __privateSet$4(this, _table, options.table);
-    __privateSet$4(this, _getFetchProps, options.pluginOptions.getFetchProps);
     __privateSet$4(this, _db, options.db);
     __privateSet$4(this, _cache, options.pluginOptions.cache);
     __privateSet$4(this, _schemaTables$2, options.schemaTables);
+    __privateSet$4(this, _getFetchProps, async () => {
+      const props = await options.pluginOptions.getFetchProps();
+      return { ...props, sessionID: generateUUID() };
+    });
     const trace = options.pluginOptions.trace ?? defaultTrace;
     __privateSet$4(this, _trace, async (name, fn, options2 = {}) => {
       return trace(name, fn, {
@@ -1746,8 +2170,9 @@ class RestRepository extends Query {
       });
     });
   }
-  async create(a, b, c) {
+  async create(a, b, c, d) {
     return __privateGet$4(this, _trace).call(this, "create", async () => {
+      const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
@@ -1758,13 +2183,13 @@ class RestRepository extends Query {
         if (a === "")
           throw new Error("The id can't be empty");
         const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns);
+        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns, { createOnly: true, ifVersion });
       }
       if (isObject(a) && isString(a.id)) {
         if (a.id === "")
           throw new Error("The id can't be empty");
         const columns = isStringArray(b) ? b : void 0;
-        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns);
+        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns, { createOnly: true, ifVersion });
       }
       if (isObject(a)) {
         const columns = isStringArray(b) ? b : void 0;
@@ -1795,6 +2220,7 @@ class RestRepository extends Query {
             pathParams: {
               workspace: "{workspaceId}",
               dbBranchName: "{dbBranch}",
+              region: "{region}",
               tableName: __privateGet$4(this, _table),
               recordId: id
             },
@@ -1832,8 +2258,9 @@ class RestRepository extends Query {
       return result;
     });
   }
-  async update(a, b, c) {
+  async update(a, b, c, d) {
     return __privateGet$4(this, _trace).call(this, "update", async () => {
+      const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
@@ -1845,18 +2272,18 @@ class RestRepository extends Query {
       }
       if (isString(a) && isObject(b)) {
         const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b, columns);
+        return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b, columns, { ifVersion });
       }
       if (isObject(a) && isString(a.id)) {
         const columns = isStringArray(b) ? b : void 0;
-        return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns);
+        return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns, { ifVersion });
       }
       throw new Error("Invalid arguments for update method");
     });
   }
-  async updateOrThrow(a, b, c) {
+  async updateOrThrow(a, b, c, d) {
     return __privateGet$4(this, _trace).call(this, "updateOrThrow", async () => {
-      const result = await this.update(a, b, c);
+      const result = await this.update(a, b, c, d);
       if (Array.isArray(result)) {
         const missingIds = compact(
           a.filter((_item, index) => result[index] === null).map((item) => extractId(item))
@@ -1873,8 +2300,9 @@ class RestRepository extends Query {
       return result;
     });
   }
-  async createOrUpdate(a, b, c) {
+  async createOrUpdate(a, b, c, d) {
     return __privateGet$4(this, _trace).call(this, "createOrUpdate", async () => {
+      const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
@@ -1886,15 +2314,35 @@ class RestRepository extends Query {
       }
       if (isString(a) && isObject(b)) {
         const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b, columns);
+        return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b, columns, { ifVersion });
       }
       if (isObject(a) && isString(a.id)) {
         const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns);
+        return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns, { ifVersion });
       }
       throw new Error("Invalid arguments for createOrUpdate method");
     });
   }
+  async createOrReplace(a, b, c, d) {
+    return __privateGet$4(this, _trace).call(this, "createOrReplace", async () => {
+      const ifVersion = parseIfVersion(b, c, d);
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        const columns = isStringArray(b) ? b : ["*"];
+        return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a, columns);
+      }
+      if (isString(a) && isObject(b)) {
+        const columns = isStringArray(c) ? c : void 0;
+        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns, { createOnly: false, ifVersion });
+      }
+      if (isObject(a) && isString(a.id)) {
+        const columns = isStringArray(c) ? c : void 0;
+        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns, { createOnly: false, ifVersion });
+      }
+      throw new Error("Invalid arguments for createOrReplace method");
+    });
+  }
   async delete(a, b) {
     return __privateGet$4(this, _trace).call(this, "delete", async () => {
       if (Array.isArray(a)) {
@@ -1936,7 +2384,12 @@ class RestRepository extends Query {
     return __privateGet$4(this, _trace).call(this, "search", async () => {
       const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const { records } = await searchTable({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
         body: {
           query,
           fuzziness: options.fuzziness,
@@ -1955,7 +2408,12 @@ class RestRepository extends Query {
     return __privateGet$4(this, _trace).call(this, "aggregate", async () => {
       const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const result = await aggregateTable({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
         body: { aggs, filter },
         ...fetchProps
       });
@@ -1970,7 +2428,12 @@ class RestRepository extends Query {
       const data = query.getQueryOptions();
       const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const { meta, records: objects } = await queryTable({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
         body: {
           filter: cleanFilter(data.filter),
           sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
@@ -1992,11 +2455,17 @@ class RestRepository extends Query {
       const data = query.getQueryOptions();
       const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const result = await summarizeTable({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
         body: {
           filter: cleanFilter(data.filter),
           sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
           columns: data.columns,
+          page: data.pagination?.size !== void 0 ? { size: data.pagination?.size } : void 0,
           summaries,
           summariesFilter
         },
@@ -2020,6 +2489,7 @@ insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
+      region: "{region}",
       tableName: __privateGet$4(this, _table)
     },
     queryParams: { columns },
@@ -2030,18 +2500,19 @@ insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
   return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
 };
 _insertRecordWithId = new WeakSet();
-insertRecordWithId_fn = async function(recordId, object, columns = ["*"]) {
+insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { createOnly, ifVersion }) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
+      region: "{region}",
       tableName: __privateGet$4(this, _table),
       recordId
     },
     body: record,
-    queryParams: { createOnly: true, columns },
+    queryParams: { createOnly, columns, ifVersion },
     ...fetchProps
   });
   const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
@@ -2052,7 +2523,12 @@ bulkInsertTableRecords_fn = async function(objects, columns = ["*"]) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const records = objects.map((object) => transformObjectLinks(object));
   const response = await bulkInsertTableRecords({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+    pathParams: {
+      workspace: "{workspaceId}",
+      dbBranchName: "{dbBranch}",
+      region: "{region}",
+      tableName: __privateGet$4(this, _table)
+    },
     queryParams: { columns },
     body: { records },
     ...fetchProps
@@ -2064,13 +2540,19 @@ bulkInsertTableRecords_fn = async function(objects, columns = ["*"]) {
   return response.records?.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, columns));
 };
 _updateRecordWithID = new WeakSet();
-updateRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
+updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   try {
     const response = await updateRecordWithID({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
-      queryParams: { columns },
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}",
+        tableName: __privateGet$4(this, _table),
+        recordId
+      },
+      queryParams: { columns, ifVersion },
       body: record,
       ...fetchProps
     });
@@ -2084,11 +2566,17 @@ updateRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
   }
 };
 _upsertRecordWithID = new WeakSet();
-upsertRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
+upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const response = await upsertRecordWithID({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
-    queryParams: { columns },
+    pathParams: {
+      workspace: "{workspaceId}",
+      dbBranchName: "{dbBranch}",
+      region: "{region}",
+      tableName: __privateGet$4(this, _table),
+      recordId
+    },
+    queryParams: { columns, ifVersion },
     body: object,
     ...fetchProps
   });
@@ -2100,7 +2588,13 @@ deleteRecord_fn = async function(recordId, columns = ["*"]) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   try {
     const response = await deleteRecord({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}",
+        tableName: __privateGet$4(this, _table),
+        recordId
+      },
       queryParams: { columns },
       ...fetchProps
     });
@@ -2135,7 +2629,7 @@ getSchemaTables_fn$1 = async function() {
     return __privateGet$4(this, _schemaTables$2);
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const { schema } = await getBranchDetails({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
     ...fetchProps
   });
   __privateSet$4(this, _schemaTables$2, schema.tables);
@@ -2201,8 +2695,15 @@ const initObject = (db, schemaTables, table, object, selectedColumns) => {
   result.read = function(columns2) {
     return db[table].read(result["id"], columns2);
   };
-  result.update = function(data, columns2) {
-    return db[table].update(result["id"], data, columns2);
+  result.update = function(data, b, c) {
+    const columns2 = isStringArray(b) ? b : ["*"];
+    const ifVersion = parseIfVersion(b, c);
+    return db[table].update(result["id"], data, columns2, { ifVersion });
+  };
+  result.replace = function(data, b, c) {
+    const columns2 = isStringArray(b) ? b : ["*"];
+    const ifVersion = parseIfVersion(b, c);
+    return db[table].createOrReplace(result["id"], data, columns2, { ifVersion });
   };
   result.delete = function() {
     return db[table].delete(result["id"]);
@@ -2235,6 +2736,14 @@ function isValidColumn(columns, column) {
   }
   return columns.includes(column.name);
 }
+function parseIfVersion(...args) {
+  for (const arg of args) {
+    if (isObject(arg) && isNumber(arg.ifVersion)) {
+      return arg.ifVersion;
+    }
+  }
+  return void 0;
+}
 
 var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -2422,7 +2931,7 @@ search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
   const { tables, fuzziness, highlight, prefix } = options ?? {};
   const { records } = await searchBranch({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
     body: { tables, query, fuzziness, prefix, highlight },
     ...fetchProps
   });
@@ -2434,7 +2943,7 @@ getSchemaTables_fn = async function(getFetchProps) {
     return __privateGet$1(this, _schemaTables);
   const fetchProps = await getFetchProps();
   const { schema } = await getBranchDetails({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
     ...fetchProps
   });
   __privateSet$1(this, _schemaTables, schema.tables);
@@ -2472,14 +2981,17 @@ async function resolveXataBranch(gitBranch, options) {
       "An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely"
     );
   const [protocol, , host, , dbName] = databaseURL.split("/");
-  const [workspace] = host.split(".");
+  const urlParts = parseWorkspacesUrlParts(host);
+  if (!urlParts)
+    throw new Error(`Unable to parse workspace and region: ${databaseURL}`);
+  const { workspace, region } = urlParts;
   const { fallbackBranch } = getEnvironment();
   const { branch } = await resolveBranch({
     apiKey,
     apiUrl: databaseURL,
     fetchImpl: getFetchImplementation(options?.fetchImpl),
     workspacesApiUrl: `${protocol}//${host}`,
-    pathParams: { dbName, workspace },
+    pathParams: { dbName, workspace, region },
     queryParams: { gitBranch, fallbackBranch },
     trace: defaultTrace
   });
@@ -2497,15 +3009,17 @@ async function getDatabaseBranch(branch, options) {
       "An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely"
     );
   const [protocol, , host, , database] = databaseURL.split("/");
-  const [workspace] = host.split(".");
-  const dbBranchName = `${database}:${branch}`;
+  const urlParts = parseWorkspacesUrlParts(host);
+  if (!urlParts)
+    throw new Error(`Unable to parse workspace and region: ${databaseURL}`);
+  const { workspace, region } = urlParts;
   try {
     return await getBranchDetails({
       apiKey,
       apiUrl: databaseURL,
       fetchImpl: getFetchImplementation(options?.fetchImpl),
       workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: { dbBranchName, workspace },
+      pathParams: { dbBranchName: `${database}:${branch}`, workspace, region },
       trace: defaultTrace
     });
   } catch (err) {
@@ -2596,8 +3110,8 @@ const buildClient = (plugins) => {
     if (!databaseURL) {
       throw new Error("Option databaseURL is required");
     }
-    return { fetch, databaseURL, apiKey, branch, cache, trace };
-  }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({ fetch, apiKey, databaseURL, branch, trace }) {
+    return { fetch, databaseURL, apiKey, branch, cache, trace, clientID: generateUUID() };
+  }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({ fetch, apiKey, databaseURL, branch, trace, clientID }) {
     const branchValue = await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, branch);
     if (!branchValue)
       throw new Error("Unable to resolve branch value");
@@ -2610,7 +3124,8 @@ const buildClient = (plugins) => {
         const newPath = path.replace(/^\/db\/[^/]+/, hasBranch !== void 0 ? `:${branchValue}` : "");
         return databaseURL + newPath;
       },
-      trace
+      trace,
+      clientID
     };
   }, _evaluateBranch = new WeakSet(), evaluateBranch_fn = async function(param) {
     if (__privateGet(this, _branch))
@@ -2760,6 +3275,11 @@ exports.createMigrationRequest = createMigrationRequest;
 exports.createTable = createTable;
 exports.createUserAPIKey = createUserAPIKey;
 exports.createWorkspace = createWorkspace;
+exports.dEPRECATEDcreateDatabase = dEPRECATEDcreateDatabase;
+exports.dEPRECATEDdeleteDatabase = dEPRECATEDdeleteDatabase;
+exports.dEPRECATEDgetDatabaseList = dEPRECATEDgetDatabaseList;
+exports.dEPRECATEDgetDatabaseMetadata = dEPRECATEDgetDatabaseMetadata;
+exports.dEPRECATEDupdateDatabaseMetadata = dEPRECATEDupdateDatabaseMetadata;
 exports.deleteBranch = deleteBranch;
 exports.deleteColumn = deleteColumn;
 exports.deleteDatabase = deleteDatabase;
@@ -2824,12 +3344,14 @@ exports.lessEquals = lessEquals;
 exports.lessThan = lessThan;
 exports.lessThanEquals = lessThanEquals;
 exports.listMigrationRequestsCommits = listMigrationRequestsCommits;
+exports.listRegions = listRegions;
 exports.lt = lt;
 exports.lte = lte;
 exports.mergeMigrationRequest = mergeMigrationRequest;
 exports.notExists = notExists;
 exports.operationsByTag = operationsByTag;
 exports.parseProviderString = parseProviderString;
+exports.parseWorkspacesUrlParts = parseWorkspacesUrlParts;
 exports.pattern = pattern;
 exports.previewBranchSchemaEdit = previewBranchSchemaEdit;
 exports.queryMigrationRequests = queryMigrationRequests;