@xata.io/client 0.0.0-alpha.vfef462e → 0.0.0-alpha.vff43566

package/dist/index.cjs

@@ -1,24 +1,27 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
+const defaultTrace = async (name, fn, _options) => {
+  return await fn({
+    name,
+    setAttributes: () => {
+      return;
+    }
+  });
+};
+const TraceAttributes = {
+  KIND: "xata.trace.kind",
+  VERSION: "xata.sdk.version",
+  TABLE: "xata.table",
+  HTTP_REQUEST_ID: "http.request_id",
+  HTTP_STATUS_CODE: "http.status_code",
+  HTTP_HOST: "http.host",
+  HTTP_SCHEME: "http.scheme",
+  HTTP_USER_AGENT: "http.user_agent",
+  HTTP_METHOD: "http.method",
+  HTTP_URL: "http.url",
+  HTTP_ROUTE: "http.route",
+  HTTP_TARGET: "http.target"
+};
 
 function notEmpty(value) {
   return value !== null && value !== void 0;
@@ -38,6 +41,21 @@ 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 parseNumber(value) {
+  if (isNumber(value)) {
+    return value;
+  }
+  if (isString(value)) {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
 function toBase64(value) {
   try {
     return btoa(value);
@@ -46,10 +64,31 @@ 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 chunk(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
+async function timeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 function getEnvironment() {
   try {
-    if (isObject(process) && isObject(process.env)) {
+    if (isDefined(process) && isDefined(process.env)) {
       return {
         apiKey: process.env.XATA_API_KEY ?? getGlobalApiKey(),
         databaseURL: process.env.XATA_DATABASE_URL ?? getGlobalDatabaseURL(),
@@ -80,6 +119,25 @@ function getEnvironment() {
     fallbackBranch: getGlobalFallbackBranch()
   };
 }
+function getEnableBrowserVariable() {
+  try {
+    if (isObject(process) && isObject(process.env) && process.env.XATA_ENABLE_BROWSER !== void 0) {
+      return process.env.XATA_ENABLE_BROWSER === "true";
+    }
+  } catch (err) {
+  }
+  try {
+    if (isObject(Deno) && isObject(Deno.env) && Deno.env.get("XATA_ENABLE_BROWSER") !== void 0) {
+      return Deno.env.get("XATA_ENABLE_BROWSER") === "true";
+    }
+  } catch (err) {
+  }
+  try {
+    return XATA_ENABLE_BROWSER === true || XATA_ENABLE_BROWSER === "true";
+  } catch (err) {
+    return void 0;
+  }
+}
 function getGlobalApiKey() {
   try {
     return XATA_API_KEY;
@@ -108,25 +166,20 @@ function getGlobalFallbackBranch() {
     return void 0;
   }
 }
-async function getGitBranch() {
-  const cmd = ["git", "branch", "--show-current"];
-  const fullCmd = cmd.join(" ");
-  const nodeModule = ["child", "process"].join("_");
-  const execOptions = { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] };
+function getDatabaseURL() {
   try {
-    if (typeof require === "function") {
-      return require(nodeModule).execSync(fullCmd, execOptions).trim();
-    }
-    const { execSync } = await (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(nodeModule);
-    return execSync(fullCmd, execOptions).toString().trim();
+    const { databaseURL } = getEnvironment();
+    return databaseURL;
   } catch (err) {
+    return void 0;
   }
+}
+function getBranch() {
   try {
-    if (isObject(Deno)) {
-      const process2 = Deno.run({ cmd, stdout: "piped", stderr: "null" });
-      return new TextDecoder().decode(await process2.output()).trim();
-    }
+    const { branch, envBranch } = getEnvironment();
+    return branch ?? envBranch;
   } catch (err) {
+    return void 0;
   }
 }
 
@@ -139,18 +192,287 @@ function getAPIKey() {
   }
 }
 
+var __accessCheck$8 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$8 = (obj, member, getter) => {
+  __accessCheck$8(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$8 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$8 = (obj, member, value, setter) => {
+  __accessCheck$8(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$4 = (obj, member, method) => {
+  __accessCheck$8(obj, member, "access private method");
+  return method;
+};
+var _fetch, _queue, _concurrency, _enqueue, enqueue_fn;
 function getFetchImplementation(userFetch) {
   const globalFetch = typeof fetch !== "undefined" ? fetch : void 0;
   const fetchImpl = userFetch ?? globalFetch;
   if (!fetchImpl) {
     throw new Error(
-      `The \`fetch\` option passed to the Xata client is resolving to a falsy value and may not be correctly imported.`
+      `Couldn't find \`fetch\`. Install a fetch implementation such as \`node-fetch\` and pass it explicitly.`
     );
   }
   return fetchImpl;
 }
+class ApiRequestPool {
+  constructor(concurrency = 10) {
+    __privateAdd$8(this, _enqueue);
+    __privateAdd$8(this, _fetch, void 0);
+    __privateAdd$8(this, _queue, void 0);
+    __privateAdd$8(this, _concurrency, void 0);
+    __privateSet$8(this, _queue, []);
+    __privateSet$8(this, _concurrency, concurrency);
+    this.running = 0;
+    this.started = 0;
+  }
+  setFetch(fetch2) {
+    __privateSet$8(this, _fetch, fetch2);
+  }
+  getFetch() {
+    if (!__privateGet$8(this, _fetch)) {
+      throw new Error("Fetch not set");
+    }
+    return __privateGet$8(this, _fetch);
+  }
+  request(url, options) {
+    const start = new Date();
+    const fetch2 = this.getFetch();
+    const runRequest = async (stalled = false) => {
+      const response = await fetch2(url, options);
+      if (response.status === 429) {
+        const rateLimitReset = parseNumber(response.headers?.get("x-ratelimit-reset")) ?? 1;
+        await timeout(rateLimitReset * 1e3);
+        return await runRequest(true);
+      }
+      if (stalled) {
+        const stalledTime = new Date().getTime() - start.getTime();
+        console.warn(`A request to Xata hit your workspace limits, was retried and stalled for ${stalledTime}ms`);
+      }
+      return response;
+    };
+    return __privateMethod$4(this, _enqueue, enqueue_fn).call(this, async () => {
+      return await runRequest();
+    });
+  }
+}
+_fetch = new WeakMap();
+_queue = new WeakMap();
+_concurrency = new WeakMap();
+_enqueue = new WeakSet();
+enqueue_fn = function(task) {
+  const promise = new Promise((resolve) => __privateGet$8(this, _queue).push(resolve)).finally(() => {
+    this.started--;
+    this.running++;
+  }).then(() => task()).finally(() => {
+    this.running--;
+    const next = __privateGet$8(this, _queue).shift();
+    if (next !== void 0) {
+      this.started++;
+      next();
+    }
+  });
+  if (this.running + this.started < __privateGet$8(this, _concurrency)) {
+    const next = __privateGet$8(this, _queue).shift();
+    if (next !== void 0) {
+      this.started++;
+      next();
+    }
+  }
+  return promise;
+};
+
+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);
+  });
+}
+
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10 /* NewLine */) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58 /* Colon */:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13 /* CarriageReturn */:
+            discardTrailingNewline = true;
+          case 10 /* NewLine */:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage?.(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* Space */ ? 2 : 1);
+      const value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+const EventStreamContentType = "text/event-stream";
+const LastEventId = "last-event-id";
+function fetchEventSource(input, {
+  signal: inputSignal,
+  headers: inputHeaders,
+  onopen: inputOnOpen,
+  onmessage,
+  onclose,
+  onerror,
+  fetch: inputFetch,
+  ...rest
+}) {
+  return new Promise((resolve, reject) => {
+    const headers = { ...inputHeaders };
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function dispose() {
+      curRequestController.abort();
+    }
+    inputSignal?.addEventListener("abort", () => {
+      dispose();
+      resolve();
+    });
+    const fetchImpl = inputFetch ?? fetch;
+    const onopen = inputOnOpen ?? defaultOnOpen;
+    async function create() {
+      curRequestController = new AbortController();
+      try {
+        const response = await fetchImpl(input, {
+          ...rest,
+          headers,
+          signal: curRequestController.signal
+        });
+        await onopen(response);
+        await getBytes(
+          response.body,
+          getLines(
+            getMessages(
+              (id) => {
+                if (id) {
+                  headers[LastEventId] = id;
+                } else {
+                  delete headers[LastEventId];
+                }
+              },
+              (_retry) => {
+              },
+              onmessage
+            )
+          )
+        );
+        onclose?.();
+        dispose();
+        resolve();
+      } catch (err) {
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers?.get("content-type");
+  if (!contentType?.startsWith(EventStreamContentType)) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
 
-const VERSION = "0.0.0-alpha.vfef462e";
+const VERSION = "0.22.4";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -161,7 +483,7 @@ class FetcherError extends ErrorWithCause {
   constructor(status, data, requestId) {
     super(getMessage(data));
     this.status = status;
-    this.errors = isBulkError(data) ? data.errors : void 0;
+    this.errors = isBulkError(data) ? data.errors : [{ message: getMessage(data), status }];
     this.requestId = requestId;
     if (data instanceof Error) {
       this.stack = data.stack;
@@ -193,6 +515,7 @@ function getMessage(data) {
   }
 }
 
+const pool = new ApiRequestPool();
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   const cleanQueryParams = Object.entries(queryParams).reduce((acc, [key, value]) => {
     if (value === void 0 || value === null)
@@ -201,310 +524,368 @@ const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   }, {});
   const query = new URLSearchParams(cleanQueryParams).toString();
   const queryString = query.length > 0 ? `?${query}` : "";
-  return url.replace(/\{\w*\}/g, (key) => pathParams[key.slice(1, -1)]) + queryString;
+  const cleanPathParams = Object.entries(pathParams).reduce((acc, [key, value]) => {
+    return { ...acc, [key]: encodeURIComponent(String(value ?? "")).replace("%3A", ":") };
+  }, {});
+  return url.replace(/\{\w*\}/g, (key) => cleanPathParams[key.slice(1, -1)]) + queryString;
 };
 function buildBaseUrl({
+  endpoint,
   path,
   workspacesApiUrl,
   apiUrl,
-  pathParams
+  pathParams = {}
 }) {
-  if (!pathParams?.workspace)
-    return `${apiUrl}${path}`;
-  const url = typeof workspacesApiUrl === "string" ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
-  return url.replace("{workspaceId}", 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>[^/]+).*/;
   const { groups } = pattern.exec(url) ?? {};
   return groups?.host ? { Host: groups.host } : {};
 }
+const defaultClientID = generateUUID();
 async function fetch$1({
   url: path,
   method,
   body,
-  headers,
+  headers: customHeaders,
+  pathParams,
+  queryParams,
+  fetch: fetch2,
+  apiKey,
+  endpoint,
+  apiUrl,
+  workspacesApiUrl,
+  trace,
+  signal,
+  clientID,
+  sessionID,
+  clientName,
+  xataAgentExtra,
+  fetchOptions = {}
+}) {
+  pool.setFetch(fetch2);
+  return await trace(
+    `${method.toUpperCase()} ${path}`,
+    async ({ setAttributes }) => {
+      const baseUrl = buildBaseUrl({ endpoint, path, workspacesApiUrl, pathParams, apiUrl });
+      const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
+      const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
+      setAttributes({
+        [TraceAttributes.HTTP_URL]: url,
+        [TraceAttributes.HTTP_TARGET]: resolveUrl(path, queryParams, pathParams)
+      });
+      const xataAgent = compact([
+        ["client", "TS_SDK"],
+        ["version", VERSION],
+        isDefined(clientName) ? ["service", clientName] : void 0,
+        ...Object.entries(xataAgentExtra ?? {})
+      ]).map(([key, value]) => `${key}=${value}`).join("; ");
+      const headers = {
+        "Accept-Encoding": "identity",
+        "Content-Type": "application/json",
+        "X-Xata-Client-ID": clientID ?? defaultClientID,
+        "X-Xata-Session-ID": sessionID ?? generateUUID(),
+        "X-Xata-Agent": xataAgent,
+        ...customHeaders,
+        ...hostHeader(fullUrl),
+        Authorization: `Bearer ${apiKey}`
+      };
+      const response = await pool.request(url, {
+        ...fetchOptions,
+        method: method.toUpperCase(),
+        body: body ? JSON.stringify(body) : void 0,
+        headers,
+        signal
+      });
+      const { host, protocol } = parseUrl(response.url);
+      const requestId = response.headers?.get("x-request-id") ?? void 0;
+      setAttributes({
+        [TraceAttributes.KIND]: "http",
+        [TraceAttributes.HTTP_REQUEST_ID]: requestId,
+        [TraceAttributes.HTTP_STATUS_CODE]: response.status,
+        [TraceAttributes.HTTP_HOST]: host,
+        [TraceAttributes.HTTP_SCHEME]: protocol?.replace(":", "")
+      });
+      if (response.status === 204) {
+        return {};
+      }
+      if (response.status === 429) {
+        throw new FetcherError(response.status, "Rate limit exceeded", requestId);
+      }
+      try {
+        const jsonResponse = await response.json();
+        if (response.ok) {
+          return jsonResponse;
+        }
+        throw new FetcherError(response.status, jsonResponse, requestId);
+      } catch (error) {
+        throw new FetcherError(response.status, error, requestId);
+      }
+    },
+    { [TraceAttributes.HTTP_METHOD]: method.toUpperCase(), [TraceAttributes.HTTP_ROUTE]: path }
+  );
+}
+function fetchSSERequest({
+  url: path,
+  method,
+  body,
+  headers: customHeaders,
   pathParams,
   queryParams,
-  fetchImpl,
+  fetch: fetch2,
   apiKey,
+  endpoint,
   apiUrl,
-  workspacesApiUrl
+  workspacesApiUrl,
+  onMessage,
+  onError,
+  onClose,
+  signal,
+  clientID,
+  sessionID,
+  clientName,
+  xataAgentExtra
 }) {
-  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;
-  const response = await fetchImpl(url, {
-    method: method.toUpperCase(),
-    body: body ? JSON.stringify(body) : void 0,
+  void fetchEventSource(url, {
+    method,
+    body: JSON.stringify(body),
+    fetch: fetch2,
+    signal,
     headers: {
-      "Content-Type": "application/json",
-      "User-Agent": `Xata client-ts/${VERSION}`,
-      ...headers,
-      ...hostHeader(fullUrl),
-      Authorization: `Bearer ${apiKey}`
+      "X-Xata-Client-ID": clientID ?? defaultClientID,
+      "X-Xata-Session-ID": sessionID ?? generateUUID(),
+      "X-Xata-Agent": compact([
+        ["client", "TS_SDK"],
+        ["version", VERSION],
+        isDefined(clientName) ? ["service", clientName] : void 0,
+        ...Object.entries(xataAgentExtra ?? {})
+      ]).map(([key, value]) => `${key}=${value}`).join("; "),
+      ...customHeaders,
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    onmessage(ev) {
+      onMessage?.(JSON.parse(ev.data));
+    },
+    onerror(ev) {
+      onError?.(JSON.parse(ev.data));
+    },
+    onclose() {
+      onClose?.();
     }
   });
-  if (response.status === 204) {
-    return {};
-  }
-  const requestId = response.headers?.get("x-request-id") ?? void 0;
+}
+function parseUrl(url) {
   try {
-    const jsonResponse = await response.json();
-    if (response.ok) {
-      return jsonResponse;
-    }
-    throw new FetcherError(response.status, jsonResponse, requestId);
+    const { host, protocol } = new URL(url);
+    return { host, protocol };
   } catch (error) {
-    throw new FetcherError(response.status, error, requestId);
+    return {};
   }
 }
 
-const getUser = (variables) => fetch$1({ url: "/user", method: "get", ...variables });
-const updateUser = (variables) => fetch$1({ url: "/user", method: "put", ...variables });
-const deleteUser = (variables) => fetch$1({ url: "/user", method: "delete", ...variables });
-const getUserAPIKeys = (variables) => fetch$1({
-  url: "/user/keys",
-  method: "get",
-  ...variables
-});
-const createUserAPIKey = (variables) => fetch$1({
-  url: "/user/keys/{keyName}",
-  method: "post",
-  ...variables
-});
-const deleteUserAPIKey = (variables) => fetch$1({
-  url: "/user/keys/{keyName}",
-  method: "delete",
-  ...variables
-});
-const createWorkspace = (variables) => fetch$1({
-  url: "/workspaces",
-  method: "post",
-  ...variables
-});
-const getWorkspacesList = (variables) => fetch$1({
-  url: "/workspaces",
-  method: "get",
-  ...variables
-});
-const getWorkspace = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}",
-  method: "get",
-  ...variables
-});
-const updateWorkspace = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}",
-  method: "put",
-  ...variables
-});
-const deleteWorkspace = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}",
-  method: "delete",
-  ...variables
-});
-const getWorkspaceMembersList = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/members",
-  method: "get",
-  ...variables
-});
-const updateWorkspaceMemberRole = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables });
-const removeWorkspaceMember = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/members/{userId}",
-  method: "delete",
-  ...variables
-});
-const inviteWorkspaceMember = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables });
-const updateWorkspaceMemberInvite = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables });
-const cancelWorkspaceMemberInvite = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteId}",
-  method: "delete",
-  ...variables
-});
-const resendWorkspaceMemberInvite = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteId}/resend",
-  method: "post",
-  ...variables
-});
-const acceptWorkspaceMemberInvite = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept",
-  method: "post",
-  ...variables
-});
-const getDatabaseList = (variables) => fetch$1({
-  url: "/dbs",
-  method: "get",
-  ...variables
-});
-const getBranchList = (variables) => fetch$1({
+const dataPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "dataPlane" });
+
+const getBranchList = (variables, signal) => dataPlaneFetch({
   url: "/dbs/{dbName}",
   method: "get",
-  ...variables
-});
-const createDatabase = (variables) => fetch$1({
-  url: "/dbs/{dbName}",
-  method: "put",
-  ...variables
-});
-const deleteDatabase = (variables) => fetch$1({
-  url: "/dbs/{dbName}",
-  method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const getGitBranchesMapping = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables });
-const addGitBranchesEntry = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables });
-const removeGitBranchesEntry = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables });
-const resolveBranch = (variables) => fetch$1({
-  url: "/dbs/{dbName}/resolveBranch",
-  method: "get",
-  ...variables
-});
-const getBranchDetails = (variables) => fetch$1({
+const getBranchDetails = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const createBranch = (variables) => fetch$1({ url: "/db/{dbBranchName}", method: "put", ...variables });
-const deleteBranch = (variables) => fetch$1({
+const createBranch = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}", method: "put", ...variables, signal });
+const deleteBranch = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
+});
+const copyBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/copy",
+  method: "post",
+  ...variables,
+  signal
 });
-const updateBranchMetadata = (variables) => fetch$1({
+const updateBranchMetadata = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/metadata",
   method: "put",
-  ...variables
+  ...variables,
+  signal
 });
-const getBranchMetadata = (variables) => fetch$1({
+const getBranchMetadata = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/metadata",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const getBranchMigrationHistory = (variables) => fetch$1({ url: "/db/{dbBranchName}/migrations", method: "get", ...variables });
-const executeBranchMigrationPlan = (variables) => fetch$1({ url: "/db/{dbBranchName}/migrations/execute", method: "post", ...variables });
-const getBranchMigrationPlan = (variables) => fetch$1({ url: "/db/{dbBranchName}/migrations/plan", method: "post", ...variables });
-const getBranchStats = (variables) => fetch$1({
+const getBranchStats = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/stats",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const createTable = (variables) => fetch$1({
+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 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 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
+  ...variables,
+  signal
 });
-const deleteTable = (variables) => fetch$1({
+const deleteTable = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}",
   method: "delete",
-  ...variables
-});
-const updateTable = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}",
-  method: "patch",
-  ...variables
+  ...variables,
+  signal
 });
-const getTableSchema = (variables) => fetch$1({
+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
+  ...variables,
+  signal
 });
-const setTableSchema = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/schema",
-  method: "put",
-  ...variables
-});
-const getTableColumns = (variables) => fetch$1({
+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
-});
-const addTableColumn = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns",
-  method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const getColumn = (variables) => fetch$1({
+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
+  ...variables,
+  signal
 });
-const deleteColumn = (variables) => fetch$1({
+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
-});
-const updateColumn = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
-  method: "patch",
-  ...variables
-});
-const insertRecord = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data", method: "post", ...variables });
-const insertRecordWithID = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "put", ...variables });
-const updateRecordWithID = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "patch", ...variables });
-const upsertRecordWithID = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "post", ...variables });
-const deleteRecord = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
-  method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const getRecord = (variables) => fetch$1({
+const branchTransaction = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/transaction", method: "post", ...variables, signal });
+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
+  ...variables,
+  signal
 });
-const bulkInsertTableRecords = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables });
-const queryTable = (variables) => fetch$1({
+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
+  ...variables,
+  signal
 });
-const searchTable = (variables) => fetch$1({
+const searchBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/search",
+  method: "post",
+  ...variables,
+  signal
+});
+const searchTable = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/search",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const searchBranch = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/search",
+const vectorSearchTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/vectorSearch", method: "post", ...variables, signal });
+const askTable = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/ask",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const operationsByTag = {
-  users: { getUser, updateUser, deleteUser, getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
-  workspaces: {
-    createWorkspace,
-    getWorkspacesList,
-    getWorkspace,
-    updateWorkspace,
-    deleteWorkspace,
-    getWorkspaceMembersList,
-    updateWorkspaceMemberRole,
-    removeWorkspaceMember,
-    inviteWorkspaceMember,
-    updateWorkspaceMemberInvite,
-    cancelWorkspaceMemberInvite,
-    resendWorkspaceMemberInvite,
-    acceptWorkspaceMemberInvite
-  },
-  database: {
-    getDatabaseList,
-    createDatabase,
-    deleteDatabase,
-    getGitBranchesMapping,
-    addGitBranchesEntry,
-    removeGitBranchesEntry,
-    resolveBranch
-  },
+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 = {
   branch: {
     getBranchList,
     getBranchDetails,
     createBranch,
     deleteBranch,
+    copyBranch,
     updateBranchMetadata,
     getBranchMetadata,
+    getBranchStats,
+    getGitBranchesMapping,
+    addGitBranchesEntry,
+    removeGitBranchesEntry,
+    resolveBranch
+  },
+  migrations: {
     getBranchMigrationHistory,
-    executeBranchMigrationPlan,
     getBranchMigrationPlan,
-    getBranchStats
+    executeBranchMigrationPlan,
+    getBranchSchemaHistory,
+    compareBranchWithUserSchema,
+    compareBranchSchemas,
+    updateBranchSchema,
+    previewBranchSchemaEdit,
+    applyBranchSchemaEdit
+  },
+  migrationRequests: {
+    queryMigrationRequests,
+    createMigrationRequest,
+    getMigrationRequest,
+    updateMigrationRequest,
+    listMigrationRequestsCommits,
+    compareMigrationRequest,
+    getMigrationRequestIsMerged,
+    mergeMigrationRequest
   },
   table: {
     createTable,
@@ -515,27 +896,174 @@ const operationsByTag = {
     getTableColumns,
     addTableColumn,
     getColumn,
-    deleteColumn,
-    updateColumn
+    updateColumn,
+    deleteColumn
   },
   records: {
+    branchTransaction,
     insertRecord,
+    getRecord,
     insertRecordWithID,
     updateRecordWithID,
     upsertRecordWithID,
     deleteRecord,
-    getRecord,
-    bulkInsertTableRecords,
+    bulkInsertTableRecords
+  },
+  searchAndFilter: {
     queryTable,
+    searchBranch,
     searchTable,
-    searchBranch
+    vectorSearchTable,
+    askTable,
+    summarizeTable,
+    aggregateTable
+  }
+};
+
+const controlPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "controlPlane" });
+
+const getUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteUser = (variables, signal) => controlPlaneFetch({
+  url: "/user",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getUserAPIKeys = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys",
+  method: "get",
+  ...variables,
+  signal
+});
+const createUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "post",
+  ...variables,
+  signal
+});
+const deleteUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getWorkspacesList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces",
+  method: "get",
+  ...variables,
+  signal
+});
+const createWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces",
+  method: "post",
+  ...variables,
+  signal
+});
+const getWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteWorkspace = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getWorkspaceMembersList = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members", method: "get", ...variables, signal });
+const updateWorkspaceMemberRole = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables, signal });
+const removeWorkspaceMember = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/members/{userId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const inviteWorkspaceMember = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables, signal });
+const updateWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables, signal });
+const cancelWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "delete", ...variables, signal });
+const acceptWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept", method: "post", ...variables, signal });
+const resendWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}/resend", method: "post", ...variables, signal });
+const getDatabaseList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/dbs",
+  method: "get",
+  ...variables,
+  signal
+});
+const createDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "put", ...variables, signal });
+const deleteDatabase = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/dbs/{dbName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "get", ...variables, signal });
+const updateDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "patch", ...variables, signal });
+const getDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "get", ...variables, signal });
+const updateDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "put", ...variables, signal });
+const deleteDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "delete", ...variables, signal });
+const listRegions = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/regions",
+  method: "get",
+  ...variables,
+  signal
+});
+const operationsByTag$1 = {
+  users: { getUser, updateUser, deleteUser },
+  authentication: { getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
+  workspaces: {
+    getWorkspacesList,
+    createWorkspace,
+    getWorkspace,
+    updateWorkspace,
+    deleteWorkspace,
+    getWorkspaceMembersList,
+    updateWorkspaceMemberRole,
+    removeWorkspaceMember
+  },
+  invites: {
+    inviteWorkspaceMember,
+    updateWorkspaceMemberInvite,
+    cancelWorkspaceMemberInvite,
+    acceptWorkspaceMemberInvite,
+    resendWorkspaceMemberInvite
+  },
+  databases: {
+    getDatabaseList,
+    createDatabase,
+    deleteDatabase,
+    getDatabaseMetadata,
+    updateDatabaseMetadata,
+    getDatabaseGithubSettings,
+    updateDatabaseGithubSettings,
+    deleteDatabaseGithubSettings,
+    listRegions
   }
 };
 
+const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
+
 function getHostUrl(provider, type) {
-  if (isValidAlias(provider)) {
+  if (isHostProviderAlias(provider)) {
     return providers[provider][type];
-  } else if (isValidBuilder(provider)) {
+  } else if (isHostProviderBuilder(provider)) {
     return provider[type];
   }
   throw new Error("Invalid API provider");
@@ -543,19 +1071,40 @@ 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"
+    main: "https://api.staging-xata.dev",
+    workspaces: "https://{workspaceId}.{region}.staging-xata.dev"
   }
 };
-function isValidAlias(alias) {
+function isHostProviderAlias(alias) {
   return isString(alias) && Object.keys(providers).includes(alias);
 }
-function isValidBuilder(builder) {
+function isHostProviderBuilder(builder) {
   return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
 }
+function parseProviderString(provider = "production") {
+  if (isHostProviderAlias(provider)) {
+    return provider;
+  }
+  const [main, workspaces] = provider.split(",");
+  if (!main || !workspaces)
+    return null;
+  return { main, workspaces };
+}
+function parseWorkspacesUrlParts(url) {
+  if (!isString(url))
+    return null;
+  const regex = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.sh.*/;
+  const regexDev = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.dev-xata\.dev.*/;
+  const regexStaging = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.staging-xata\.dev.*/;
+  const regexProdTesting = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.tech.*/;
+  const match = url.match(regex) || url.match(regexDev) || url.match(regexStaging) || url.match(regexProdTesting);
+  if (!match)
+    return null;
+  return { workspace: match[1], region: match[2] };
+}
 
 var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -581,15 +1130,21 @@ class XataApiClient {
     __privateAdd$7(this, _extraProps, void 0);
     __privateAdd$7(this, _namespaces, {});
     const provider = options.host ?? "production";
-    const apiKey = options?.apiKey ?? getAPIKey();
+    const apiKey = options.apiKey ?? getAPIKey();
+    const trace = options.trace ?? defaultTrace;
+    const clientID = generateUUID();
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
     __privateSet$7(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
-      fetchImpl: getFetchImplementation(options.fetch),
-      apiKey
+      fetch: getFetchImplementation(options.fetch),
+      apiKey,
+      trace,
+      clientName: options.clientName,
+      xataAgentExtra: options.xataAgentExtra,
+      clientID
     });
   }
   get user() {
@@ -597,21 +1152,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));
@@ -622,6 +1197,11 @@ class XataApiClient {
       __privateGet$7(this, _namespaces).records = new RecordsApi(__privateGet$7(this, _extraProps));
     return __privateGet$7(this, _namespaces).records;
   }
+  get searchAndFilter() {
+    if (!__privateGet$7(this, _namespaces).searchAndFilter)
+      __privateGet$7(this, _namespaces).searchAndFilter = new SearchAndFilterApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).searchAndFilter;
+  }
 }
 _extraProps = new WeakMap();
 _namespaces = new WeakMap();
@@ -632,24 +1212,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
     });
   }
@@ -658,368 +1243,996 @@ 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 },
+  getBranchList({
+    workspace,
+    region,
+    database
+  }) {
+    return operationsByTag.branch.getBranchList({
+      pathParams: { workspace, region, dbName: database },
       ...this.extraProps
     });
   }
-  createDatabase(workspace, dbName, options = {}) {
-    return operationsByTag.database.createDatabase({
-      pathParams: { workspace, dbName },
-      body: options,
+  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
     });
   }
-  deleteDatabase(workspace, dbName) {
-    return operationsByTag.database.deleteDatabase({
-      pathParams: { workspace, dbName },
+  getBranchStats({
+    workspace,
+    region,
+    database,
+    branch
+  }) {
+    return operationsByTag.branch.getBranchStats({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
       ...this.extraProps
     });
   }
-  getGitBranchesMapping(workspace, dbName) {
-    return operationsByTag.database.getGitBranchesMapping({
-      pathParams: { workspace, dbName },
+  getGitBranchesMapping({
+    workspace,
+    region,
+    database
+  }) {
+    return operationsByTag.branch.getGitBranchesMapping({
+      pathParams: { workspace, region, dbName: database },
       ...this.extraProps
     });
   }
-  addGitBranchesEntry(workspace, dbName, body) {
-    return operationsByTag.database.addGitBranchesEntry({
-      pathParams: { workspace, dbName },
-      body,
+  addGitBranchesEntry({
+    workspace,
+    region,
+    database,
+    gitBranch,
+    xataBranch
+  }) {
+    return operationsByTag.branch.addGitBranchesEntry({
+      pathParams: { workspace, region, dbName: database },
+      body: { gitBranch, xataBranch },
       ...this.extraProps
     });
   }
-  removeGitBranchesEntry(workspace, dbName, gitBranch) {
-    return operationsByTag.database.removeGitBranchesEntry({
-      pathParams: { workspace, dbName },
+  removeGitBranchesEntry({
+    workspace,
+    region,
+    database,
+    gitBranch
+  }) {
+    return operationsByTag.branch.removeGitBranchesEntry({
+      pathParams: { workspace, region, dbName: database },
       queryParams: { gitBranch },
       ...this.extraProps
     });
   }
-  resolveBranch(workspace, dbName, gitBranch, fallbackBranch) {
-    return operationsByTag.database.resolveBranch({
-      pathParams: { workspace, dbName },
+  resolveBranch({
+    workspace,
+    region,
+    database,
+    gitBranch,
+    fallbackBranch
+  }) {
+    return operationsByTag.branch.resolveBranch({
+      pathParams: { workspace, region, dbName: database },
       queryParams: { gitBranch, fallbackBranch },
       ...this.extraProps
     });
   }
 }
-class BranchApi {
+class TableApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  getBranchList(workspace, dbName) {
-    return operationsByTag.branch.getBranchList({
-      pathParams: { workspace, dbName },
+  createTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
+    return operationsByTag.table.createTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  getBranchDetails(workspace, database, branch) {
-    return operationsByTag.branch.getBranchDetails({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  deleteTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
+    return operationsByTag.table.deleteTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...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,
+  updateTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    update
+  }) {
+    return operationsByTag.table.updateTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: update,
       ...this.extraProps
     });
   }
-  deleteBranch(workspace, database, branch) {
-    return operationsByTag.branch.deleteBranch({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  getTableSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
+    return operationsByTag.table.getTableSchema({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  updateBranchMetadata(workspace, database, branch, metadata = {}) {
-    return operationsByTag.branch.updateBranchMetadata({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: metadata,
+  setTableSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    schema
+  }) {
+    return operationsByTag.table.setTableSchema({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: schema,
       ...this.extraProps
     });
   }
-  getBranchMetadata(workspace, database, branch) {
-    return operationsByTag.branch.getBranchMetadata({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  getTableColumns({
+    workspace,
+    region,
+    database,
+    branch,
+    table
+  }) {
+    return operationsByTag.table.getTableColumns({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
       ...this.extraProps
     });
   }
-  getBranchMigrationHistory(workspace, database, branch, options = {}) {
-    return operationsByTag.branch.getBranchMigrationHistory({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: options,
+  addTableColumn({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    column
+  }) {
+    return operationsByTag.table.addTableColumn({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: column,
       ...this.extraProps
     });
   }
-  executeBranchMigrationPlan(workspace, database, branch, migrationPlan) {
-    return operationsByTag.branch.executeBranchMigrationPlan({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: migrationPlan,
+  getColumn({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    column
+  }) {
+    return operationsByTag.table.getColumn({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
       ...this.extraProps
     });
   }
-  getBranchMigrationPlan(workspace, database, branch, schema) {
-    return operationsByTag.branch.getBranchMigrationPlan({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: schema,
+  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
     });
   }
-  getBranchStats(workspace, database, branch) {
-    return operationsByTag.branch.getBranchStats({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  deleteColumn({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    column
+  }) {
+    return operationsByTag.table.deleteColumn({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, columnName: column },
       ...this.extraProps
     });
   }
 }
-class TableApi {
+class RecordsApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  createTable(workspace, database, branch, tableName) {
-    return operationsByTag.table.createTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+  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 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
+    });
+  }
+  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
     });
   }
-  deleteTable(workspace, database, branch, tableName) {
-    return operationsByTag.table.deleteTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+  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
     });
   }
-  updateTable(workspace, database, branch, tableName, options) {
-    return operationsByTag.table.updateTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: options,
+  getBranchMigrationPlan({
+    workspace,
+    region,
+    database,
+    branch,
+    schema
+  }) {
+    return operationsByTag.migrations.getBranchMigrationPlan({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: schema,
       ...this.extraProps
     });
   }
-  getTableSchema(workspace, database, branch, tableName) {
-    return operationsByTag.table.getTableSchema({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+  executeBranchMigrationPlan({
+    workspace,
+    region,
+    database,
+    branch,
+    plan
+  }) {
+    return operationsByTag.migrations.executeBranchMigrationPlan({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: plan,
       ...this.extraProps
     });
   }
-  setTableSchema(workspace, database, branch, tableName, options) {
-    return operationsByTag.table.setTableSchema({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: options,
+  getBranchSchemaHistory({
+    workspace,
+    region,
+    database,
+    branch,
+    page
+  }) {
+    return operationsByTag.migrations.getBranchSchemaHistory({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { page },
       ...this.extraProps
     });
   }
-  getTableColumns(workspace, database, branch, tableName) {
-    return operationsByTag.table.getTableColumns({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+  compareBranchWithUserSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    schema,
+    schemaOperations,
+    branchOperations
+  }) {
+    return operationsByTag.migrations.compareBranchWithUserSchema({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { schema, schemaOperations, branchOperations },
       ...this.extraProps
     });
   }
-  addTableColumn(workspace, database, branch, tableName, column) {
-    return operationsByTag.table.addTableColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: column,
+  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
     });
   }
-  getColumn(workspace, database, branch, tableName, columnName) {
-    return operationsByTag.table.getColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
+  updateBranchSchema({
+    workspace,
+    region,
+    database,
+    branch,
+    migration
+  }) {
+    return operationsByTag.migrations.updateBranchSchema({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: migration,
       ...this.extraProps
     });
   }
-  deleteColumn(workspace, database, branch, tableName, columnName) {
-    return operationsByTag.table.deleteColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
+  previewBranchSchemaEdit({
+    workspace,
+    region,
+    database,
+    branch,
+    data
+  }) {
+    return operationsByTag.migrations.previewBranchSchemaEdit({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: data,
       ...this.extraProps
     });
   }
-  updateColumn(workspace, database, branch, tableName, columnName, options) {
-    return operationsByTag.table.updateColumn({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
-      body: options,
+  applyBranchSchemaEdit({
+    workspace,
+    region,
+    database,
+    branch,
+    edits
+  }) {
+    return operationsByTag.migrations.applyBranchSchemaEdit({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { edits },
       ...this.extraProps
     });
   }
 }
-class RecordsApi {
+class DatabaseApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  insertRecord(workspace, database, branch, tableName, record, options = {}) {
-    return operationsByTag.records.insertRecord({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      queryParams: options,
-      body: record,
-      ...this.extraProps
-    });
-  }
-  insertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
-    return operationsByTag.records.insertRecordWithID({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
-      body: record,
+  getDatabaseList({ workspace }) {
+    return operationsByTag.databases.getDatabaseList({
+      pathParams: { workspaceId: workspace },
       ...this.extraProps
     });
   }
-  updateRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
-    return operationsByTag.records.updateRecordWithID({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
-      body: record,
+  createDatabase({
+    workspace,
+    database,
+    data
+  }) {
+    return operationsByTag.databases.createDatabase({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: data,
       ...this.extraProps
     });
   }
-  upsertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
-    return operationsByTag.records.upsertRecordWithID({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
-      body: record,
+  deleteDatabase({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.deleteDatabase({
+      pathParams: { workspaceId: workspace, dbName: database },
       ...this.extraProps
     });
   }
-  deleteRecord(workspace, database, branch, tableName, recordId, options = {}) {
-    return operationsByTag.records.deleteRecord({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
+  getDatabaseMetadata({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.getDatabaseMetadata({
+      pathParams: { workspaceId: workspace, dbName: database },
       ...this.extraProps
     });
   }
-  getRecord(workspace, database, branch, tableName, recordId, options = {}) {
-    return operationsByTag.records.getRecord({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
-      queryParams: options,
+  updateDatabaseMetadata({
+    workspace,
+    database,
+    metadata
+  }) {
+    return operationsByTag.databases.updateDatabaseMetadata({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: metadata,
       ...this.extraProps
     });
   }
-  bulkInsertTableRecords(workspace, database, branch, tableName, records, options = {}) {
-    return operationsByTag.records.bulkInsertTableRecords({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      queryParams: options,
-      body: { records },
+  getDatabaseGithubSettings({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.getDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
       ...this.extraProps
     });
   }
-  queryTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.queryTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: query,
+  updateDatabaseGithubSettings({
+    workspace,
+    database,
+    settings
+  }) {
+    return operationsByTag.databases.updateDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: settings,
       ...this.extraProps
     });
   }
-  searchTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.searchTable({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
-      body: query,
+  deleteDatabaseGithubSettings({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.deleteDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
       ...this.extraProps
     });
   }
-  searchBranch(workspace, database, branch, query) {
-    return operationsByTag.records.searchBranch({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: query,
+  listRegions({ workspace }) {
+    return operationsByTag.databases.listRegions({
+      pathParams: { workspaceId: workspace },
       ...this.extraProps
     });
   }
 }
 
 class XataApiPlugin {
-  async build(options) {
-    const { fetchImpl, apiKey } = await options.getFetchProps();
-    return new XataApiClient({ fetch: fetchImpl, apiKey });
+  build(options) {
+    return new XataApiClient(options);
   }
 }
 
 class XataPlugin {
 }
 
+function cleanFilter(filter) {
+  if (!filter)
+    return void 0;
+  const values = Object.values(filter).filter(Boolean).filter((value) => Array.isArray(value) ? value.length > 0 : true);
+  return values.length > 0 ? filter : void 0;
+}
+
 var __accessCheck$6 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -1052,11 +2265,11 @@ class Page {
   async previousPage(size, offset) {
     return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, before: this.meta.page.cursor } });
   }
-  async firstPage(size, offset) {
-    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, first: this.meta.page.cursor } });
+  async startPage(size, offset) {
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, start: this.meta.page.cursor } });
   }
-  async lastPage(size, offset) {
-    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, last: this.meta.page.cursor } });
+  async endPage(size, offset) {
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, end: this.meta.page.cursor } });
   }
   hasNextPage() {
     return this.meta.page.more;
@@ -1068,7 +2281,7 @@ const PAGINATION_DEFAULT_SIZE = 20;
 const PAGINATION_MAX_OFFSET = 800;
 const PAGINATION_DEFAULT_OFFSET = 0;
 function isCursorPaginationOptions(options) {
-  return isDefined(options) && (isDefined(options.first) || isDefined(options.last) || isDefined(options.after) || isDefined(options.before));
+  return isDefined(options) && (isDefined(options.start) || isDefined(options.end) || isDefined(options.after) || isDefined(options.before));
 }
 const _RecordArray = class extends Array {
   constructor(...args) {
@@ -1089,6 +2302,12 @@ const _RecordArray = class extends Array {
   toArray() {
     return new Array(...this);
   }
+  toSerializable() {
+    return JSON.parse(this.toString());
+  }
+  toString() {
+    return JSON.stringify(this.toArray());
+  }
   map(callbackfn, thisArg) {
     return this.toArray().map(callbackfn, thisArg);
   }
@@ -1100,12 +2319,12 @@ const _RecordArray = class extends Array {
     const newPage = await __privateGet$6(this, _page).previousPage(size, offset);
     return new _RecordArray(newPage);
   }
-  async firstPage(size, offset) {
-    const newPage = await __privateGet$6(this, _page).firstPage(size, offset);
+  async startPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).startPage(size, offset);
     return new _RecordArray(newPage);
   }
-  async lastPage(size, offset) {
-    const newPage = await __privateGet$6(this, _page).lastPage(size, offset);
+  async endPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).endPage(size, offset);
     return new _RecordArray(newPage);
   }
   hasNextPage() {
@@ -1133,9 +2352,14 @@ var __privateSet$5 = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _table$1, _repository, _data;
+var __privateMethod$3 = (obj, member, method) => {
+  __accessCheck$5(obj, member, "access private method");
+  return method;
+};
+var _table$1, _repository, _data, _cleanFilterConstraint, cleanFilterConstraint_fn;
 const _Query = class {
   constructor(repository, table, data, rawParent) {
+    __privateAdd$5(this, _cleanFilterConstraint);
     __privateAdd$5(this, _table$1, void 0);
     __privateAdd$5(this, _repository, void 0);
     __privateAdd$5(this, _data, { filter: {} });
@@ -1154,9 +2378,11 @@ const _Query = class {
     __privateGet$5(this, _data).filter.$not = data.filter?.$not ?? parent?.filter?.$not;
     __privateGet$5(this, _data).filter.$none = data.filter?.$none ?? parent?.filter?.$none;
     __privateGet$5(this, _data).sort = data.sort ?? parent?.sort;
-    __privateGet$5(this, _data).columns = data.columns ?? parent?.columns ?? ["*"];
+    __privateGet$5(this, _data).columns = data.columns ?? parent?.columns;
+    __privateGet$5(this, _data).consistency = data.consistency ?? parent?.consistency;
     __privateGet$5(this, _data).pagination = data.pagination ?? parent?.pagination;
     __privateGet$5(this, _data).cache = data.cache ?? parent?.cache;
+    __privateGet$5(this, _data).fetchOptions = data.fetchOptions ?? parent?.fetchOptions;
     this.any = this.any.bind(this);
     this.all = this.all.bind(this);
     this.not = this.not.bind(this);
@@ -1192,15 +2418,18 @@ const _Query = class {
   }
   filter(a, b) {
     if (arguments.length === 1) {
-      const constraints = Object.entries(a).map(([column, constraint]) => ({ [column]: constraint }));
+      const constraints = Object.entries(a ?? {}).map(([column, constraint]) => ({
+        [column]: __privateMethod$3(this, _cleanFilterConstraint, cleanFilterConstraint_fn).call(this, column, constraint)
+      }));
       const $all = compact([__privateGet$5(this, _data).filter?.$all].flat().concat(constraints));
       return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
     } else {
-      const $all = compact([__privateGet$5(this, _data).filter?.$all].flat().concat([{ [a]: b }]));
+      const constraints = isDefined(a) && isDefined(b) ? [{ [a]: __privateMethod$3(this, _cleanFilterConstraint, cleanFilterConstraint_fn).call(this, a, b) }] : void 0;
+      const $all = compact([__privateGet$5(this, _data).filter?.$all].flat().concat(constraints));
       return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
     }
   }
-  sort(column, direction) {
+  sort(column, direction = "asc") {
     const originalSort = [__privateGet$5(this, _data).sort ?? []].flat();
     const sort = [...originalSort, { column, direction }];
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { sort }, __privateGet$5(this, _data));
@@ -1234,11 +2463,20 @@ const _Query = class {
     }
   }
   async getMany(options = {}) {
-    const page = await this.getPaginated(options);
+    const { pagination = {}, ...rest } = options;
+    const { size = PAGINATION_DEFAULT_SIZE, offset } = pagination;
+    const batchSize = size <= PAGINATION_MAX_SIZE ? size : PAGINATION_MAX_SIZE;
+    let page = await this.getPaginated({ ...rest, pagination: { size: batchSize, offset } });
+    const results = [...page.records];
+    while (page.hasNextPage() && results.length < size) {
+      page = await page.nextPage();
+      results.push(...page.records);
+    }
     if (page.hasNextPage() && options.pagination?.size === void 0) {
       console.trace("Calling getMany does not return all results. Paginate to get all results or call getAll.");
     }
-    return page.records;
+    const array = new RecordArray(page, results.slice(0, size));
+    return array;
   }
   async getAll(options = {}) {
     const { batchSize = PAGINATION_MAX_SIZE, ...rest } = options;
@@ -1252,19 +2490,35 @@ const _Query = class {
     const records = await this.getMany({ ...options, pagination: { size: 1 } });
     return records[0] ?? null;
   }
+  async getFirstOrThrow(options = {}) {
+    const records = await this.getMany({ ...options, pagination: { size: 1 } });
+    if (records[0] === void 0)
+      throw new Error("No results found.");
+    return records[0];
+  }
+  async summarize(params = {}) {
+    const { summaries, summariesFilter, ...options } = params;
+    const query = new _Query(
+      __privateGet$5(this, _repository),
+      __privateGet$5(this, _table$1),
+      options,
+      __privateGet$5(this, _data)
+    );
+    return __privateGet$5(this, _repository).summarizeTable(query, summaries, summariesFilter);
+  }
   cache(ttl) {
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { cache: ttl }, __privateGet$5(this, _data));
   }
   nextPage(size, offset) {
-    return this.firstPage(size, offset);
+    return this.startPage(size, offset);
   }
   previousPage(size, offset) {
-    return this.firstPage(size, offset);
+    return this.startPage(size, offset);
   }
-  firstPage(size, offset) {
+  startPage(size, offset) {
     return this.getPaginated({ pagination: { size, offset } });
   }
-  lastPage(size, offset) {
+  endPage(size, offset) {
     return this.getPaginated({ pagination: { size, offset, before: "end" } });
   }
   hasNextPage() {
@@ -1275,9 +2529,20 @@ let Query = _Query;
 _table$1 = new WeakMap();
 _repository = new WeakMap();
 _data = new WeakMap();
+_cleanFilterConstraint = new WeakSet();
+cleanFilterConstraint_fn = function(column, value) {
+  const columnType = __privateGet$5(this, _table$1).schema?.columns.find(({ name }) => name === column)?.type;
+  if (columnType === "multiple" && (isString(value) || isStringArray(value))) {
+    return { $includes: value };
+  }
+  if (columnType === "link" && isObject(value) && isString(value.id)) {
+    return value.id;
+  }
+  return 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;
 }
@@ -1336,18 +2601,25 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _getFetchProps, _db, _cache, _schemaTables$2, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchemaTables$1, getSchemaTables_fn$1;
+var _table, _getFetchProps, _db, _cache, _schemaTables$2, _trace, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _insertRecords, insertRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _updateRecords, updateRecords_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _deleteRecords, deleteRecords_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchemaTables$1, getSchemaTables_fn$1;
+const BULK_OPERATION_MAX_SIZE = 1e3;
 class Repository extends Query {
 }
 class RestRepository extends Query {
   constructor(options) {
-    super(null, options.table, {});
+    super(
+      null,
+      { name: options.table, schema: options.schemaTables?.find((table) => table.name === options.table) },
+      {}
+    );
     __privateAdd$4(this, _insertRecordWithoutId);
     __privateAdd$4(this, _insertRecordWithId);
-    __privateAdd$4(this, _bulkInsertTableRecords);
+    __privateAdd$4(this, _insertRecords);
     __privateAdd$4(this, _updateRecordWithID);
+    __privateAdd$4(this, _updateRecords);
     __privateAdd$4(this, _upsertRecordWithID);
     __privateAdd$4(this, _deleteRecord);
+    __privateAdd$4(this, _deleteRecords);
     __privateAdd$4(this, _setCacheQuery);
     __privateAdd$4(this, _getCacheQuery);
     __privateAdd$4(this, _getSchemaTables$1);
@@ -1356,168 +2628,398 @@ class RestRepository extends Query {
     __privateAdd$4(this, _db, void 0);
     __privateAdd$4(this, _cache, void 0);
     __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, () => ({ ...options.pluginOptions, sessionID: generateUUID() }));
+    const trace = options.pluginOptions.trace ?? defaultTrace;
+    __privateSet$4(this, _trace, async (name, fn, options2 = {}) => {
+      return trace(name, fn, {
+        ...options2,
+        [TraceAttributes.TABLE]: __privateGet$4(this, _table),
+        [TraceAttributes.KIND]: "sdk-operation",
+        [TraceAttributes.VERSION]: VERSION
+      });
+    });
   }
-  async create(a, b, c) {
-    if (Array.isArray(a)) {
-      if (a.length === 0)
-        return [];
-      const columns = isStringArray(b) ? b : void 0;
-      return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a, columns);
-    }
-    if (isString(a) && isObject(b)) {
-      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);
-    }
-    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);
-    }
-    if (isObject(a)) {
-      const columns = isStringArray(b) ? b : void 0;
-      return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a, columns);
-    }
-    throw new Error("Invalid arguments for create method");
+  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 [];
+        const ids = await __privateMethod$2(this, _insertRecords, insertRecords_fn).call(this, a, { ifVersion, createOnly: true });
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(ids, columns);
+        return result;
+      }
+      if (isString(a) && isObject(b)) {
+        if (a === "")
+          throw new Error("The id can't be empty");
+        const columns = isStringArray(c) ? c : void 0;
+        return await __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 await __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;
+        return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a, columns);
+      }
+      throw new Error("Invalid arguments for create method");
+    });
   }
   async read(a, b) {
-    const columns = isStringArray(b) ? b : ["*"];
-    if (Array.isArray(a)) {
-      if (a.length === 0)
-        return [];
-      const ids = a.map((item) => isString(item) ? item : item.id).filter((id2) => isString(id2));
-      const finalObjects = await this.getAll({ filter: { id: { $any: ids } }, columns });
-      const dictionary = finalObjects.reduce((acc, object) => {
-        acc[object.id] = object;
-        return acc;
-      }, {});
-      return ids.map((id2) => dictionary[id2] ?? null);
-    }
-    const id = isString(a) ? a : a.id;
-    if (isString(id)) {
-      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-      try {
-        const response = await getRecord({
-          pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId: id },
-          queryParams: { columns },
-          ...fetchProps
+    return __privateGet$4(this, _trace).call(this, "read", async () => {
+      const columns = isStringArray(b) ? b : ["*"];
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        const ids = a.map((item) => extractId(item));
+        const finalObjects = await this.getAll({ filter: { id: { $any: compact(ids) } }, columns });
+        const dictionary = finalObjects.reduce((acc, object) => {
+          acc[object.id] = object;
+          return acc;
+        }, {});
+        return ids.map((id2) => dictionary[id2 ?? ""] ?? null);
+      }
+      const id = extractId(a);
+      if (id) {
+        try {
+          const response = await getRecord({
+            pathParams: {
+              workspace: "{workspaceId}",
+              dbBranchName: "{dbBranch}",
+              region: "{region}",
+              tableName: __privateGet$4(this, _table),
+              recordId: id
+            },
+            queryParams: { columns },
+            ...__privateGet$4(this, _getFetchProps).call(this)
+          });
+          const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+          return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+        } catch (e) {
+          if (isObject(e) && e.status === 404) {
+            return null;
+          }
+          throw e;
+        }
+      }
+      return null;
+    });
+  }
+  async readOrThrow(a, b) {
+    return __privateGet$4(this, _trace).call(this, "readOrThrow", async () => {
+      const result = await this.read(a, b);
+      if (Array.isArray(result)) {
+        const missingIds = compact(
+          a.filter((_item, index) => result[index] === null).map((item) => extractId(item))
+        );
+        if (missingIds.length > 0) {
+          throw new Error(`Could not find records with ids: ${missingIds.join(", ")}`);
+        }
+        return result;
+      }
+      if (result === null) {
+        const id = extractId(a) ?? "unknown";
+        throw new Error(`Record with id ${id} not found`);
+      }
+      return result;
+    });
+  }
+  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 [];
+        const existing = await this.read(a, ["id"]);
+        const updates = a.filter((_item, index) => existing[index] !== null);
+        await __privateMethod$2(this, _updateRecords, updateRecords_fn).call(this, updates, {
+          ifVersion,
+          upsert: false
         });
-        const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-        return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response);
-      } catch (e) {
-        if (isObject(e) && e.status === 404) {
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(a, columns);
+        return result;
+      }
+      try {
+        if (isString(a) && isObject(b)) {
+          const columns = isStringArray(c) ? c : void 0;
+          return await __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 await __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns, { ifVersion });
+        }
+      } catch (error) {
+        if (error.status === 422)
           return null;
+        throw error;
+      }
+      throw new Error("Invalid arguments for update method");
+    });
+  }
+  async updateOrThrow(a, b, c, d) {
+    return __privateGet$4(this, _trace).call(this, "updateOrThrow", async () => {
+      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))
+        );
+        if (missingIds.length > 0) {
+          throw new Error(`Could not find records with ids: ${missingIds.join(", ")}`);
         }
-        throw e;
+        return result;
       }
-    }
-    return null;
+      if (result === null) {
+        const id = extractId(a) ?? "unknown";
+        throw new Error(`Record with id ${id} not found`);
+      }
+      return result;
+    });
   }
-  async update(a, b, c) {
-    if (Array.isArray(a)) {
-      if (a.length === 0)
-        return [];
-      if (a.length > 100) {
-        console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
+  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 [];
+        await __privateMethod$2(this, _updateRecords, updateRecords_fn).call(this, a, {
+          ifVersion,
+          upsert: true
+        });
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(a, columns);
+        return result;
       }
-      const columns = isStringArray(b) ? b : ["*"];
-      return Promise.all(a.map((object) => this.update(object, columns)));
-    }
-    if (isString(a) && isObject(b)) {
-      const columns = isStringArray(c) ? c : void 0;
-      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b, columns);
-    }
-    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);
-    }
-    throw new Error("Invalid arguments for update method");
-  }
-  async createOrUpdate(a, b, c) {
-    if (Array.isArray(a)) {
-      if (a.length === 0)
-        return [];
-      if (a.length > 100) {
-        console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
+      if (isString(a) && isObject(b)) {
+        const columns = isStringArray(c) ? c : void 0;
+        return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b, columns, { ifVersion });
       }
-      const columns = isStringArray(b) ? b : ["*"];
-      return Promise.all(a.map((object) => this.createOrUpdate(object, columns)));
-    }
-    if (isString(a) && isObject(b)) {
-      const columns = isStringArray(c) ? c : void 0;
-      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b, columns);
-    }
-    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);
-    }
-    throw new Error("Invalid arguments for createOrUpdate method");
-  }
-  async delete(a) {
-    if (Array.isArray(a)) {
-      if (a.length === 0)
-        return;
-      if (a.length > 100) {
-        console.warn("Bulk delete operation is not optimized in the Xata API yet, this request might be slow");
+      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, { ifVersion });
       }
-      await Promise.all(a.map((id) => this.delete(id)));
-      return;
-    }
-    if (isString(a)) {
-      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a);
-      return;
-    }
-    if (isObject(a) && isString(a.id)) {
-      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a.id);
-      return;
-    }
-    throw new Error("Invalid arguments for delete method");
+      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 ids = await __privateMethod$2(this, _insertRecords, insertRecords_fn).call(this, a, { ifVersion, createOnly: false });
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(ids, columns);
+        return result;
+      }
+      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)) {
+        if (a.length === 0)
+          return [];
+        const ids = a.map((o) => {
+          if (isString(o))
+            return o;
+          if (isString(o.id))
+            return o.id;
+          throw new Error("Invalid arguments for delete method");
+        });
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(a, columns);
+        await __privateMethod$2(this, _deleteRecords, deleteRecords_fn).call(this, ids);
+        return result;
+      }
+      if (isString(a)) {
+        return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a, b);
+      }
+      if (isObject(a) && isString(a.id)) {
+        return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a.id, b);
+      }
+      throw new Error("Invalid arguments for delete method");
+    });
+  }
+  async deleteOrThrow(a, b) {
+    return __privateGet$4(this, _trace).call(this, "deleteOrThrow", async () => {
+      const result = await this.delete(a, b);
+      if (Array.isArray(result)) {
+        const missingIds = compact(
+          a.filter((_item, index) => result[index] === null).map((item) => extractId(item))
+        );
+        if (missingIds.length > 0) {
+          throw new Error(`Could not find records with ids: ${missingIds.join(", ")}`);
+        }
+        return result;
+      } else if (result === null) {
+        const id = extractId(a) ?? "unknown";
+        throw new Error(`Record with id ${id} not found`);
+      }
+      return result;
+    });
   }
   async search(query, options = {}) {
-    const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-    const { records } = await searchTable({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
-      body: {
-        query,
-        fuzziness: options.fuzziness,
-        prefix: options.prefix,
-        highlight: options.highlight,
-        filter: options.filter,
-        boosters: options.boosters
-      },
-      ...fetchProps
+    return __privateGet$4(this, _trace).call(this, "search", async () => {
+      const { records } = await searchTable({
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
+        body: {
+          query,
+          fuzziness: options.fuzziness,
+          prefix: options.prefix,
+          highlight: options.highlight,
+          filter: options.filter,
+          boosters: options.boosters,
+          page: options.page,
+          target: options.target
+        },
+        ...__privateGet$4(this, _getFetchProps).call(this)
+      });
+      const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+      return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"]));
+    });
+  }
+  async vectorSearch(column, query, options) {
+    return __privateGet$4(this, _trace).call(this, "vectorSearch", async () => {
+      const { records } = await vectorSearchTable({
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
+        body: {
+          column,
+          queryVector: query,
+          similarityFunction: options?.similarityFunction,
+          size: options?.size,
+          filter: options?.filter
+        },
+        ...__privateGet$4(this, _getFetchProps).call(this)
+      });
+      const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+      return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"]));
+    });
+  }
+  async aggregate(aggs, filter) {
+    return __privateGet$4(this, _trace).call(this, "aggregate", async () => {
+      const result = await aggregateTable({
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
+        body: { aggs, filter },
+        ...__privateGet$4(this, _getFetchProps).call(this)
+      });
+      return result;
     });
-    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-    return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item));
   }
   async query(query) {
-    const cacheQuery = await __privateMethod$2(this, _getCacheQuery, getCacheQuery_fn).call(this, query);
-    if (cacheQuery)
-      return new Page(query, cacheQuery.meta, cacheQuery.records);
-    const data = query.getQueryOptions();
-    const body = {
-      filter: Object.values(data.filter ?? {}).some(Boolean) ? data.filter : void 0,
-      sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
-      page: data.pagination,
-      columns: data.columns
-    };
-    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) },
-      body,
-      ...fetchProps
+    return __privateGet$4(this, _trace).call(this, "query", async () => {
+      const cacheQuery = await __privateMethod$2(this, _getCacheQuery, getCacheQuery_fn).call(this, query);
+      if (cacheQuery)
+        return new Page(query, cacheQuery.meta, cacheQuery.records);
+      const data = query.getQueryOptions();
+      const { meta, records: objects } = await queryTable({
+        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,
+          page: data.pagination,
+          columns: data.columns ?? ["*"],
+          consistency: data.consistency
+        },
+        fetchOptions: data.fetchOptions,
+        ...__privateGet$4(this, _getFetchProps).call(this)
+      });
+      const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+      const records = objects.map(
+        (record) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), record, data.columns ?? ["*"])
+      );
+      await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
+      return new Page(query, meta, records);
     });
-    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-    const records = objects.map((record) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), record));
-    await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
-    return new Page(query, meta, records);
+  }
+  async summarizeTable(query, summaries, summariesFilter) {
+    return __privateGet$4(this, _trace).call(this, "summarize", async () => {
+      const data = query.getQueryOptions();
+      const result = await summarizeTable({
+        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,
+          consistency: data.consistency,
+          page: data.pagination?.size !== void 0 ? { size: data.pagination?.size } : void 0,
+          summaries,
+          summariesFilter
+        },
+        ...__privateGet$4(this, _getFetchProps).call(this)
+      });
+      return result;
+    });
+  }
+  ask(question, options) {
+    const params = {
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}",
+        tableName: __privateGet$4(this, _table)
+      },
+      body: {
+        question,
+        ...options
+      },
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    };
+    if (options?.onMessage) {
+      fetchSSERequest({
+        endpoint: "dataPlane",
+        url: "/db/{dbBranchName}/tables/{tableName}/ask",
+        method: "POST",
+        onMessage: (message) => {
+          options.onMessage?.({ answer: message.text });
+        },
+        ...params
+      });
+    } else {
+      return askTable(params);
+    }
   }
 }
 _table = new WeakMap();
@@ -1525,89 +3027,182 @@ _getFetchProps = new WeakMap();
 _db = new WeakMap();
 _cache = new WeakMap();
 _schemaTables$2 = new WeakMap();
+_trace = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
 insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecord({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
+      region: "{region}",
       tableName: __privateGet$4(this, _table)
     },
     queryParams: { columns },
     body: record,
-    ...fetchProps
+    ...__privateGet$4(this, _getFetchProps).call(this)
   });
   const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response);
+  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
 };
 _insertRecordWithId = new WeakSet();
-insertRecordWithId_fn = async function(recordId, object, columns = ["*"]) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { createOnly, ifVersion }) {
   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 },
-    ...fetchProps
+    queryParams: { createOnly, columns, ifVersion },
+    ...__privateGet$4(this, _getFetchProps).call(this)
   });
   const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response);
-};
-_bulkInsertTableRecords = new WeakSet();
-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) },
-    queryParams: { columns },
-    body: { records },
-    ...fetchProps
-  });
-  if (!isResponseWithRecords(response)) {
-    throw new Error("Request included columns but server didn't include them");
+  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+};
+_insertRecords = new WeakSet();
+insertRecords_fn = async function(objects, { createOnly, ifVersion }) {
+  const chunkedOperations = chunk(
+    objects.map((object) => ({
+      insert: { table: __privateGet$4(this, _table), record: transformObjectLinks(object), createOnly, ifVersion }
+    })),
+    BULK_OPERATION_MAX_SIZE
+  );
+  const ids = [];
+  for (const operations of chunkedOperations) {
+    const { results } = await branchTransaction({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}"
+      },
+      body: { operations },
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    });
+    for (const result of results) {
+      if (result.operation === "insert") {
+        ids.push(result.id);
+      } else {
+        ids.push(null);
+      }
+    }
   }
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-  return response.records?.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item));
+  return ids;
 };
 _updateRecordWithID = new WeakSet();
-updateRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const record = transformObjectLinks(object);
-  const response = await updateRecordWithID({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
-    queryParams: { columns },
-    body: record,
-    ...fetchProps
-  });
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response);
+updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
+  const { id: _id, ...record } = transformObjectLinks(object);
+  try {
+    const response = await updateRecordWithID({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}",
+        tableName: __privateGet$4(this, _table),
+        recordId
+      },
+      queryParams: { columns, ifVersion },
+      body: record,
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    });
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+  } catch (e) {
+    if (isObject(e) && e.status === 404) {
+      return null;
+    }
+    throw e;
+  }
+};
+_updateRecords = new WeakSet();
+updateRecords_fn = async function(objects, { ifVersion, upsert }) {
+  const chunkedOperations = chunk(
+    objects.map(({ id, ...object }) => ({
+      update: { table: __privateGet$4(this, _table), id, ifVersion, upsert, fields: transformObjectLinks(object) }
+    })),
+    BULK_OPERATION_MAX_SIZE
+  );
+  const ids = [];
+  for (const operations of chunkedOperations) {
+    const { results } = await branchTransaction({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}"
+      },
+      body: { operations },
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    });
+    for (const result of results) {
+      if (result.operation === "update") {
+        ids.push(result.id);
+      } else {
+        ids.push(null);
+      }
+    }
+  }
+  return ids;
 };
 _upsertRecordWithID = new WeakSet();
-upsertRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
   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
+    ...__privateGet$4(this, _getFetchProps).call(this)
   });
   const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response);
+  return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
 };
 _deleteRecord = new WeakSet();
-deleteRecord_fn = async function(recordId) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  await deleteRecord({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
-    ...fetchProps
-  });
+deleteRecord_fn = async function(recordId, columns = ["*"]) {
+  try {
+    const response = await deleteRecord({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}",
+        tableName: __privateGet$4(this, _table),
+        recordId
+      },
+      queryParams: { columns },
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    });
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+  } catch (e) {
+    if (isObject(e) && e.status === 404) {
+      return null;
+    }
+    throw e;
+  }
+};
+_deleteRecords = new WeakSet();
+deleteRecords_fn = async function(recordIds) {
+  const chunkedOperations = chunk(
+    recordIds.map((id) => ({ delete: { table: __privateGet$4(this, _table), id } })),
+    BULK_OPERATION_MAX_SIZE
+  );
+  for (const operations of chunkedOperations) {
+    await branchTransaction({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}"
+      },
+      body: { operations },
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    });
+  }
 };
 _setCacheQuery = new WeakSet();
 setCacheQuery_fn = async function(query, meta, records) {
@@ -1629,10 +3224,9 @@ _getSchemaTables$1 = new WeakSet();
 getSchemaTables_fn$1 = async function() {
   if (__privateGet$4(this, _schemaTables$2))
     return __privateGet$4(this, _schemaTables$2);
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const { schema } = await getBranchDetails({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-    ...fetchProps
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
+    ...__privateGet$4(this, _getFetchProps).call(this)
   });
   __privateSet$4(this, _schemaTables$2, schema.tables);
   return schema.tables;
@@ -1644,22 +3238,24 @@ const transformObjectLinks = (object) => {
     return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
   }, {});
 };
-const initObject = (db, schemaTables, table, object) => {
-  const result = {};
+const initObject = (db, schemaTables, table, object, selectedColumns) => {
+  const data = {};
   const { xata, ...rest } = object ?? {};
-  Object.assign(result, rest);
+  Object.assign(data, rest);
   const { columns } = schemaTables.find(({ name }) => name === table) ?? {};
   if (!columns)
     console.error(`Table ${table} not found in schema`);
   for (const column of columns ?? []) {
-    const value = result[column.name];
+    if (!isValidColumn(selectedColumns, column))
+      continue;
+    const value = data[column.name];
     switch (column.type) {
       case "datetime": {
-        const date = value !== void 0 ? new Date(value) : void 0;
-        if (date && isNaN(date.getTime())) {
+        const date = value !== void 0 ? new Date(value) : null;
+        if (date !== null && isNaN(date.getTime())) {
           console.error(`Failed to parse date ${value} for field ${column.name}`);
-        } else if (date) {
-          result[column.name] = date;
+        } else {
+          data[column.name] = date;
         }
         break;
       }
@@ -1668,32 +3264,85 @@ const initObject = (db, schemaTables, table, object) => {
         if (!linkTable) {
           console.error(`Failed to parse link for field ${column.name}`);
         } else if (isObject(value)) {
-          result[column.name] = initObject(db, schemaTables, linkTable, value);
+          const selectedLinkColumns = selectedColumns.reduce((acc, item) => {
+            if (item === column.name) {
+              return [...acc, "*"];
+            }
+            if (item.startsWith(`${column.name}.`)) {
+              const [, ...path] = item.split(".");
+              return [...acc, path.join(".")];
+            }
+            return acc;
+          }, []);
+          data[column.name] = initObject(db, schemaTables, linkTable, value, selectedLinkColumns);
+        } else {
+          data[column.name] = null;
         }
         break;
       }
+      default:
+        data[column.name] = value ?? null;
+        if (column.notNull === true && value === null) {
+          console.error(`Parse error, column ${column.name} is non nullable and value resolves null`);
+        }
+        break;
     }
   }
-  result.read = function(columns2) {
-    return db[table].read(result["id"], columns2);
+  const record = { ...data };
+  record.read = function(columns2) {
+    return db[table].read(record["id"], columns2);
   };
-  result.update = function(data, columns2) {
-    return db[table].update(result["id"], data, columns2);
+  record.update = function(data2, b, c) {
+    const columns2 = isStringArray(b) ? b : ["*"];
+    const ifVersion = parseIfVersion(b, c);
+    return db[table].update(record["id"], data2, columns2, { ifVersion });
   };
-  result.delete = function() {
-    return db[table].delete(result["id"]);
+  record.replace = function(data2, b, c) {
+    const columns2 = isStringArray(b) ? b : ["*"];
+    const ifVersion = parseIfVersion(b, c);
+    return db[table].createOrReplace(record["id"], data2, columns2, { ifVersion });
   };
-  result.getMetadata = function() {
+  record.delete = function() {
+    return db[table].delete(record["id"]);
+  };
+  record.getMetadata = function() {
     return xata;
   };
-  for (const prop of ["read", "update", "delete", "getMetadata"]) {
-    Object.defineProperty(result, prop, { enumerable: false });
+  record.toSerializable = function() {
+    return JSON.parse(JSON.stringify(transformObjectLinks(data)));
+  };
+  record.toString = function() {
+    return JSON.stringify(transformObjectLinks(data));
+  };
+  for (const prop of ["read", "update", "replace", "delete", "getMetadata", "toSerializable", "toString"]) {
+    Object.defineProperty(record, prop, { enumerable: false });
   }
-  Object.freeze(result);
-  return result;
+  Object.freeze(record);
+  return record;
 };
-function isResponseWithRecords(value) {
-  return isObject(value) && Array.isArray(value.records);
+function extractId(value) {
+  if (isString(value))
+    return value;
+  if (isObject(value) && isString(value.id))
+    return value.id;
+  return void 0;
+}
+function isValidColumn(columns, column) {
+  if (columns.includes("*"))
+    return true;
+  if (column.type === "link") {
+    const linkColumns = columns.filter((item) => item.startsWith(column.name));
+    return linkColumns.length > 0;
+  }
+  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) => {
@@ -1745,18 +3394,25 @@ class SimpleCache {
 }
 _map = new WeakMap();
 
-const gt = (value) => ({ $gt: value });
-const ge = (value) => ({ $ge: value });
-const gte = (value) => ({ $ge: value });
-const lt = (value) => ({ $lt: value });
-const lte = (value) => ({ $le: value });
-const le = (value) => ({ $le: value });
+const greaterThan = (value) => ({ $gt: value });
+const gt = greaterThan;
+const greaterThanEquals = (value) => ({ $ge: value });
+const greaterEquals = greaterThanEquals;
+const gte = greaterThanEquals;
+const ge = greaterThanEquals;
+const lessThan = (value) => ({ $lt: value });
+const lt = lessThan;
+const lessThanEquals = (value) => ({ $le: value });
+const lessEquals = lessThanEquals;
+const lte = lessThanEquals;
+const le = lessThanEquals;
 const exists = (column) => ({ $exists: column });
 const notExists = (column) => ({ $notExists: column });
 const startsWith = (value) => ({ $startsWith: value });
 const endsWith = (value) => ({ $endsWith: value });
 const pattern = (value) => ({ $pattern: value });
 const is = (value) => ({ $is: value });
+const equals = is;
 const isNot = (value) => ({ $isNot: value });
 const contains = (value) => ({ $contains: value });
 const includes = (value) => ({ $includes: value });
@@ -1846,23 +3502,23 @@ class SearchPlugin extends XataPlugin {
     __privateAdd$1(this, _schemaTables, void 0);
     __privateSet$1(this, _schemaTables, schemaTables);
   }
-  build({ getFetchProps }) {
+  build(pluginOptions) {
     return {
       all: async (query, options = {}) => {
-        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
+        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, pluginOptions);
         return records.map((record) => {
           const { table = "orphan" } = record.xata;
-          return { table, record: initObject(this.db, schemaTables, table, record) };
+          return { table, record: initObject(this.db, schemaTables, table, record, ["*"]) };
         });
       },
       byTable: async (query, options = {}) => {
-        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
+        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, pluginOptions);
         return records.reduce((acc, record) => {
           const { table = "orphan" } = record.xata;
           const items = acc[table] ?? [];
-          const item = initObject(this.db, schemaTables, table, record);
+          const item = initObject(this.db, schemaTables, table, record, ["*"]);
           return { ...acc, [table]: [...items, item] };
         }, {});
       }
@@ -1871,106 +3527,39 @@ class SearchPlugin extends XataPlugin {
 }
 _schemaTables = new WeakMap();
 _search = new WeakSet();
-search_fn = async function(query, options, getFetchProps) {
-  const fetchProps = await getFetchProps();
-  const { tables, fuzziness, highlight, prefix } = options ?? {};
+search_fn = async function(query, options, pluginOptions) {
+  const { tables, fuzziness, highlight, prefix, page } = options ?? {};
   const { records } = await searchBranch({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-    body: { tables, query, fuzziness, prefix, highlight },
-    ...fetchProps
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
+    body: { tables, query, fuzziness, prefix, highlight, page },
+    ...pluginOptions
   });
   return records;
 };
 _getSchemaTables = new WeakSet();
-getSchemaTables_fn = async function(getFetchProps) {
+getSchemaTables_fn = async function(pluginOptions) {
   if (__privateGet$1(this, _schemaTables))
     return __privateGet$1(this, _schemaTables);
-  const fetchProps = await getFetchProps();
   const { schema } = await getBranchDetails({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-    ...fetchProps
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
+    ...pluginOptions
   });
   __privateSet$1(this, _schemaTables, schema.tables);
   return schema.tables;
 };
 
-const isBranchStrategyBuilder = (strategy) => {
-  return typeof strategy === "function";
-};
-
-async function getCurrentBranchName(options) {
-  const { branch, envBranch } = getEnvironment();
-  if (branch) {
-    const details = await getDatabaseBranch(branch, options);
-    if (details)
-      return branch;
-    console.warn(`Branch ${branch} not found in Xata. Ignoring...`);
-  }
-  const gitBranch = envBranch || await getGitBranch();
-  return resolveXataBranch(gitBranch, options);
-}
-async function getCurrentBranchDetails(options) {
-  const branch = await getCurrentBranchName(options);
-  return getDatabaseBranch(branch, options);
-}
-async function resolveXataBranch(gitBranch, options) {
-  const databaseURL = options?.databaseURL || getDatabaseURL();
-  const apiKey = options?.apiKey || getAPIKey();
-  if (!databaseURL)
-    throw new Error(
-      "A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely"
-    );
-  if (!apiKey)
-    throw new Error(
-      "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 { fallbackBranch } = getEnvironment();
-  const { branch } = await resolveBranch({
-    apiKey,
-    apiUrl: databaseURL,
-    fetchImpl: getFetchImplementation(options?.fetchImpl),
-    workspacesApiUrl: `${protocol}//${host}`,
-    pathParams: { dbName, workspace },
-    queryParams: { gitBranch, fallbackBranch }
-  });
-  return branch;
-}
-async function getDatabaseBranch(branch, options) {
-  const databaseURL = options?.databaseURL || getDatabaseURL();
-  const apiKey = options?.apiKey || getAPIKey();
-  if (!databaseURL)
-    throw new Error(
-      "A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely"
-    );
-  if (!apiKey)
-    throw new Error(
-      "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}`;
-  try {
-    return await getBranchDetails({
-      apiKey,
-      apiUrl: databaseURL,
-      fetchImpl: getFetchImplementation(options?.fetchImpl),
-      workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: { dbBranchName, workspace }
-    });
-  } catch (err) {
-    if (isObject(err) && err.status === 404)
-      return null;
-    throw err;
-  }
-}
-function getDatabaseURL() {
-  try {
-    const { databaseURL } = getEnvironment();
-    return databaseURL;
-  } catch (err) {
-    return void 0;
+class TransactionPlugin extends XataPlugin {
+  build(pluginOptions) {
+    return {
+      run: async (operations) => {
+        const response = await branchTransaction({
+          pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
+          body: { operations },
+          ...pluginOptions
+        });
+        return response;
+      }
+    };
   }
 }
 
@@ -1997,24 +3586,24 @@ var __privateMethod = (obj, member, method) => {
   return method;
 };
 const buildClient = (plugins) => {
-  var _branch, _options, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _evaluateBranch, evaluateBranch_fn, _a;
+  var _options, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _a;
   return _a = class {
     constructor(options = {}, schemaTables) {
       __privateAdd(this, _parseOptions);
       __privateAdd(this, _getFetchProps);
-      __privateAdd(this, _evaluateBranch);
-      __privateAdd(this, _branch, void 0);
       __privateAdd(this, _options, void 0);
       const safeOptions = __privateMethod(this, _parseOptions, parseOptions_fn).call(this, options);
       __privateSet(this, _options, safeOptions);
       const pluginOptions = {
-        getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
+        ...__privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
         cache: safeOptions.cache
       };
       const db = new SchemaPlugin(schemaTables).build(pluginOptions);
       const search = new SearchPlugin(db, schemaTables).build(pluginOptions);
+      const transactions = new TransactionPlugin().build(pluginOptions);
       this.db = db;
       this.search = search;
+      this.transactions = transactions;
       for (const [key, namespace] of Object.entries(plugins ?? {})) {
         if (namespace === void 0)
           continue;
@@ -2030,54 +3619,156 @@ const buildClient = (plugins) => {
     }
     async getConfig() {
       const databaseURL = __privateGet(this, _options).databaseURL;
-      const branch = await __privateGet(this, _options).branch();
+      const branch = __privateGet(this, _options).branch;
       return { databaseURL, branch };
     }
-  }, _branch = new WeakMap(), _options = new WeakMap(), _parseOptions = new WeakSet(), parseOptions_fn = function(options) {
+  }, _options = new WeakMap(), _parseOptions = new WeakSet(), parseOptions_fn = function(options) {
+    const enableBrowser = options?.enableBrowser ?? getEnableBrowserVariable() ?? false;
+    const isBrowser = typeof window !== "undefined" && typeof Deno === "undefined";
+    if (isBrowser && !enableBrowser) {
+      throw new Error(
+        "You are trying to use Xata from the browser, which is potentially a non-secure environment. If you understand the security concerns, such as leaking your credentials, pass `enableBrowser: true` to the client options to remove this error."
+      );
+    }
     const fetch = getFetchImplementation(options?.fetch);
     const databaseURL = options?.databaseURL || getDatabaseURL();
+    const branch = options?.branch || getBranch() || "main";
     const apiKey = options?.apiKey || getAPIKey();
     const cache = options?.cache ?? new SimpleCache({ defaultQueryTTL: 0 });
-    const branch = async () => options?.branch !== void 0 ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({ apiKey, databaseURL, fetchImpl: options?.fetch });
-    if (!databaseURL || !apiKey) {
-      throw new Error("Options databaseURL and apiKey are required");
+    const trace = options?.trace ?? defaultTrace;
+    const clientName = options?.clientName;
+    const host = options?.host ?? "production";
+    const xataAgentExtra = options?.xataAgentExtra;
+    if (!apiKey) {
+      throw new Error("Option apiKey is required");
     }
-    return { fetch, databaseURL, apiKey, branch, cache };
-  }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({ fetch, apiKey, databaseURL, branch }) {
-    const branchValue = await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, branch);
-    if (!branchValue)
-      throw new Error("Unable to resolve branch value");
+    if (!databaseURL) {
+      throw new Error("Option databaseURL is required");
+    }
+    return {
+      fetch,
+      databaseURL,
+      apiKey,
+      branch,
+      cache,
+      trace,
+      host,
+      clientID: generateUUID(),
+      enableBrowser,
+      clientName,
+      xataAgentExtra
+    };
+  }, _getFetchProps = new WeakSet(), getFetchProps_fn = function({
+    fetch,
+    apiKey,
+    databaseURL,
+    branch,
+    trace,
+    clientID,
+    clientName,
+    xataAgentExtra
+  }) {
     return {
-      fetchImpl: fetch,
+      fetch,
       apiKey,
       apiUrl: "",
       workspacesApiUrl: (path, params) => {
         const hasBranch = params.dbBranchName ?? params.branch;
-        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branchValue}` : "");
+        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch !== void 0 ? `:${branch}` : "");
         return databaseURL + newPath;
-      }
-    };
-  }, _evaluateBranch = new WeakSet(), evaluateBranch_fn = async function(param) {
-    if (__privateGet(this, _branch))
-      return __privateGet(this, _branch);
-    if (param === void 0)
-      return void 0;
-    const strategies = Array.isArray(param) ? [...param] : [param];
-    const evaluateBranch = async (strategy) => {
-      return isBranchStrategyBuilder(strategy) ? await strategy() : strategy;
+      },
+      trace,
+      clientID,
+      clientName,
+      xataAgentExtra
     };
-    for await (const strategy of strategies) {
-      const branch = await evaluateBranch(strategy);
-      if (branch) {
-        __privateSet(this, _branch, branch);
-        return branch;
-      }
-    }
   }, _a;
 };
 class BaseClient extends buildClient() {
 }
 
+const META = "__";
+const VALUE = "___";
+class Serializer {
+  constructor() {
+    this.classes = {};
+  }
+  add(clazz) {
+    this.classes[clazz.name] = clazz;
+  }
+  toJSON(data) {
+    function visit(obj) {
+      if (Array.isArray(obj))
+        return obj.map(visit);
+      const type = typeof obj;
+      if (type === "undefined")
+        return { [META]: "undefined" };
+      if (type === "bigint")
+        return { [META]: "bigint", [VALUE]: obj.toString() };
+      if (obj === null || type !== "object")
+        return obj;
+      const constructor = obj.constructor;
+      const o = { [META]: constructor.name };
+      for (const [key, value] of Object.entries(obj)) {
+        o[key] = visit(value);
+      }
+      if (constructor === Date)
+        o[VALUE] = obj.toISOString();
+      if (constructor === Map)
+        o[VALUE] = Object.fromEntries(obj);
+      if (constructor === Set)
+        o[VALUE] = [...obj];
+      return o;
+    }
+    return JSON.stringify(visit(data));
+  }
+  fromJSON(json) {
+    return JSON.parse(json, (key, value) => {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const { [META]: clazz, [VALUE]: val, ...rest } = value;
+        const constructor = this.classes[clazz];
+        if (constructor) {
+          return Object.assign(Object.create(constructor.prototype), rest);
+        }
+        if (clazz === "Date")
+          return new Date(val);
+        if (clazz === "Set")
+          return new Set(val);
+        if (clazz === "Map")
+          return new Map(Object.entries(val));
+        if (clazz === "bigint")
+          return BigInt(val);
+        if (clazz === "undefined")
+          return void 0;
+        return rest;
+      }
+      return value;
+    });
+  }
+}
+const defaultSerializer = new Serializer();
+const serialize = (data) => {
+  return defaultSerializer.toJSON(data);
+};
+const deserialize = (json) => {
+  return defaultSerializer.fromJSON(json);
+};
+
+function buildWorkerRunner(config) {
+  return function xataWorker(name, worker) {
+    return async (...args) => {
+      const url = process.env.NODE_ENV === "development" ? `http://localhost:64749/${name}` : `https://dispatcher.xata.workers.dev/${config.workspace}/${config.worker}/${name}`;
+      const result = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: serialize({ args })
+      });
+      const text = await result.text();
+      return deserialize(text);
+    };
+  };
+}
+
 class XataError extends Error {
   constructor(message, status) {
     super(message);
@@ -2086,6 +3777,7 @@ class XataError extends Error {
 }
 
 exports.BaseClient = BaseClient;
+exports.FetcherError = FetcherError;
 exports.Operations = operationsByTag;
 exports.PAGINATION_DEFAULT_OFFSET = PAGINATION_DEFAULT_OFFSET;
 exports.PAGINATION_DEFAULT_SIZE = PAGINATION_DEFAULT_SIZE;
@@ -2098,6 +3790,7 @@ exports.Repository = Repository;
 exports.RestRepository = RestRepository;
 exports.SchemaPlugin = SchemaPlugin;
 exports.SearchPlugin = SearchPlugin;
+exports.Serializer = Serializer;
 exports.SimpleCache = SimpleCache;
 exports.XataApiClient = XataApiClient;
 exports.XataApiPlugin = XataApiPlugin;
@@ -2106,40 +3799,58 @@ exports.XataPlugin = XataPlugin;
 exports.acceptWorkspaceMemberInvite = acceptWorkspaceMemberInvite;
 exports.addGitBranchesEntry = addGitBranchesEntry;
 exports.addTableColumn = addTableColumn;
+exports.aggregateTable = aggregateTable;
+exports.applyBranchSchemaEdit = applyBranchSchemaEdit;
+exports.askTable = askTable;
+exports.branchTransaction = branchTransaction;
 exports.buildClient = buildClient;
+exports.buildWorkerRunner = buildWorkerRunner;
 exports.bulkInsertTableRecords = bulkInsertTableRecords;
 exports.cancelWorkspaceMemberInvite = cancelWorkspaceMemberInvite;
+exports.compareBranchSchemas = compareBranchSchemas;
+exports.compareBranchWithUserSchema = compareBranchWithUserSchema;
+exports.compareMigrationRequest = compareMigrationRequest;
 exports.contains = contains;
+exports.copyBranch = copyBranch;
 exports.createBranch = createBranch;
 exports.createDatabase = createDatabase;
+exports.createMigrationRequest = createMigrationRequest;
 exports.createTable = createTable;
 exports.createUserAPIKey = createUserAPIKey;
 exports.createWorkspace = createWorkspace;
 exports.deleteBranch = deleteBranch;
 exports.deleteColumn = deleteColumn;
 exports.deleteDatabase = deleteDatabase;
+exports.deleteDatabaseGithubSettings = deleteDatabaseGithubSettings;
 exports.deleteRecord = deleteRecord;
 exports.deleteTable = deleteTable;
 exports.deleteUser = deleteUser;
 exports.deleteUserAPIKey = deleteUserAPIKey;
 exports.deleteWorkspace = deleteWorkspace;
+exports.deserialize = deserialize;
 exports.endsWith = endsWith;
+exports.equals = equals;
 exports.executeBranchMigrationPlan = executeBranchMigrationPlan;
 exports.exists = exists;
 exports.ge = ge;
 exports.getAPIKey = getAPIKey;
+exports.getBranch = getBranch;
 exports.getBranchDetails = getBranchDetails;
 exports.getBranchList = getBranchList;
 exports.getBranchMetadata = getBranchMetadata;
 exports.getBranchMigrationHistory = getBranchMigrationHistory;
 exports.getBranchMigrationPlan = getBranchMigrationPlan;
+exports.getBranchSchemaHistory = getBranchSchemaHistory;
 exports.getBranchStats = getBranchStats;
 exports.getColumn = getColumn;
-exports.getCurrentBranchDetails = getCurrentBranchDetails;
-exports.getCurrentBranchName = getCurrentBranchName;
+exports.getDatabaseGithubSettings = getDatabaseGithubSettings;
 exports.getDatabaseList = getDatabaseList;
+exports.getDatabaseMetadata = getDatabaseMetadata;
 exports.getDatabaseURL = getDatabaseURL;
 exports.getGitBranchesMapping = getGitBranchesMapping;
+exports.getHostUrl = getHostUrl;
+exports.getMigrationRequest = getMigrationRequest;
+exports.getMigrationRequestIsMerged = getMigrationRequestIsMerged;
 exports.getRecord = getRecord;
 exports.getTableColumns = getTableColumns;
 exports.getTableSchema = getTableSchema;
@@ -2148,6 +3859,9 @@ exports.getUserAPIKeys = getUserAPIKeys;
 exports.getWorkspace = getWorkspace;
 exports.getWorkspaceMembersList = getWorkspaceMembersList;
 exports.getWorkspacesList = getWorkspacesList;
+exports.greaterEquals = greaterEquals;
+exports.greaterThan = greaterThan;
+exports.greaterThanEquals = greaterThanEquals;
 exports.gt = gt;
 exports.gte = gte;
 exports.includes = includes;
@@ -2159,15 +3873,27 @@ exports.insertRecordWithID = insertRecordWithID;
 exports.inviteWorkspaceMember = inviteWorkspaceMember;
 exports.is = is;
 exports.isCursorPaginationOptions = isCursorPaginationOptions;
+exports.isHostProviderAlias = isHostProviderAlias;
+exports.isHostProviderBuilder = isHostProviderBuilder;
 exports.isIdentifiable = isIdentifiable;
 exports.isNot = isNot;
 exports.isXataRecord = isXataRecord;
 exports.le = le;
+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;
 exports.queryTable = queryTable;
 exports.removeGitBranchesEntry = removeGitBranchesEntry;
 exports.removeWorkspaceMember = removeWorkspaceMember;
@@ -2175,10 +3901,16 @@ exports.resendWorkspaceMemberInvite = resendWorkspaceMemberInvite;
 exports.resolveBranch = resolveBranch;
 exports.searchBranch = searchBranch;
 exports.searchTable = searchTable;
+exports.serialize = serialize;
 exports.setTableSchema = setTableSchema;
 exports.startsWith = startsWith;
+exports.summarizeTable = summarizeTable;
 exports.updateBranchMetadata = updateBranchMetadata;
+exports.updateBranchSchema = updateBranchSchema;
 exports.updateColumn = updateColumn;
+exports.updateDatabaseGithubSettings = updateDatabaseGithubSettings;
+exports.updateDatabaseMetadata = updateDatabaseMetadata;
+exports.updateMigrationRequest = updateMigrationRequest;
 exports.updateRecordWithID = updateRecordWithID;
 exports.updateTable = updateTable;
 exports.updateUser = updateUser;
@@ -2186,4 +3918,5 @@ exports.updateWorkspace = updateWorkspace;
 exports.updateWorkspaceMemberInvite = updateWorkspaceMemberInvite;
 exports.updateWorkspaceMemberRole = updateWorkspaceMemberRole;
 exports.upsertRecordWithID = upsertRecordWithID;
+exports.vectorSearchTable = vectorSearchTable;
 //# sourceMappingURL=index.cjs.map