@xata.io/client 0.0.0-alpha.vf76843f → 0.0.0-alpha.vf7a5219a6da9afdecee2e8995fcc249036ff88a1

package/dist/index.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-const defaultTrace = async (_name, fn, _options) => {
+const defaultTrace = async (name, fn, _options) => {
   return await fn({
+    name,
     setAttributes: () => {
       return;
     }
@@ -19,7 +20,8 @@ const TraceAttributes = {
   HTTP_METHOD: "http.method",
   HTTP_URL: "http.url",
   HTTP_ROUTE: "http.route",
-  HTTP_TARGET: "http.target"
+  HTTP_TARGET: "http.target",
+  CLOUDFLARE_RAY_ID: "cf.ray"
 };
 
 function notEmpty(value) {
@@ -28,8 +30,18 @@ function notEmpty(value) {
 function compact(arr) {
   return arr.filter(notEmpty);
 }
+function compactObject(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => notEmpty(value)));
+}
+function isBlob(value) {
+  try {
+    return value instanceof Blob;
+  } catch (error) {
+    return false;
+  }
+}
 function isObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !isBlob(value);
 }
 function isDefined(value) {
   return value !== null && value !== void 0;
@@ -43,6 +55,18 @@ function isStringArray(value) {
 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);
@@ -69,16 +93,42 @@ function chunk(array, chunkSize) {
   }
   return result;
 }
+async function timeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function timeoutWithCancel(ms) {
+  let timeoutId;
+  const promise = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      resolve();
+    }, ms);
+  });
+  return {
+    cancel: () => clearTimeout(timeoutId),
+    promise
+  };
+}
+function promiseMap(inputValues, mapper) {
+  const reducer = (acc$, inputValue) => acc$.then(
+    (acc) => mapper(inputValue).then((result) => {
+      acc.push(result);
+      return acc;
+    })
+  );
+  return inputValues.reduce(reducer, Promise.resolve([]));
+}
 
 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(),
         branch: process.env.XATA_BRANCH ?? getGlobalBranch(),
-        envBranch: process.env.VERCEL_GIT_COMMIT_REF ?? process.env.CF_PAGES_BRANCH ?? process.env.BRANCH,
-        fallbackBranch: process.env.XATA_FALLBACK_BRANCH ?? getGlobalFallbackBranch()
+        deployPreview: process.env.XATA_PREVIEW,
+        deployPreviewBranch: process.env.XATA_PREVIEW_BRANCH,
+        vercelGitCommitRef: process.env.VERCEL_GIT_COMMIT_REF,
+        vercelGitRepoOwner: process.env.VERCEL_GIT_REPO_OWNER
       };
     }
   } catch (err) {
@@ -89,8 +139,10 @@ function getEnvironment() {
         apiKey: Deno.env.get("XATA_API_KEY") ?? getGlobalApiKey(),
         databaseURL: Deno.env.get("XATA_DATABASE_URL") ?? getGlobalDatabaseURL(),
         branch: Deno.env.get("XATA_BRANCH") ?? getGlobalBranch(),
-        envBranch: Deno.env.get("VERCEL_GIT_COMMIT_REF") ?? Deno.env.get("CF_PAGES_BRANCH") ?? Deno.env.get("BRANCH"),
-        fallbackBranch: Deno.env.get("XATA_FALLBACK_BRANCH") ?? getGlobalFallbackBranch()
+        deployPreview: Deno.env.get("XATA_PREVIEW"),
+        deployPreviewBranch: Deno.env.get("XATA_PREVIEW_BRANCH"),
+        vercelGitCommitRef: Deno.env.get("VERCEL_GIT_COMMIT_REF"),
+        vercelGitRepoOwner: Deno.env.get("VERCEL_GIT_REPO_OWNER")
       };
     }
   } catch (err) {
@@ -99,8 +151,10 @@ function getEnvironment() {
     apiKey: getGlobalApiKey(),
     databaseURL: getGlobalDatabaseURL(),
     branch: getGlobalBranch(),
-    envBranch: void 0,
-    fallbackBranch: getGlobalFallbackBranch()
+    deployPreview: void 0,
+    deployPreviewBranch: void 0,
+    vercelGitCommitRef: void 0,
+    vercelGitRepoOwner: void 0
   };
 }
 function getEnableBrowserVariable() {
@@ -143,56 +197,338 @@ function getGlobalBranch() {
     return void 0;
   }
 }
-function getGlobalFallbackBranch() {
+function getDatabaseURL() {
   try {
-    return XATA_FALLBACK_BRANCH;
+    const { databaseURL } = getEnvironment();
+    return databaseURL;
   } catch (err) {
     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 getAPIKey() {
   try {
-    if (typeof require === "function") {
-      return require(nodeModule).execSync(fullCmd, execOptions).trim();
-    }
-    const { execSync } = await import(nodeModule);
-    return execSync(fullCmd, execOptions).toString().trim();
+    const { apiKey } = getEnvironment();
+    return apiKey;
   } 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 } = getEnvironment();
+    return branch;
   } catch (err) {
+    return void 0;
   }
 }
-
-function getAPIKey() {
+function buildPreviewBranchName({ org, branch }) {
+  return `preview-${org}-${branch}`;
+}
+function getPreviewBranch() {
   try {
-    const { apiKey } = getEnvironment();
-    return apiKey;
+    const { deployPreview, deployPreviewBranch, vercelGitCommitRef, vercelGitRepoOwner } = getEnvironment();
+    if (deployPreviewBranch)
+      return deployPreviewBranch;
+    switch (deployPreview) {
+      case "vercel": {
+        if (!vercelGitCommitRef || !vercelGitRepoOwner) {
+          console.warn("XATA_PREVIEW=vercel but VERCEL_GIT_COMMIT_REF or VERCEL_GIT_REPO_OWNER is not valid");
+          return void 0;
+        }
+        return buildPreviewBranchName({ org: vercelGitRepoOwner, branch: vercelGitCommitRef });
+      }
+    }
+    return void 0;
   } catch (err) {
     return void 0;
   }
 }
 
+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;
+const REQUEST_TIMEOUT = 5 * 60 * 1e3;
 function getFetchImplementation(userFetch) {
   const globalFetch = typeof fetch !== "undefined" ? fetch : void 0;
-  const fetchImpl = userFetch ?? globalFetch;
+  const globalThisFetch = typeof globalThis !== "undefined" ? globalThis.fetch : void 0;
+  const fetchImpl = userFetch ?? globalFetch ?? globalThisFetch;
   if (!fetchImpl) {
-    throw new Error(
-      `Couldn't find \`fetch\`. Install a fetch implementation such as \`node-fetch\` and pass it explicitly.`
-    );
+    throw new Error(`Couldn't find a global \`fetch\`. Pass a fetch implementation 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 = /* @__PURE__ */ new Date();
+    const fetchImpl = this.getFetch();
+    const runRequest = async (stalled = false) => {
+      const { promise, cancel } = timeoutWithCancel(REQUEST_TIMEOUT);
+      const response = await Promise.race([fetchImpl(url, options), promise.then(() => null)]).finally(cancel);
+      if (!response) {
+        throw new Error("Request timed out");
+      }
+      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 = (/* @__PURE__ */ new Date()).getTime() - start.getTime();
+        console.warn(`A request to Xata hit branch rate 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.vf76843f";
+const VERSION = "0.28.3";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -203,7 +539,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;
@@ -235,6 +571,68 @@ function getMessage(data) {
   }
 }
 
+function getHostUrl(provider, type) {
+  if (isHostProviderAlias(provider)) {
+    return providers[provider][type];
+  } else if (isHostProviderBuilder(provider)) {
+    return provider[type];
+  }
+  throw new Error("Invalid API provider");
+}
+const providers = {
+  production: {
+    main: "https://api.xata.io",
+    workspaces: "https://{workspaceId}.{region}.xata.sh"
+  },
+  staging: {
+    main: "https://api.staging-xata.dev",
+    workspaces: "https://{workspaceId}.{region}.staging-xata.dev"
+  },
+  dev: {
+    main: "https://api.dev-xata.dev",
+    workspaces: "https://{workspaceId}.{region}.dev-xata.dev"
+  },
+  local: {
+    main: "http://localhost:6001",
+    workspaces: "http://{workspaceId}.{region}.localhost:6001"
+  }
+};
+function isHostProviderAlias(alias) {
+  return isString(alias) && Object.keys(providers).includes(alias);
+}
+function isHostProviderBuilder(builder) {
+  return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
+}
+function parseProviderString(provider = "production") {
+  if (isHostProviderAlias(provider)) {
+    return provider;
+  }
+  const [main, workspaces] = provider.split(",");
+  if (!main || !workspaces)
+    return null;
+  return { main, workspaces };
+}
+function buildProviderString(provider) {
+  if (isHostProviderAlias(provider))
+    return provider;
+  return `${provider.main},${provider.workspaces}`;
+}
+function parseWorkspacesUrlParts(url) {
+  if (!isString(url))
+    return null;
+  const matches = {
+    production: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.sh.*/),
+    staging: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.staging-xata\.dev.*/),
+    dev: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.dev-xata\.dev.*/),
+    local: url.match(/(?:https?:\/\/)?([^.]+)(?:\.([^.]+))\.localhost:(\d+)/)
+  };
+  const [host, match] = Object.entries(matches).find(([, match2]) => match2 !== null) ?? [];
+  if (!isHostProviderAlias(host) || !match)
+    return null;
+  return { workspace: match[1], region: match[2], host };
+}
+
+const pool = new ApiRequestPool();
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   const cleanQueryParams = Object.entries(queryParams).reduce((acc, [key, value]) => {
     if (value === void 0 || value === null)
@@ -249,6 +647,7 @@ const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   return url.replace(/\{\w*\}/g, (key) => cleanPathParams[key.slice(1, -1)]) + queryString;
 };
 function buildBaseUrl({
+  method,
   endpoint,
   path,
   workspacesApiUrl,
@@ -256,7 +655,24 @@ function buildBaseUrl({
   pathParams = {}
 }) {
   if (endpoint === "dataPlane") {
-    const url = isString(workspacesApiUrl) ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
+    let url = isString(workspacesApiUrl) ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
+    if (method.toUpperCase() === "PUT" && [
+      "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file",
+      "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file/{fileId}"
+    ].includes(path)) {
+      const { host } = parseWorkspacesUrlParts(url) ?? {};
+      switch (host) {
+        case "production":
+          url = url.replace("xata.sh", "upload.xata.sh");
+          break;
+        case "staging":
+          url = url.replace("staging-xata.dev", "upload.staging-xata.dev");
+          break;
+        case "dev":
+          url = url.replace("dev-xata.dev", "upload.dev-xata.dev");
+          break;
+      }
+    }
     const urlWithWorkspace = isString(pathParams.workspace) ? url.replace("{workspaceId}", String(pathParams.workspace)) : url;
     return isString(pathParams.region) ? urlWithWorkspace.replace("{region}", String(pathParams.region)) : urlWithWorkspace;
   }
@@ -267,14 +683,27 @@ function hostHeader(url) {
   const { groups } = pattern.exec(url) ?? {};
   return groups?.host ? { Host: groups.host } : {};
 }
+async function parseBody(body, headers) {
+  if (!isDefined(body))
+    return void 0;
+  if (isBlob(body) || typeof body.text === "function") {
+    return body;
+  }
+  const { "Content-Type": contentType } = headers ?? {};
+  if (String(contentType).toLowerCase() === "application/json" && isObject(body)) {
+    return JSON.stringify(body);
+  }
+  return body;
+}
+const defaultClientID = generateUUID();
 async function fetch$1({
   url: path,
   method,
   body,
-  headers,
+  headers: customHeaders,
   pathParams,
   queryParams,
-  fetchImpl,
+  fetch: fetch2,
   apiKey,
   endpoint,
   apiUrl,
@@ -283,36 +712,45 @@ async function fetch$1({
   signal,
   clientID,
   sessionID,
-  fetchOptions = {}
+  clientName,
+  xataAgentExtra,
+  fetchOptions = {},
+  rawResponse = false
 }) {
-  return trace(
+  pool.setFetch(fetch2);
+  return await trace(
     `${method.toUpperCase()} ${path}`,
     async ({ setAttributes }) => {
-      const baseUrl = buildBaseUrl({ endpoint, path, workspacesApiUrl, pathParams, apiUrl });
+      const baseUrl = buildBaseUrl({ method, endpoint, path, workspacesApiUrl, pathParams, apiUrl });
       const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
-      const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
+      const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\.[^.]+\./, "http://") : fullUrl;
       setAttributes({
         [TraceAttributes.HTTP_URL]: url,
         [TraceAttributes.HTTP_TARGET]: resolveUrl(path, queryParams, pathParams)
       });
-      const response = await fetchImpl(url, {
+      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 = compactObject({
+        "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: {
-          "Content-Type": "application/json",
-          "User-Agent": `Xata client-ts/${VERSION}`,
-          "X-Xata-Client-ID": clientID ?? "",
-          "X-Xata-Session-ID": sessionID ?? "",
-          ...headers,
-          ...hostHeader(fullUrl),
-          Authorization: `Bearer ${apiKey}`
-        },
+        body: await parseBody(body, headers),
+        headers,
         signal
       });
-      if (response.status === 204) {
-        return {};
-      }
       const { host, protocol } = parseUrl(response.url);
       const requestId = response.headers?.get("x-request-id") ?? void 0;
       setAttributes({
@@ -320,10 +758,20 @@ async function fetch$1({
         [TraceAttributes.HTTP_REQUEST_ID]: requestId,
         [TraceAttributes.HTTP_STATUS_CODE]: response.status,
         [TraceAttributes.HTTP_HOST]: host,
-        [TraceAttributes.HTTP_SCHEME]: protocol?.replace(":", "")
+        [TraceAttributes.HTTP_SCHEME]: protocol?.replace(":", ""),
+        [TraceAttributes.CLOUDFLARE_RAY_ID]: response.headers?.get("cf-ray") ?? void 0
       });
+      const message = response.headers?.get("x-xata-message");
+      if (message)
+        console.warn(message);
+      if (response.status === 204) {
+        return {};
+      }
+      if (response.status === 429) {
+        throw new FetcherError(response.status, "Rate limit exceeded", requestId);
+      }
       try {
-        const jsonResponse = await response.json();
+        const jsonResponse = rawResponse ? await response.blob() : await response.json();
         if (response.ok) {
           return jsonResponse;
         }
@@ -335,6 +783,59 @@ async function fetch$1({
     { [TraceAttributes.HTTP_METHOD]: method.toUpperCase(), [TraceAttributes.HTTP_ROUTE]: path }
   );
 }
+function fetchSSERequest({
+  url: path,
+  method,
+  body,
+  headers: customHeaders,
+  pathParams,
+  queryParams,
+  fetch: fetch2,
+  apiKey,
+  endpoint,
+  apiUrl,
+  workspacesApiUrl,
+  onMessage,
+  onError,
+  onClose,
+  signal,
+  clientID,
+  sessionID,
+  clientName,
+  xataAgentExtra
+}) {
+  const baseUrl = buildBaseUrl({ method, endpoint, path, workspacesApiUrl, pathParams, apiUrl });
+  const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
+  const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
+  void fetchEventSource(url, {
+    method,
+    body: JSON.stringify(body),
+    fetch: fetch2,
+    signal,
+    headers: {
+      "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?.();
+    }
+  });
+}
 function parseUrl(url) {
   try {
     const { host, protocol } = new URL(url);
@@ -346,17 +847,26 @@ function parseUrl(url) {
 
 const dataPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "dataPlane" });
 
-const dEPRECATEDgetDatabaseList = (variables, signal) => dataPlaneFetch({ url: "/dbs", method: "get", ...variables, signal });
+const applyMigration = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/pgroll/apply", method: "post", ...variables, signal });
+const pgRollStatus = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/pgroll/status",
+  method: "get",
+  ...variables,
+  signal
+});
+const pgRollJobStatus = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/pgroll/jobs/{jobId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const pgRollMigrationHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/pgroll/migrations", method: "get", ...variables, signal });
 const getBranchList = (variables, signal) => dataPlaneFetch({
   url: "/dbs/{dbName}",
   method: "get",
   ...variables,
   signal
 });
-const dEPRECATEDcreateDatabase = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}", method: "put", ...variables, signal });
-const dEPRECATEDdeleteDatabase = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}", method: "delete", ...variables, signal });
-const dEPRECATEDgetDatabaseMetadata = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/metadata", method: "get", ...variables, signal });
-const dEPRECATEDupdateDatabaseMetadata = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/metadata", method: "patch", ...variables, signal });
 const getBranchDetails = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}",
   method: "get",
@@ -370,6 +880,18 @@ const deleteBranch = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+const getSchema = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema",
+  method: "get",
+  ...variables,
+  signal
+});
+const copyBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/copy",
+  method: "post",
+  ...variables,
+  signal
+});
 const updateBranchMetadata = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/metadata",
   method: "put",
@@ -395,7 +917,6 @@ const resolveBranch = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName
 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 branchTransaction = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/transaction", 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({
@@ -420,6 +941,7 @@ const compareBranchSchemas = (variables, signal) => dataPlaneFetch({ url: "/db/{
 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 pushBranchMigrations = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/push", method: "post", ...variables, signal });
 const createTable = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}",
   method: "put",
@@ -462,7 +984,44 @@ const deleteColumn = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+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 getFileItem = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file/{fileId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const putFileItem = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file/{fileId}",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteFileItem = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file/{fileId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getFile = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file",
+  method: "get",
+  ...variables,
+  signal
+});
+const putFile = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteFile = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}/column/{columnName}/file",
+  method: "delete",
+  ...variables,
+  signal
+});
 const getRecord = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
   method: "get",
@@ -492,21 +1051,45 @@ const searchTable = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+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,
+  signal
+});
+const askTableSession = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/ask/{sessionId}", method: "post", ...variables, signal });
 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 fileAccess = (variables, signal) => dataPlaneFetch({
+  url: "/file/{fileId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const fileUpload = (variables, signal) => dataPlaneFetch({
+  url: "/file/{fileId}",
+  method: "put",
+  ...variables,
+  signal
+});
+const sqlQuery = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/sql",
+  method: "post",
+  ...variables,
+  signal
+});
 const operationsByTag$2 = {
-  database: {
-    dEPRECATEDgetDatabaseList,
-    dEPRECATEDcreateDatabase,
-    dEPRECATEDdeleteDatabase,
-    dEPRECATEDgetDatabaseMetadata,
-    dEPRECATEDupdateDatabaseMetadata
-  },
   branch: {
+    applyMigration,
+    pgRollStatus,
+    pgRollJobStatus,
+    pgRollMigrationHistory,
     getBranchList,
     getBranchDetails,
     createBranch,
     deleteBranch,
+    copyBranch,
     updateBranchMetadata,
     getBranchMetadata,
     getBranchStats,
@@ -516,6 +1099,7 @@ const operationsByTag$2 = {
     resolveBranch
   },
   migrations: {
+    getSchema,
     getBranchMigrationHistory,
     getBranchMigrationPlan,
     executeBranchMigrationPlan,
@@ -524,17 +1108,8 @@ const operationsByTag$2 = {
     compareBranchSchemas,
     updateBranchSchema,
     previewBranchSchemaEdit,
-    applyBranchSchemaEdit
-  },
-  records: {
-    branchTransaction,
-    insertRecord,
-    getRecord,
-    insertRecordWithID,
-    updateRecordWithID,
-    upsertRecordWithID,
-    deleteRecord,
-    bulkInsertTableRecords
+    applyBranchSchemaEdit,
+    pushBranchMigrations
   },
   migrationRequests: {
     queryMigrationRequests,
@@ -558,11 +1133,34 @@ const operationsByTag$2 = {
     updateColumn,
     deleteColumn
   },
-  searchAndFilter: { queryTable, searchBranch, searchTable, summarizeTable, aggregateTable }
+  records: {
+    branchTransaction,
+    insertRecord,
+    getRecord,
+    insertRecordWithID,
+    updateRecordWithID,
+    upsertRecordWithID,
+    deleteRecord,
+    bulkInsertTableRecords
+  },
+  files: { getFileItem, putFileItem, deleteFileItem, getFile, putFile, deleteFile, fileAccess, fileUpload },
+  searchAndFilter: {
+    queryTable,
+    searchBranch,
+    searchTable,
+    vectorSearchTable,
+    askTable,
+    askTableSession,
+    summarizeTable,
+    aggregateTable
+  },
+  sql: { sqlQuery }
 };
 
 const controlPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "controlPlane" });
 
+const getAuthorizationCode = (variables, signal) => controlPlaneFetch({ url: "/oauth/authorize", method: "get", ...variables, signal });
+const grantAuthorizationCode = (variables, signal) => controlPlaneFetch({ url: "/oauth/authorize", method: "post", ...variables, signal });
 const getUser = (variables, signal) => controlPlaneFetch({
   url: "/user",
   method: "get",
@@ -587,18 +1185,43 @@ const getUserAPIKeys = (variables, signal) => controlPlaneFetch({
   ...variables,
   signal
 });
-const createUserAPIKey = (variables, signal) => controlPlaneFetch({
-  url: "/user/keys/{keyName}",
-  method: "post",
+const createUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "post",
+  ...variables,
+  signal
+});
+const deleteUserAPIKey = (variables, signal) => controlPlaneFetch({
+  url: "/user/keys/{keyName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getUserOAuthClients = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/clients",
+  method: "get",
+  ...variables,
+  signal
+});
+const deleteUserOAuthClient = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/clients/{clientId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const getUserOAuthAccessTokens = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/tokens",
+  method: "get",
   ...variables,
   signal
 });
-const deleteUserAPIKey = (variables, signal) => controlPlaneFetch({
-  url: "/user/keys/{keyName}",
+const deleteOAuthAccessToken = (variables, signal) => controlPlaneFetch({
+  url: "/user/oauth/tokens/{token}",
   method: "delete",
   ...variables,
   signal
 });
+const updateOAuthAccessToken = (variables, signal) => controlPlaneFetch({ url: "/user/oauth/tokens/{token}", method: "patch", ...variables, signal });
 const getWorkspacesList = (variables, signal) => controlPlaneFetch({
   url: "/workspaces",
   method: "get",
@@ -642,6 +1265,15 @@ const updateWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ u
 const cancelWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "delete", ...variables, signal });
 const acceptWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept", method: "post", ...variables, signal });
 const resendWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}/resend", method: "post", ...variables, signal });
+const listClusters = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "get", ...variables, signal });
+const createCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "post", ...variables, signal });
+const getCluster = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/clusters/{clusterId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters/{clusterId}", method: "patch", ...variables, signal });
 const getDatabaseList = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/dbs",
   method: "get",
@@ -657,6 +1289,10 @@ const deleteDatabase = (variables, signal) => controlPlaneFetch({
 });
 const getDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "get", ...variables, signal });
 const updateDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "patch", ...variables, signal });
+const renameDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/rename", method: "post", ...variables, signal });
+const getDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "get", ...variables, signal });
+const updateDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "put", ...variables, signal });
+const deleteDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "delete", ...variables, signal });
 const listRegions = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/regions",
   method: "get",
@@ -664,6 +1300,15 @@ const listRegions = (variables, signal) => controlPlaneFetch({
   signal
 });
 const operationsByTag$1 = {
+  oAuth: {
+    getAuthorizationCode,
+    grantAuthorizationCode,
+    getUserOAuthClients,
+    deleteUserOAuthClient,
+    getUserOAuthAccessTokens,
+    deleteOAuthAccessToken,
+    updateOAuthAccessToken
+  },
   users: { getUser, updateUser, deleteUser },
   authentication: { getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
   workspaces: {
@@ -683,62 +1328,23 @@ const operationsByTag$1 = {
     acceptWorkspaceMemberInvite,
     resendWorkspaceMemberInvite
   },
+  xbcontrolOther: { listClusters, createCluster, getCluster, updateCluster },
   databases: {
     getDatabaseList,
     createDatabase,
     deleteDatabase,
     getDatabaseMetadata,
     updateDatabaseMetadata,
+    renameDatabase,
+    getDatabaseGithubSettings,
+    updateDatabaseGithubSettings,
+    deleteDatabaseGithubSettings,
     listRegions
   }
 };
 
 const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
 
-function getHostUrl(provider, type) {
-  if (isHostProviderAlias(provider)) {
-    return providers[provider][type];
-  } else if (isHostProviderBuilder(provider)) {
-    return provider[type];
-  }
-  throw new Error("Invalid API provider");
-}
-const providers = {
-  production: {
-    main: "https://api.xata.io",
-    workspaces: "https://{workspaceId}.{region}.xata.sh"
-  },
-  staging: {
-    main: "https://staging.xatabase.co",
-    workspaces: "https://{workspaceId}.staging.{region}.xatabase.co"
-  }
-};
-function isHostProviderAlias(alias) {
-  return isString(alias) && Object.keys(providers).includes(alias);
-}
-function isHostProviderBuilder(builder) {
-  return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
-}
-function parseProviderString(provider = "production") {
-  if (isHostProviderAlias(provider)) {
-    return provider;
-  }
-  const [main, workspaces] = provider.split(",");
-  if (!main || !workspaces)
-    return null;
-  return { main, workspaces };
-}
-function parseWorkspacesUrlParts(url) {
-  if (!isString(url))
-    return null;
-  const regex = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))?\.xata\.sh.*/;
-  const regexStaging = /(?:https:\/\/)?([^.]+)\.staging(?:\.([^.]+))?\.xatabase\.co.*/;
-  const match = url.match(regex) || url.match(regexStaging);
-  if (!match)
-    return null;
-  return { workspace: match[1], region: match[2] ?? "eu-west-1" };
-}
-
 var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -765,15 +1371,19 @@ class XataApiClient {
     const provider = options.host ?? "production";
     const apiKey = options.apiKey ?? getAPIKey();
     const trace = options.trace ?? defaultTrace;
+    const clientID = generateUUID();
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
     __privateSet$7(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
-      fetchImpl: getFetchImplementation(options.fetch),
+      fetch: getFetchImplementation(options.fetch),
       apiKey,
-      trace
+      trace,
+      clientName: options.clientName,
+      xataAgentExtra: options.xataAgentExtra,
+      clientID
     });
   }
   get user() {
@@ -826,6 +1436,11 @@ class XataApiClient {
       __privateGet$7(this, _namespaces).records = new RecordsApi(__privateGet$7(this, _extraProps));
     return __privateGet$7(this, _namespaces).records;
   }
+  get files() {
+    if (!__privateGet$7(this, _namespaces).files)
+      __privateGet$7(this, _namespaces).files = new FilesApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).files;
+  }
   get searchAndFilter() {
     if (!__privateGet$7(this, _namespaces).searchAndFilter)
       __privateGet$7(this, _namespaces).searchAndFilter = new SearchAndFilterApi(__privateGet$7(this, _extraProps));
@@ -1034,6 +1649,20 @@ class BranchApi {
       ...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,
@@ -1389,6 +2018,164 @@ class RecordsApi {
     });
   }
 }
+class FilesApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
+  getFileItem({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    column,
+    fileId
+  }) {
+    return operationsByTag.files.getFileItem({
+      pathParams: {
+        workspace,
+        region,
+        dbBranchName: `${database}:${branch}`,
+        tableName: table,
+        recordId: record,
+        columnName: column,
+        fileId
+      },
+      ...this.extraProps
+    });
+  }
+  putFileItem({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    column,
+    fileId,
+    file
+  }) {
+    return operationsByTag.files.putFileItem({
+      pathParams: {
+        workspace,
+        region,
+        dbBranchName: `${database}:${branch}`,
+        tableName: table,
+        recordId: record,
+        columnName: column,
+        fileId
+      },
+      // @ts-ignore
+      body: file,
+      ...this.extraProps
+    });
+  }
+  deleteFileItem({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    column,
+    fileId
+  }) {
+    return operationsByTag.files.deleteFileItem({
+      pathParams: {
+        workspace,
+        region,
+        dbBranchName: `${database}:${branch}`,
+        tableName: table,
+        recordId: record,
+        columnName: column,
+        fileId
+      },
+      ...this.extraProps
+    });
+  }
+  getFile({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    column
+  }) {
+    return operationsByTag.files.getFile({
+      pathParams: {
+        workspace,
+        region,
+        dbBranchName: `${database}:${branch}`,
+        tableName: table,
+        recordId: record,
+        columnName: column
+      },
+      ...this.extraProps
+    });
+  }
+  putFile({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    column,
+    file
+  }) {
+    return operationsByTag.files.putFile({
+      pathParams: {
+        workspace,
+        region,
+        dbBranchName: `${database}:${branch}`,
+        tableName: table,
+        recordId: record,
+        columnName: column
+      },
+      body: file,
+      ...this.extraProps
+    });
+  }
+  deleteFile({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    record,
+    column
+  }) {
+    return operationsByTag.files.deleteFile({
+      pathParams: {
+        workspace,
+        region,
+        dbBranchName: `${database}:${branch}`,
+        tableName: table,
+        recordId: record,
+        columnName: column
+      },
+      ...this.extraProps
+    });
+  }
+  fileAccess({
+    workspace,
+    region,
+    fileId,
+    verify
+  }) {
+    return operationsByTag.files.fileAccess({
+      pathParams: {
+        workspace,
+        region,
+        fileId
+      },
+      queryParams: { verify },
+      ...this.extraProps
+    });
+  }
+}
 class SearchAndFilterApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
@@ -1448,6 +2235,53 @@ class SearchAndFilterApi {
       ...this.extraProps
     });
   }
+  vectorSearchTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    queryVector,
+    column,
+    similarityFunction,
+    size,
+    filter
+  }) {
+    return operationsByTag.searchAndFilter.vectorSearchTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: { queryVector, column, similarityFunction, size, filter },
+      ...this.extraProps
+    });
+  }
+  askTable({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    options
+  }) {
+    return operationsByTag.searchAndFilter.askTable({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table },
+      body: { ...options },
+      ...this.extraProps
+    });
+  }
+  askTableSession({
+    workspace,
+    region,
+    database,
+    branch,
+    table,
+    sessionId,
+    message
+  }) {
+    return operationsByTag.searchAndFilter.askTableSession({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, tableName: table, sessionId },
+      body: { message },
+      ...this.extraProps
+    });
+  }
   summarizeTable({
     workspace,
     region,
@@ -1648,11 +2482,13 @@ class MigrationsApi {
     region,
     database,
     branch,
-    schema
+    schema,
+    schemaOperations,
+    branchOperations
   }) {
     return operationsByTag.migrations.compareBranchWithUserSchema({
       pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { schema },
+      body: { schema, schemaOperations, branchOperations },
       ...this.extraProps
     });
   }
@@ -1662,11 +2498,12 @@ class MigrationsApi {
     database,
     branch,
     compare,
-    schema
+    sourceBranchOperations,
+    targetBranchOperations
   }) {
     return operationsByTag.migrations.compareBranchSchemas({
       pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, branchName: compare },
-      body: { schema },
+      body: { sourceBranchOperations, targetBranchOperations },
       ...this.extraProps
     });
   }
@@ -1709,6 +2546,19 @@ class MigrationsApi {
       ...this.extraProps
     });
   }
+  pushBranchMigrations({
+    workspace,
+    region,
+    database,
+    branch,
+    migrations
+  }) {
+    return operationsByTag.migrations.pushBranchMigrations({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { migrations },
+      ...this.extraProps
+    });
+  }
 }
 class DatabaseApi {
   constructor(extraProps) {
@@ -1723,11 +2573,13 @@ class DatabaseApi {
   createDatabase({
     workspace,
     database,
-    data
+    data,
+    headers
   }) {
     return operationsByTag.databases.createDatabase({
       pathParams: { workspaceId: workspace, dbName: database },
       body: data,
+      headers,
       ...this.extraProps
     });
   }
@@ -1760,36 +2612,252 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
-  listRegions({ workspace }) {
-    return operationsByTag.databases.listRegions({
-      pathParams: { workspaceId: workspace },
-      ...this.extraProps
-    });
+  renameDatabase({
+    workspace,
+    database,
+    newName
+  }) {
+    return operationsByTag.databases.renameDatabase({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: { newName },
+      ...this.extraProps
+    });
+  }
+  getDatabaseGithubSettings({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.getDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      ...this.extraProps
+    });
+  }
+  updateDatabaseGithubSettings({
+    workspace,
+    database,
+    settings
+  }) {
+    return operationsByTag.databases.updateDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: settings,
+      ...this.extraProps
+    });
+  }
+  deleteDatabaseGithubSettings({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.deleteDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      ...this.extraProps
+    });
+  }
+  listRegions({ workspace }) {
+    return operationsByTag.databases.listRegions({
+      pathParams: { workspaceId: workspace },
+      ...this.extraProps
+    });
+  }
+}
+
+class XataApiPlugin {
+  build(options) {
+    return new XataApiClient(options);
+  }
+}
+
+class XataPlugin {
+}
+
+function buildTransformString(transformations) {
+  return transformations.flatMap(
+    (t) => Object.entries(t).map(([key, value]) => {
+      if (key === "trim") {
+        const { left = 0, top = 0, right = 0, bottom = 0 } = value;
+        return `${key}=${[top, right, bottom, left].join(";")}`;
+      }
+      if (key === "gravity" && typeof value === "object") {
+        const { x = 0.5, y = 0.5 } = value;
+        return `${key}=${[x, y].join("x")}`;
+      }
+      return `${key}=${value}`;
+    })
+  ).join(",");
+}
+function transformImage(url, ...transformations) {
+  if (!isDefined(url))
+    return void 0;
+  const newTransformations = buildTransformString(transformations);
+  const { hostname, pathname, search } = new URL(url);
+  const pathParts = pathname.split("/");
+  const transformIndex = pathParts.findIndex((part) => part === "transform");
+  const removedItems = transformIndex >= 0 ? pathParts.splice(transformIndex, 2) : [];
+  const transform = `/transform/${[removedItems[1], newTransformations].filter(isDefined).join(",")}`;
+  const path = pathParts.join("/");
+  return `https://${hostname}${transform}${path}${search}`;
+}
+
+class XataFile {
+  constructor(file) {
+    this.id = file.id;
+    this.name = file.name;
+    this.mediaType = file.mediaType;
+    this.base64Content = file.base64Content;
+    this.enablePublicUrl = file.enablePublicUrl;
+    this.signedUrlTimeout = file.signedUrlTimeout;
+    this.uploadUrlTimeout = file.uploadUrlTimeout;
+    this.size = file.size;
+    this.version = file.version;
+    this.url = file.url;
+    this.signedUrl = file.signedUrl;
+    this.uploadUrl = file.uploadUrl;
+    this.attributes = file.attributes;
+  }
+  static fromBuffer(buffer, options = {}) {
+    const base64Content = buffer.toString("base64");
+    return new XataFile({ ...options, base64Content });
+  }
+  toBuffer() {
+    if (!this.base64Content) {
+      throw new Error(`File content is not available, please select property "base64Content" when querying the file`);
+    }
+    return Buffer.from(this.base64Content, "base64");
+  }
+  static fromArrayBuffer(arrayBuffer, options = {}) {
+    const uint8Array = new Uint8Array(arrayBuffer);
+    return this.fromUint8Array(uint8Array, options);
+  }
+  toArrayBuffer() {
+    if (!this.base64Content) {
+      throw new Error(`File content is not available, please select property "base64Content" when querying the file`);
+    }
+    const binary = atob(this.base64Content);
+    return new ArrayBuffer(binary.length);
+  }
+  static fromUint8Array(uint8Array, options = {}) {
+    let binary = "";
+    for (let i = 0; i < uint8Array.byteLength; i++) {
+      binary += String.fromCharCode(uint8Array[i]);
+    }
+    const base64Content = btoa(binary);
+    return new XataFile({ ...options, base64Content });
+  }
+  toUint8Array() {
+    if (!this.base64Content) {
+      throw new Error(`File content is not available, please select property "base64Content" when querying the file`);
+    }
+    const binary = atob(this.base64Content);
+    const uint8Array = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      uint8Array[i] = binary.charCodeAt(i);
+    }
+    return uint8Array;
+  }
+  static async fromBlob(file, options = {}) {
+    const name = options.name ?? file.name;
+    const mediaType = file.type;
+    const arrayBuffer = await file.arrayBuffer();
+    return this.fromArrayBuffer(arrayBuffer, { ...options, name, mediaType });
+  }
+  toBlob() {
+    if (!this.base64Content) {
+      throw new Error(`File content is not available, please select property "base64Content" when querying the file`);
+    }
+    const binary = atob(this.base64Content);
+    const uint8Array = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      uint8Array[i] = binary.charCodeAt(i);
+    }
+    return new Blob([uint8Array], { type: this.mediaType });
+  }
+  static fromString(string, options = {}) {
+    const base64Content = btoa(string);
+    return new XataFile({ ...options, base64Content });
   }
-}
-
-class XataApiPlugin {
-  async build(options) {
-    const { fetchImpl, apiKey } = await options.getFetchProps();
-    return new XataApiClient({ fetch: fetchImpl, apiKey });
+  toString() {
+    if (!this.base64Content) {
+      throw new Error(`File content is not available, please select property "base64Content" when querying the file`);
+    }
+    return atob(this.base64Content);
+  }
+  static fromBase64(base64Content, options = {}) {
+    return new XataFile({ ...options, base64Content });
+  }
+  toBase64() {
+    if (!this.base64Content) {
+      throw new Error(`File content is not available, please select property "base64Content" when querying the file`);
+    }
+    return this.base64Content;
+  }
+  transform(...options) {
+    return {
+      url: transformImage(this.url, ...options),
+      signedUrl: transformImage(this.signedUrl, ...options),
+      metadataUrl: transformImage(this.url, ...options, { format: "json" }),
+      metadataSignedUrl: transformImage(this.signedUrl, ...options, { format: "json" })
+    };
   }
 }
-
-class XataPlugin {
-}
-
-function generateUUID() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
-    return v.toString(16);
+const parseInputFileEntry = async (entry) => {
+  if (!isDefined(entry))
+    return null;
+  const { id, name, mediaType, base64Content, enablePublicUrl, signedUrlTimeout, uploadUrlTimeout } = await entry;
+  return compactObject({
+    id,
+    // Name cannot be an empty string in our API
+    name: name ? name : void 0,
+    mediaType,
+    base64Content,
+    enablePublicUrl,
+    signedUrlTimeout,
+    uploadUrlTimeout
   });
-}
+};
 
 function cleanFilter(filter) {
-  if (!filter)
+  if (!isDefined(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;
+  if (!isObject(filter))
+    return filter;
+  const values = Object.fromEntries(
+    Object.entries(filter).reduce((acc, [key, value]) => {
+      if (!isDefined(value))
+        return acc;
+      if (Array.isArray(value)) {
+        const clean = value.map((item) => cleanFilter(item)).filter((item) => isDefined(item));
+        if (clean.length === 0)
+          return acc;
+        return [...acc, [key, clean]];
+      }
+      if (isObject(value)) {
+        const clean = cleanFilter(value);
+        if (!isDefined(clean))
+          return acc;
+        return [...acc, [key, clean]];
+      }
+      return [...acc, [key, value]];
+    }, [])
+  );
+  return Object.keys(values).length > 0 ? values : void 0;
+}
+
+function stringifyJson(value) {
+  if (!isDefined(value))
+    return value;
+  if (isString(value))
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return value;
+  }
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return value;
+  }
 }
 
 var __accessCheck$6 = (obj, member, msg) => {
@@ -1818,31 +2886,59 @@ class Page {
     this.meta = meta;
     this.records = new RecordArray(this, records);
   }
+  /**
+   * Retrieves the next page of results.
+   * @param size Maximum number of results to be retrieved.
+   * @param offset Number of results to skip when retrieving the results.
+   * @returns The next page or results.
+   */
   async nextPage(size, offset) {
     return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, after: this.meta.page.cursor } });
   }
+  /**
+   * Retrieves the previous page of results.
+   * @param size Maximum number of results to be retrieved.
+   * @param offset Number of results to skip when retrieving the results.
+   * @returns The previous page or results.
+   */
   async previousPage(size, offset) {
     return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, before: this.meta.page.cursor } });
   }
+  /**
+   * Retrieves the start page of results.
+   * @param size Maximum number of results to be retrieved.
+   * @param offset Number of results to skip when retrieving the results.
+   * @returns The start page or results.
+   */
   async startPage(size, offset) {
     return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, start: this.meta.page.cursor } });
   }
+  /**
+   * Retrieves the end page of results.
+   * @param size Maximum number of results to be retrieved.
+   * @param offset Number of results to skip when retrieving the results.
+   * @returns The end page or results.
+   */
   async endPage(size, offset) {
     return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, end: this.meta.page.cursor } });
   }
+  /**
+   * Shortcut method to check if there will be additional results if the next page of results is retrieved.
+   * @returns Whether or not there will be additional results in the next page of results.
+   */
   hasNextPage() {
     return this.meta.page.more;
   }
 }
 _query = new WeakMap();
-const PAGINATION_MAX_SIZE = 200;
+const PAGINATION_MAX_SIZE = 1e3;
 const PAGINATION_DEFAULT_SIZE = 20;
-const PAGINATION_MAX_OFFSET = 800;
+const PAGINATION_MAX_OFFSET = 49e3;
 const PAGINATION_DEFAULT_OFFSET = 0;
 function isCursorPaginationOptions(options) {
   return isDefined(options) && (isDefined(options.start) || isDefined(options.end) || isDefined(options.after) || isDefined(options.before));
 }
-const _RecordArray = class extends Array {
+const _RecordArray = class _RecordArray extends Array {
   constructor(...args) {
     super(..._RecordArray.parseConstructorParams(...args));
     __privateAdd$6(this, _page, void 0);
@@ -1861,31 +2957,60 @@ 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);
   }
+  /**
+   * Retrieve next page of records
+   *
+   * @returns A new array of objects
+   */
   async nextPage(size, offset) {
     const newPage = await __privateGet$6(this, _page).nextPage(size, offset);
     return new _RecordArray(newPage);
   }
+  /**
+   * Retrieve previous page of records
+   *
+   * @returns A new array of objects
+   */
   async previousPage(size, offset) {
     const newPage = await __privateGet$6(this, _page).previousPage(size, offset);
     return new _RecordArray(newPage);
   }
+  /**
+   * Retrieve start page of records
+   *
+   * @returns A new array of objects
+   */
   async startPage(size, offset) {
     const newPage = await __privateGet$6(this, _page).startPage(size, offset);
     return new _RecordArray(newPage);
   }
+  /**
+   * Retrieve end page of records
+   *
+   * @returns A new array of objects
+   */
   async endPage(size, offset) {
     const newPage = await __privateGet$6(this, _page).endPage(size, offset);
     return new _RecordArray(newPage);
   }
+  /**
+   * @returns Boolean indicating if there is a next page
+   */
   hasNextPage() {
     return __privateGet$6(this, _page).meta.page.more;
   }
 };
-let RecordArray = _RecordArray;
 _page = new WeakMap();
+let RecordArray = _RecordArray;
 
 var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -1910,13 +3035,14 @@ var __privateMethod$3 = (obj, member, method) => {
   return method;
 };
 var _table$1, _repository, _data, _cleanFilterConstraint, cleanFilterConstraint_fn;
-const _Query = class {
+const _Query = class _Query {
   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: {} });
-    this.meta = { page: { cursor: "start", more: true } };
+    // Implements pagination
+    this.meta = { page: { cursor: "start", more: true, size: PAGINATION_DEFAULT_SIZE } };
     this.records = new RecordArray(this, []);
     __privateSet$5(this, _table$1, table);
     if (repository) {
@@ -1932,6 +3058,7 @@ const _Query = class {
     __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).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;
@@ -1952,18 +3079,38 @@ const _Query = class {
     const key = JSON.stringify({ columns, filter, sort, pagination });
     return toBase64(key);
   }
+  /**
+   * Builds a new query object representing a logical OR between the given subqueries.
+   * @param queries An array of subqueries.
+   * @returns A new Query object.
+   */
   any(...queries) {
     const $any = queries.map((query) => query.getQueryOptions().filter ?? {});
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $any } }, __privateGet$5(this, _data));
   }
+  /**
+   * Builds a new query object representing a logical AND between the given subqueries.
+   * @param queries An array of subqueries.
+   * @returns A new Query object.
+   */
   all(...queries) {
     const $all = queries.map((query) => query.getQueryOptions().filter ?? {});
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
   }
+  /**
+   * Builds a new query object representing a logical OR negating each subquery. In pseudo-code: !q1 OR !q2
+   * @param queries An array of subqueries.
+   * @returns A new Query object.
+   */
   not(...queries) {
     const $not = queries.map((query) => query.getQueryOptions().filter ?? {});
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $not } }, __privateGet$5(this, _data));
   }
+  /**
+   * Builds a new query object representing a logical AND negating each subquery. In pseudo-code: !q1 AND !q2
+   * @param queries An array of subqueries.
+   * @returns A new Query object.
+   */
   none(...queries) {
     const $none = queries.map((query) => query.getQueryOptions().filter ?? {});
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $none } }, __privateGet$5(this, _data));
@@ -1986,6 +3133,11 @@ const _Query = class {
     const sort = [...originalSort, { column, direction }];
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { sort }, __privateGet$5(this, _data));
   }
+  /**
+   * Builds a new query specifying the set of columns to be returned in the query response.
+   * @param columns Array of column names to be returned by the query.
+   * @returns A new Query object.
+   */
   select(columns) {
     return new _Query(
       __privateGet$5(this, _repository),
@@ -1998,6 +3150,12 @@ const _Query = class {
     const query = new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), options, __privateGet$5(this, _data));
     return __privateGet$5(this, _repository).query(query);
   }
+  /**
+   * Get results in an iterator
+   *
+   * @async
+   * @returns Async interable of results
+   */
   async *[Symbol.asyncIterator]() {
     for await (const [record] of this.getIterator({ batchSize: 1 })) {
       yield record;
@@ -2058,26 +3216,53 @@ const _Query = class {
     );
     return __privateGet$5(this, _repository).summarizeTable(query, summaries, summariesFilter);
   }
+  /**
+   * Builds a new query object adding a cache TTL in milliseconds.
+   * @param ttl The cache TTL in milliseconds.
+   * @returns A new Query object.
+   */
   cache(ttl) {
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { cache: ttl }, __privateGet$5(this, _data));
   }
+  /**
+   * Retrieve next page of records
+   *
+   * @returns A new page object.
+   */
   nextPage(size, offset) {
     return this.startPage(size, offset);
   }
+  /**
+   * Retrieve previous page of records
+   *
+   * @returns A new page object
+   */
   previousPage(size, offset) {
     return this.startPage(size, offset);
   }
+  /**
+   * Retrieve start page of records
+   *
+   * @returns A new page object
+   */
   startPage(size, offset) {
     return this.getPaginated({ pagination: { size, offset } });
   }
+  /**
+   * Retrieve last page of records
+   *
+   * @returns A new page object
+   */
   endPage(size, offset) {
     return this.getPaginated({ pagination: { size, offset, before: "end" } });
   }
+  /**
+   * @returns Boolean indicating if there is a next page
+   */
   hasNextPage() {
     return this.meta.page.more;
   }
 };
-let Query = _Query;
 _table$1 = new WeakMap();
 _repository = new WeakMap();
 _data = new WeakMap();
@@ -2092,6 +3277,7 @@ cleanFilterConstraint_fn = function(column, value) {
   }
   return value;
 };
+let Query = _Query;
 function cleanParent(data, parent) {
   if (isCursorPaginationOptions(data.pagination)) {
     return { ...parent, sort: void 0, filter: void 0 };
@@ -2099,6 +3285,21 @@ function cleanParent(data, parent) {
   return parent;
 }
 
+const RecordColumnTypes = [
+  "bool",
+  "int",
+  "float",
+  "string",
+  "text",
+  "email",
+  "multiple",
+  "link",
+  "datetime",
+  "vector",
+  "file[]",
+  "file",
+  "json"
+];
 function isIdentifiable(x) {
   return isObject(x) && isString(x?.id);
 }
@@ -2108,11 +3309,33 @@ function isXataRecord(x) {
   return isIdentifiable(x) && isObject(metadata) && typeof metadata.version === "number";
 }
 
+function isValidExpandedColumn(column) {
+  return isObject(column) && isString(column.name);
+}
+function isValidSelectableColumns(columns) {
+  if (!Array.isArray(columns)) {
+    return false;
+  }
+  return columns.every((column) => {
+    if (typeof column === "string") {
+      return true;
+    }
+    if (typeof column === "object") {
+      return isValidExpandedColumn(column);
+    }
+    return false;
+  });
+}
+
 function isSortFilterString(value) {
   return isString(value);
 }
 function isSortFilterBase(filter) {
-  return isObject(filter) && Object.values(filter).every((value) => value === "asc" || value === "desc");
+  return isObject(filter) && Object.entries(filter).every(([key, value]) => {
+    if (key === "*")
+      return value === "random";
+    return value === "asc" || value === "desc";
+  });
 }
 function isSortFilterObject(filter) {
   return isObject(filter) && !isSortFilterBase(filter) && filter.column !== void 0;
@@ -2153,7 +3376,7 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-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;
+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, _transformObjectToApi, transformObjectToApi_fn;
 const BULK_OPERATION_MAX_SIZE = 1e3;
 class Repository extends Query {
 }
@@ -2175,6 +3398,7 @@ class RestRepository extends Query {
     __privateAdd$4(this, _setCacheQuery);
     __privateAdd$4(this, _getCacheQuery);
     __privateAdd$4(this, _getSchemaTables$1);
+    __privateAdd$4(this, _transformObjectToApi);
     __privateAdd$4(this, _table, void 0);
     __privateAdd$4(this, _getFetchProps, void 0);
     __privateAdd$4(this, _db, void 0);
@@ -2185,10 +3409,7 @@ class RestRepository extends Query {
     __privateSet$4(this, _db, options.db);
     __privateSet$4(this, _cache, options.pluginOptions.cache);
     __privateSet$4(this, _schemaTables$2, options.schemaTables);
-    __privateSet$4(this, _getFetchProps, async () => {
-      const props = await options.pluginOptions.getFetchProps();
-      return { ...props, sessionID: generateUUID() };
-    });
+    __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, {
@@ -2206,24 +3427,24 @@ class RestRepository extends Query {
         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 columns = isValidSelectableColumns(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;
+        const columns = isValidSelectableColumns(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;
+        const columns = isValidSelectableColumns(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;
+        const columns = isValidSelectableColumns(b) ? b : void 0;
         return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a, columns);
       }
       throw new Error("Invalid arguments for create method");
@@ -2231,7 +3452,7 @@ class RestRepository extends Query {
   }
   async read(a, b) {
     return __privateGet$4(this, _trace).call(this, "read", async () => {
-      const columns = isStringArray(b) ? b : ["*"];
+      const columns = isValidSelectableColumns(b) ? b : ["*"];
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
@@ -2245,7 +3466,6 @@ class RestRepository extends Query {
       }
       const id = extractId(a);
       if (id) {
-        const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
         try {
           const response = await getRecord({
             pathParams: {
@@ -2256,10 +3476,16 @@ class RestRepository extends Query {
               recordId: id
             },
             queryParams: { columns },
-            ...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, columns);
+          return initObject(
+            __privateGet$4(this, _db),
+            schemaTables,
+            __privateGet$4(this, _table),
+            response,
+            columns
+          );
         } catch (e) {
           if (isObject(e) && e.status === 404) {
             return null;
@@ -2301,17 +3527,23 @@ class RestRepository extends Query {
           ifVersion,
           upsert: false
         });
-        const columns = isStringArray(b) ? b : ["*"];
+        const columns = isValidSelectableColumns(b) ? b : ["*"];
         const result = await this.read(a, columns);
         return result;
       }
-      if (isString(a) && isObject(b)) {
-        const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b, columns, { ifVersion });
-      }
-      if (isObject(a) && isString(a.id)) {
-        const columns = isStringArray(b) ? b : void 0;
-        return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns, { ifVersion });
+      try {
+        if (isString(a) && isObject(b)) {
+          const columns = isValidSelectableColumns(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 = isValidSelectableColumns(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");
     });
@@ -2345,17 +3577,27 @@ class RestRepository extends Query {
           ifVersion,
           upsert: true
         });
-        const columns = isStringArray(b) ? b : ["*"];
+        const columns = isValidSelectableColumns(b) ? b : ["*"];
         const result = await this.read(a, columns);
         return result;
       }
       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 });
+        if (a === "")
+          throw new Error("The id can't be empty");
+        const columns = isValidSelectableColumns(c) ? c : void 0;
+        return await __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b, columns, { ifVersion });
       }
       if (isObject(a) && isString(a.id)) {
-        const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns, { ifVersion });
+        if (a.id === "")
+          throw new Error("The id can't be empty");
+        const columns = isValidSelectableColumns(c) ? c : void 0;
+        return await __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns, { ifVersion });
+      }
+      if (!isDefined(a) && isObject(b)) {
+        return await this.create(b, c);
+      }
+      if (isObject(a) && !isDefined(a.id)) {
+        return await this.create(a, b);
       }
       throw new Error("Invalid arguments for createOrUpdate method");
     });
@@ -2367,17 +3609,27 @@ class RestRepository extends Query {
         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 columns = isValidSelectableColumns(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 (a === "")
+          throw new Error("The id can't be empty");
+        const columns = isValidSelectableColumns(c) ? c : void 0;
+        return await __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 });
+        if (a.id === "")
+          throw new Error("The id can't be empty");
+        const columns = isValidSelectableColumns(c) ? c : void 0;
+        return await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns, { createOnly: false, ifVersion });
+      }
+      if (!isDefined(a) && isObject(b)) {
+        return await this.create(b, c);
+      }
+      if (isObject(a) && !isDefined(a.id)) {
+        return await this.create(a, b);
       }
       throw new Error("Invalid arguments for createOrReplace method");
     });
@@ -2394,7 +3646,7 @@ class RestRepository extends Query {
             return o.id;
           throw new Error("Invalid arguments for delete method");
         });
-        const columns = isStringArray(b) ? b : ["*"];
+        const columns = isValidSelectableColumns(b) ? b : ["*"];
         const result = await this.read(a, columns);
         await __privateMethod$2(this, _deleteRecords, deleteRecords_fn).call(this, ids);
         return result;
@@ -2428,8 +3680,7 @@ class RestRepository extends Query {
   }
   async search(query, options = {}) {
     return __privateGet$4(this, _trace).call(this, "search", async () => {
-      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-      const { records } = await searchTable({
+      const { records, totalCount } = await searchTable({
         pathParams: {
           workspace: "{workspaceId}",
           dbBranchName: "{dbBranch}",
@@ -2442,17 +3693,46 @@ class RestRepository extends Query {
           prefix: options.prefix,
           highlight: options.highlight,
           filter: options.filter,
-          boosters: options.boosters
+          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: records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"])),
+        totalCount
+      };
+    });
+  }
+  async vectorSearch(column, query, options) {
+    return __privateGet$4(this, _trace).call(this, "vectorSearch", async () => {
+      const { records, totalCount } = await vectorSearchTable({
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
         },
-        ...fetchProps
+        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, ["*"]));
+      return {
+        records: records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"])),
+        totalCount
+      };
     });
   }
   async aggregate(aggs, filter) {
     return __privateGet$4(this, _trace).call(this, "aggregate", async () => {
-      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const result = await aggregateTable({
         pathParams: {
           workspace: "{workspaceId}",
@@ -2461,7 +3741,7 @@ class RestRepository extends Query {
           tableName: __privateGet$4(this, _table)
         },
         body: { aggs, filter },
-        ...fetchProps
+        ...__privateGet$4(this, _getFetchProps).call(this)
       });
       return result;
     });
@@ -2472,7 +3752,6 @@ class RestRepository extends Query {
       if (cacheQuery)
         return new Page(query, cacheQuery.meta, cacheQuery.records);
       const data = query.getQueryOptions();
-      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const { meta, records: objects } = await queryTable({
         pathParams: {
           workspace: "{workspaceId}",
@@ -2484,14 +3763,21 @@ class RestRepository extends Query {
           filter: cleanFilter(data.filter),
           sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
           page: data.pagination,
-          columns: data.columns ?? ["*"]
+          columns: data.columns ?? ["*"],
+          consistency: data.consistency
         },
         fetchOptions: data.fetchOptions,
-        ...fetchProps
+        ...__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 ?? ["*"])
+        (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);
@@ -2500,7 +3786,6 @@ class RestRepository extends Query {
   async summarizeTable(query, summaries, summariesFilter) {
     return __privateGet$4(this, _trace).call(this, "summarize", async () => {
       const data = query.getQueryOptions();
-      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       const result = await summarizeTable({
         pathParams: {
           workspace: "{workspaceId}",
@@ -2512,15 +3797,55 @@ class RestRepository extends Query {
           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
         },
-        ...fetchProps
+        ...__privateGet$4(this, _getFetchProps).call(this)
       });
-      return result;
+      const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+      return {
+        ...result,
+        summaries: result.summaries.map(
+          (summary) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), summary, data.columns ?? [])
+        )
+      };
     });
   }
+  ask(question, options) {
+    const questionParam = options?.sessionId ? { message: question } : { question };
+    const params = {
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}",
+        tableName: __privateGet$4(this, _table),
+        sessionId: options?.sessionId
+      },
+      body: {
+        ...questionParam,
+        rules: options?.rules,
+        searchType: options?.searchType,
+        search: options?.searchType === "keyword" ? options?.search : void 0,
+        vectorSearch: options?.searchType === "vector" ? options?.vectorSearch : void 0
+      },
+      ...__privateGet$4(this, _getFetchProps).call(this)
+    };
+    if (options?.onMessage) {
+      fetchSSERequest({
+        endpoint: "dataPlane",
+        url: "/db/{dbBranchName}/tables/{tableName}/ask/{sessionId}",
+        method: "POST",
+        onMessage: (message) => {
+          options.onMessage?.({ answer: message.text, records: message.records });
+        },
+        ...params
+      });
+    } else {
+      return askTableSession(params);
+    }
+  }
 }
 _table = new WeakMap();
 _getFetchProps = new WeakMap();
@@ -2530,8 +3855,7 @@ _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 record = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
   const response = await insertRecord({
     pathParams: {
       workspace: "{workspaceId}",
@@ -2541,15 +3865,16 @@ insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
     },
     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, columns);
 };
 _insertRecordWithId = new WeakSet();
 insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { createOnly, ifVersion }) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const record = transformObjectLinks(object);
+  if (!recordId)
+    return null;
+  const record = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
   const response = await insertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
@@ -2560,30 +3885,28 @@ insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { crea
     },
     body: record,
     queryParams: { createOnly, columns, ifVersion },
-    ...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, columns);
 };
 _insertRecords = new WeakSet();
 insertRecords_fn = async function(objects, { createOnly, ifVersion }) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const chunkedOperations = chunk(
-    objects.map((object) => ({
-      insert: { table: __privateGet$4(this, _table), record: transformObjectLinks(object), createOnly, ifVersion }
-    })),
-    BULK_OPERATION_MAX_SIZE
-  );
+  const operations = await promiseMap(objects, async (object) => {
+    const record = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+    return { insert: { table: __privateGet$4(this, _table), record, createOnly, ifVersion } };
+  });
+  const chunkedOperations = chunk(operations, BULK_OPERATION_MAX_SIZE);
   const ids = [];
-  for (const operations of chunkedOperations) {
+  for (const operations2 of chunkedOperations) {
     const { results } = await branchTransaction({
       pathParams: {
         workspace: "{workspaceId}",
         dbBranchName: "{dbBranch}",
         region: "{region}"
       },
-      body: { operations },
-      ...fetchProps
+      body: { operations: operations2 },
+      ...__privateGet$4(this, _getFetchProps).call(this)
     });
     for (const result of results) {
       if (result.operation === "insert") {
@@ -2597,8 +3920,9 @@ insertRecords_fn = async function(objects, { createOnly, ifVersion }) {
 };
 _updateRecordWithID = new WeakSet();
 updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const { id: _id, ...record } = transformObjectLinks(object);
+  if (!recordId)
+    return null;
+  const { id: _id, ...record } = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
   try {
     const response = await updateRecordWithID({
       pathParams: {
@@ -2610,7 +3934,7 @@ updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
       },
       queryParams: { columns, ifVersion },
       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, columns);
@@ -2623,23 +3947,21 @@ updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
 };
 _updateRecords = new WeakSet();
 updateRecords_fn = async function(objects, { ifVersion, upsert }) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const chunkedOperations = chunk(
-    objects.map(({ id, ...object }) => ({
-      update: { table: __privateGet$4(this, _table), id, ifVersion, upsert, fields: transformObjectLinks(object) }
-    })),
-    BULK_OPERATION_MAX_SIZE
-  );
+  const operations = await promiseMap(objects, async ({ id, ...object }) => {
+    const fields = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+    return { update: { table: __privateGet$4(this, _table), id, ifVersion, upsert, fields } };
+  });
+  const chunkedOperations = chunk(operations, BULK_OPERATION_MAX_SIZE);
   const ids = [];
-  for (const operations of chunkedOperations) {
+  for (const operations2 of chunkedOperations) {
     const { results } = await branchTransaction({
       pathParams: {
         workspace: "{workspaceId}",
         dbBranchName: "{dbBranch}",
         region: "{region}"
       },
-      body: { operations },
-      ...fetchProps
+      body: { operations: operations2 },
+      ...__privateGet$4(this, _getFetchProps).call(this)
     });
     for (const result of results) {
       if (result.operation === "update") {
@@ -2653,7 +3975,8 @@ updateRecords_fn = async function(objects, { ifVersion, upsert }) {
 };
 _upsertRecordWithID = new WeakSet();
 upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+  if (!recordId)
+    return null;
   const response = await upsertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
@@ -2664,14 +3987,15 @@ upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
     },
     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, columns);
 };
 _deleteRecord = new WeakSet();
 deleteRecord_fn = async function(recordId, columns = ["*"]) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+  if (!recordId)
+    return null;
   try {
     const response = await deleteRecord({
       pathParams: {
@@ -2682,7 +4006,7 @@ deleteRecord_fn = async function(recordId, columns = ["*"]) {
         recordId
       },
       queryParams: { columns },
-      ...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, columns);
@@ -2695,9 +4019,8 @@ deleteRecord_fn = async function(recordId, columns = ["*"]) {
 };
 _deleteRecords = new WeakSet();
 deleteRecords_fn = async function(recordIds) {
-  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const chunkedOperations = chunk(
-    recordIds.map((id) => ({ delete: { table: __privateGet$4(this, _table), id } })),
+    compact(recordIds).map((id) => ({ delete: { table: __privateGet$4(this, _table), id } })),
     BULK_OPERATION_MAX_SIZE
   );
   for (const operations of chunkedOperations) {
@@ -2708,21 +4031,22 @@ deleteRecords_fn = async function(recordIds) {
         region: "{region}"
       },
       body: { operations },
-      ...fetchProps
+      ...__privateGet$4(this, _getFetchProps).call(this)
     });
   }
 };
 _setCacheQuery = new WeakSet();
 setCacheQuery_fn = async function(query, meta, records) {
-  await __privateGet$4(this, _cache).set(`query_${__privateGet$4(this, _table)}:${query.key()}`, { date: new Date(), meta, records });
+  await __privateGet$4(this, _cache)?.set(`query_${__privateGet$4(this, _table)}:${query.key()}`, { date: /* @__PURE__ */ new Date(), meta, records });
 };
 _getCacheQuery = new WeakSet();
 getCacheQuery_fn = async function(query) {
   const key = `query_${__privateGet$4(this, _table)}:${query.key()}`;
-  const result = await __privateGet$4(this, _cache).get(key);
+  const result = await __privateGet$4(this, _cache)?.get(key);
   if (!result)
     return null;
-  const { cache: ttl = __privateGet$4(this, _cache).defaultQueryTTL } = query.getQueryOptions();
+  const defaultTTL = __privateGet$4(this, _cache)?.defaultQueryTTL ?? -1;
+  const { cache: ttl = defaultTTL } = query.getQueryOptions();
   if (ttl < 0)
     return null;
   const hasExpired = result.date.getTime() + ttl < Date.now();
@@ -2732,39 +4056,66 @@ _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}", region: "{region}" },
-    ...fetchProps
+    ...__privateGet$4(this, _getFetchProps).call(this)
   });
   __privateSet$4(this, _schemaTables$2, schema.tables);
   return schema.tables;
 };
-const transformObjectLinks = (object) => {
-  return Object.entries(object).reduce((acc, [key, value]) => {
+_transformObjectToApi = new WeakSet();
+transformObjectToApi_fn = async function(object) {
+  const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+  const schema = schemaTables.find((table) => table.name === __privateGet$4(this, _table));
+  if (!schema)
+    throw new Error(`Table ${__privateGet$4(this, _table)} not found in schema`);
+  const result = {};
+  for (const [key, value] of Object.entries(object)) {
     if (key === "xata")
-      return acc;
-    return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
-  }, {});
+      continue;
+    const type = schema.columns.find((column) => column.name === key)?.type;
+    switch (type) {
+      case "link": {
+        result[key] = isIdentifiable(value) ? value.id : value;
+        break;
+      }
+      case "datetime": {
+        result[key] = value instanceof Date ? value.toISOString() : value;
+        break;
+      }
+      case `file`:
+        result[key] = await parseInputFileEntry(value);
+        break;
+      case "file[]":
+        result[key] = await promiseMap(value, (item) => parseInputFileEntry(item));
+        break;
+      case "json":
+        result[key] = stringifyJson(value);
+        break;
+      default:
+        result[key] = value;
+    }
+  }
+  return result;
 };
 const initObject = (db, schemaTables, table, object, selectedColumns) => {
-  const result = {};
+  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 ?? []) {
     if (!isValidColumn(selectedColumns, column))
       continue;
-    const value = result[column.name];
+    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;
       }
@@ -2777,50 +4128,76 @@ const initObject = (db, schemaTables, table, object, selectedColumns) => {
             if (item === column.name) {
               return [...acc, "*"];
             }
-            if (item.startsWith(`${column.name}.`)) {
+            if (isString(item) && item.startsWith(`${column.name}.`)) {
               const [, ...path] = item.split(".");
               return [...acc, path.join(".")];
             }
             return acc;
           }, []);
-          result[column.name] = initObject(db, schemaTables, linkTable, value, selectedLinkColumns);
+          data[column.name] = initObject(
+            db,
+            schemaTables,
+            linkTable,
+            value,
+            selectedLinkColumns
+          );
         } else {
-          result[column.name] = null;
+          data[column.name] = null;
         }
         break;
       }
+      case "file":
+        data[column.name] = isDefined(value) ? new XataFile(value) : null;
+        break;
+      case "file[]":
+        data[column.name] = value?.map((item) => new XataFile(item)) ?? null;
+        break;
+      case "json":
+        data[column.name] = parseJson(value);
+        break;
       default:
-        result[column.name] = value ?? null;
+        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 };
+  const metadata = xata !== void 0 ? { ...xata, createdAt: new Date(xata.createdAt), updatedAt: new Date(xata.updatedAt) } : void 0;
+  record.read = function(columns2) {
+    return db[table].read(record["id"], columns2);
   };
-  result.update = function(data, b, c) {
-    const columns2 = isStringArray(b) ? b : ["*"];
+  record.update = function(data2, b, c) {
+    const columns2 = isValidSelectableColumns(b) ? b : ["*"];
     const ifVersion = parseIfVersion(b, c);
-    return db[table].update(result["id"], data, columns2, { ifVersion });
+    return db[table].update(record["id"], data2, columns2, { ifVersion });
   };
-  result.replace = function(data, b, c) {
-    const columns2 = isStringArray(b) ? b : ["*"];
+  record.replace = function(data2, b, c) {
+    const columns2 = isValidSelectableColumns(b) ? b : ["*"];
     const ifVersion = parseIfVersion(b, c);
-    return db[table].createOrReplace(result["id"], data, columns2, { ifVersion });
+    return db[table].createOrReplace(record["id"], data2, columns2, { ifVersion });
+  };
+  record.delete = function() {
+    return db[table].delete(record["id"]);
+  };
+  if (metadata !== void 0) {
+    record.xata = Object.freeze(metadata);
+  }
+  record.getMetadata = function() {
+    return record.xata;
   };
-  result.delete = function() {
-    return db[table].delete(result["id"]);
+  record.toSerializable = function() {
+    return JSON.parse(JSON.stringify(record));
   };
-  result.getMetadata = function() {
-    return xata;
+  record.toString = function() {
+    return JSON.stringify(record);
   };
-  for (const prop of ["read", "update", "replace", "delete", "getMetadata"]) {
-    Object.defineProperty(result, prop, { enumerable: false });
+  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 extractId(value) {
   if (isString(value))
@@ -2832,11 +4209,7 @@ function extractId(value) {
 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);
+  return columns.filter((item) => isString(item) && item.startsWith(column.name)).length > 0;
 }
 function parseIfVersion(...args) {
   for (const arg of args) {
@@ -2913,10 +4286,12 @@ const notExists = (column) => ({ $notExists: column });
 const startsWith = (value) => ({ $startsWith: value });
 const endsWith = (value) => ({ $endsWith: value });
 const pattern = (value) => ({ $pattern: value });
+const iPattern = (value) => ({ $iPattern: value });
 const is = (value) => ({ $is: value });
 const equals = is;
 const isNot = (value) => ({ $isNot: value });
 const contains = (value) => ({ $contains: value });
+const iContains = (value) => ({ $iContains: value });
 const includes = (value) => ({ $includes: value });
 const includesAll = (value) => ({ $includesAll: value });
 const includesNone = (value) => ({ $includesNone: value });
@@ -2972,6 +4347,80 @@ class SchemaPlugin extends XataPlugin {
 _tables = new WeakMap();
 _schemaTables$1 = new WeakMap();
 
+class FilesPlugin extends XataPlugin {
+  build(pluginOptions) {
+    return {
+      download: async (location) => {
+        const { table, record, column, fileId = "" } = location ?? {};
+        return await getFileItem({
+          pathParams: {
+            workspace: "{workspaceId}",
+            dbBranchName: "{dbBranch}",
+            region: "{region}",
+            tableName: table ?? "",
+            recordId: record ?? "",
+            columnName: column ?? "",
+            fileId
+          },
+          ...pluginOptions,
+          rawResponse: true
+        });
+      },
+      upload: async (location, file, options) => {
+        const { table, record, column, fileId = "" } = location ?? {};
+        const resolvedFile = await file;
+        const contentType = options?.mediaType || getContentType(resolvedFile);
+        const body = resolvedFile instanceof XataFile ? resolvedFile.toBlob() : resolvedFile;
+        return await putFileItem({
+          ...pluginOptions,
+          pathParams: {
+            workspace: "{workspaceId}",
+            dbBranchName: "{dbBranch}",
+            region: "{region}",
+            tableName: table ?? "",
+            recordId: record ?? "",
+            columnName: column ?? "",
+            fileId
+          },
+          body,
+          headers: { "Content-Type": contentType }
+        });
+      },
+      delete: async (location) => {
+        const { table, record, column, fileId = "" } = location ?? {};
+        return await deleteFileItem({
+          pathParams: {
+            workspace: "{workspaceId}",
+            dbBranchName: "{dbBranch}",
+            region: "{region}",
+            tableName: table ?? "",
+            recordId: record ?? "",
+            columnName: column ?? "",
+            fileId
+          },
+          ...pluginOptions
+        });
+      }
+    };
+  }
+}
+function getContentType(file) {
+  if (typeof file === "string") {
+    return "text/plain";
+  }
+  if ("mediaType" in file && file.mediaType !== void 0) {
+    return file.mediaType;
+  }
+  if (isBlob(file)) {
+    return file.type;
+  }
+  try {
+    return file.type;
+  } catch (e) {
+  }
+  return "application/octet-stream";
+}
+
 var __accessCheck$1 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -3004,138 +4453,141 @@ 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);
-        return records.map((record) => {
-          const { table = "orphan" } = record.xata;
-          return { table, record: initObject(this.db, schemaTables, table, record, ["*"]) };
-        });
+        const { records, totalCount } = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, pluginOptions);
+        return {
+          totalCount,
+          records: records.map((record) => {
+            const { table = "orphan" } = record.xata;
+            return { table, record: initObject(this.db, schemaTables, table, record, ["*"]) };
+          })
+        };
       },
       byTable: async (query, options = {}) => {
-        const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
-        return records.reduce((acc, record) => {
+        const { records: rawRecords, totalCount } = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, pluginOptions);
+        const records = rawRecords.reduce((acc, record) => {
           const { table = "orphan" } = record.xata;
           const items = acc[table] ?? [];
           const item = initObject(this.db, schemaTables, table, record, ["*"]);
           return { ...acc, [table]: [...items, item] };
         }, {});
+        return { totalCount, records };
       }
     };
   }
 }
 _schemaTables = new WeakMap();
 _search = new WeakSet();
-search_fn = async function(query, options, getFetchProps) {
-  const fetchProps = await getFetchProps();
-  const { tables, fuzziness, highlight, prefix } = options ?? {};
-  const { records } = await searchBranch({
+search_fn = async function(query, options, pluginOptions) {
+  const { tables, fuzziness, highlight, prefix, page } = options ?? {};
+  const { records, totalCount } = await searchBranch({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
-    body: { tables, query, fuzziness, prefix, highlight },
-    ...fetchProps
+    // @ts-ignore https://github.com/xataio/client-ts/issues/313
+    body: { tables, query, fuzziness, prefix, highlight, page },
+    ...pluginOptions
   });
-  return records;
+  return { records, totalCount };
 };
 _getSchemaTables = new WeakSet();
-getSchemaTables_fn = async function(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}", region: "{region}" },
-    ...fetchProps
+    ...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 urlParts = parseWorkspacesUrlParts(host);
-  if (!urlParts)
-    throw new Error(`Unable to parse workspace and region: ${databaseURL}`);
-  const { workspace, region } = urlParts;
-  const { fallbackBranch } = getEnvironment();
-  const { branch } = await resolveBranch({
-    apiKey,
-    apiUrl: databaseURL,
-    fetchImpl: getFetchImplementation(options?.fetchImpl),
-    workspacesApiUrl: `${protocol}//${host}`,
-    pathParams: { dbName, workspace, region },
-    queryParams: { gitBranch, fallbackBranch },
-    trace: defaultTrace
-  });
-  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 urlParts = parseWorkspacesUrlParts(host);
-  if (!urlParts)
-    throw new Error(`Unable to parse workspace and region: ${databaseURL}`);
-  const { workspace, region } = urlParts;
-  try {
-    return await getBranchDetails({
-      apiKey,
-      apiUrl: databaseURL,
-      fetchImpl: getFetchImplementation(options?.fetchImpl),
-      workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: { dbBranchName: `${database}:${branch}`, workspace, region },
-      trace: defaultTrace
-    });
-  } catch (err) {
-    if (isObject(err) && err.status === 404)
-      return null;
-    throw err;
+function escapeElement(elementRepresentation) {
+  const escaped = elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return '"' + escaped + '"';
+}
+function arrayString(val) {
+  let result = "{";
+  for (let i = 0; i < val.length; i++) {
+    if (i > 0) {
+      result = result + ",";
+    }
+    if (val[i] === null || typeof val[i] === "undefined") {
+      result = result + "NULL";
+    } else if (Array.isArray(val[i])) {
+      result = result + arrayString(val[i]);
+    } else if (val[i] instanceof Buffer) {
+      result += "\\\\x" + val[i].toString("hex");
+    } else {
+      result += escapeElement(prepareValue(val[i]));
+    }
   }
+  result = result + "}";
+  return result;
 }
-function getDatabaseURL() {
+function prepareValue(value) {
+  if (!isDefined(value))
+    return null;
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return arrayString(value);
+  }
+  if (isObject(value)) {
+    return JSON.stringify(value);
+  }
   try {
-    const { databaseURL } = getEnvironment();
-    return databaseURL;
-  } catch (err) {
-    return void 0;
+    return value.toString();
+  } catch (e) {
+    return value;
+  }
+}
+function prepareParams(param1, param2) {
+  if (isString(param1)) {
+    return { statement: param1, params: param2?.map((value) => prepareValue(value)) };
+  }
+  if (isStringArray(param1)) {
+    const statement = param1.reduce((acc, curr, index) => {
+      return acc + curr + (index < (param2?.length ?? 0) ? "$" + (index + 1) : "");
+    }, "");
+    return { statement, params: param2?.map((value) => prepareValue(value)) };
+  }
+  if (isObject(param1)) {
+    const { statement, params, consistency } = param1;
+    return { statement, params: params?.map((value) => prepareValue(value)), consistency };
+  }
+  throw new Error("Invalid query");
+}
+
+class SQLPlugin extends XataPlugin {
+  build(pluginOptions) {
+    return async (param1, ...param2) => {
+      const { statement, params, consistency } = prepareParams(param1, param2);
+      const { records, warning } = await sqlQuery({
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
+        body: { statement, params, consistency },
+        ...pluginOptions
+      });
+      return { records, warning };
+    };
+  }
+}
+
+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;
+      }
+    };
   }
 }
 
@@ -3162,46 +4614,43 @@ 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,
-        trace: safeOptions.trace
+        host: safeOptions.host
       };
       const db = new SchemaPlugin(schemaTables).build(pluginOptions);
       const search = new SearchPlugin(db, schemaTables).build(pluginOptions);
+      const transactions = new TransactionPlugin().build(pluginOptions);
+      const sql = new SQLPlugin().build(pluginOptions);
+      const files = new FilesPlugin().build(pluginOptions);
       this.db = db;
       this.search = search;
+      this.transactions = transactions;
+      this.sql = sql;
+      this.files = files;
       for (const [key, namespace] of Object.entries(plugins ?? {})) {
         if (namespace === void 0)
           continue;
-        const result = namespace.build(pluginOptions);
-        if (result instanceof Promise) {
-          void result.then((namespace2) => {
-            this[key] = namespace2;
-          });
-        } else {
-          this[key] = result;
-        }
+        this[key] = namespace.build(pluginOptions);
       }
     }
     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";
+    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."
@@ -3212,46 +4661,73 @@ const buildClient = (plugins) => {
     const apiKey = options?.apiKey || getAPIKey();
     const cache = options?.cache ?? new SimpleCache({ defaultQueryTTL: 0 });
     const trace = options?.trace ?? defaultTrace;
-    const branch = async () => options?.branch !== void 0 ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({ apiKey, databaseURL, fetchImpl: options?.fetch });
+    const clientName = options?.clientName;
+    const host = options?.host ?? "production";
+    const xataAgentExtra = options?.xataAgentExtra;
     if (!apiKey) {
       throw new Error("Option apiKey is required");
     }
     if (!databaseURL) {
       throw new Error("Option databaseURL is required");
     }
-    return { fetch, databaseURL, apiKey, branch, cache, trace, clientID: generateUUID(), enableBrowser };
-  }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({ fetch, apiKey, databaseURL, branch, trace, clientID }) {
-    const branchValue = await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, branch);
-    if (!branchValue)
-      throw new Error("Unable to resolve branch value");
+    const envBranch = getBranch();
+    const previewBranch = getPreviewBranch();
+    const branch = options?.branch || previewBranch || envBranch || "main";
+    if (!!previewBranch && branch !== previewBranch) {
+      console.warn(
+        `Ignoring preview branch ${previewBranch} because branch option was passed to the client constructor with value ${branch}`
+      );
+    } else if (!!envBranch && branch !== envBranch) {
+      console.warn(
+        `Ignoring branch ${envBranch} because branch option was passed to the client constructor with value ${branch}`
+      );
+    } else if (!!previewBranch && !!envBranch && previewBranch !== envBranch) {
+      console.warn(
+        `Ignoring preview branch ${previewBranch} and branch ${envBranch} because branch option was passed to the client constructor with value ${branch}`
+      );
+    } else if (!previewBranch && !envBranch && options?.branch === void 0) {
+      console.warn(
+        `No branch was passed to the client constructor. Using default branch ${branch}. You can set the branch with the environment variable XATA_BRANCH or by passing the branch option to the client constructor.`
+      );
+    }
+    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: "",
+      // Instead of using workspace and dbBranch, we inject a probably CNAME'd URL
       workspacesApiUrl: (path, params) => {
         const hasBranch = params.dbBranchName ?? params.branch;
-        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch !== void 0 ? `:${branchValue}` : "");
+        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch !== void 0 ? `:${branch}` : "");
         return databaseURL + newPath;
       },
       trace,
-      clientID
-    };
-  }, _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;
+      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() {
@@ -3324,21 +4800,6 @@ const deserialize = (json) => {
   return defaultSerializer.fromJSON(json);
 };
 
-function buildWorkerRunner(config) {
-  return function xataWorker(name, _worker) {
-    return async (...args) => {
-      const url = process.env.NODE_ENV === "development" ? `http://localhost:64749/${name}` : `https://dispatcher.xata.workers.dev/${config.workspace}/${config.worker}/${name}`;
-      const result = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: serialize({ args })
-      });
-      const text = await result.text();
-      return deserialize(text);
-    };
-  };
-}
-
 class XataError extends Error {
   constructor(message, status) {
     super(message);
@@ -3347,6 +4808,8 @@ class XataError extends Error {
 }
 
 exports.BaseClient = BaseClient;
+exports.FetcherError = FetcherError;
+exports.FilesPlugin = FilesPlugin;
 exports.Operations = operationsByTag;
 exports.PAGINATION_DEFAULT_OFFSET = PAGINATION_DEFAULT_OFFSET;
 exports.PAGINATION_DEFAULT_SIZE = PAGINATION_DEFAULT_SIZE;
@@ -3355,56 +4818,70 @@ exports.PAGINATION_MAX_SIZE = PAGINATION_MAX_SIZE;
 exports.Page = Page;
 exports.Query = Query;
 exports.RecordArray = RecordArray;
+exports.RecordColumnTypes = RecordColumnTypes;
 exports.Repository = Repository;
 exports.RestRepository = RestRepository;
+exports.SQLPlugin = SQLPlugin;
 exports.SchemaPlugin = SchemaPlugin;
 exports.SearchPlugin = SearchPlugin;
 exports.Serializer = Serializer;
 exports.SimpleCache = SimpleCache;
+exports.TransactionPlugin = TransactionPlugin;
 exports.XataApiClient = XataApiClient;
 exports.XataApiPlugin = XataApiPlugin;
 exports.XataError = XataError;
+exports.XataFile = XataFile;
 exports.XataPlugin = XataPlugin;
 exports.acceptWorkspaceMemberInvite = acceptWorkspaceMemberInvite;
 exports.addGitBranchesEntry = addGitBranchesEntry;
 exports.addTableColumn = addTableColumn;
 exports.aggregateTable = aggregateTable;
 exports.applyBranchSchemaEdit = applyBranchSchemaEdit;
+exports.applyMigration = applyMigration;
+exports.askTable = askTable;
+exports.askTableSession = askTableSession;
 exports.branchTransaction = branchTransaction;
 exports.buildClient = buildClient;
-exports.buildWorkerRunner = buildWorkerRunner;
+exports.buildPreviewBranchName = buildPreviewBranchName;
+exports.buildProviderString = buildProviderString;
 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.createCluster = createCluster;
 exports.createDatabase = createDatabase;
 exports.createMigrationRequest = createMigrationRequest;
 exports.createTable = createTable;
 exports.createUserAPIKey = createUserAPIKey;
 exports.createWorkspace = createWorkspace;
-exports.dEPRECATEDcreateDatabase = dEPRECATEDcreateDatabase;
-exports.dEPRECATEDdeleteDatabase = dEPRECATEDdeleteDatabase;
-exports.dEPRECATEDgetDatabaseList = dEPRECATEDgetDatabaseList;
-exports.dEPRECATEDgetDatabaseMetadata = dEPRECATEDgetDatabaseMetadata;
-exports.dEPRECATEDupdateDatabaseMetadata = dEPRECATEDupdateDatabaseMetadata;
 exports.deleteBranch = deleteBranch;
 exports.deleteColumn = deleteColumn;
 exports.deleteDatabase = deleteDatabase;
+exports.deleteDatabaseGithubSettings = deleteDatabaseGithubSettings;
+exports.deleteFile = deleteFile;
+exports.deleteFileItem = deleteFileItem;
+exports.deleteOAuthAccessToken = deleteOAuthAccessToken;
 exports.deleteRecord = deleteRecord;
 exports.deleteTable = deleteTable;
 exports.deleteUser = deleteUser;
 exports.deleteUserAPIKey = deleteUserAPIKey;
+exports.deleteUserOAuthClient = deleteUserOAuthClient;
 exports.deleteWorkspace = deleteWorkspace;
 exports.deserialize = deserialize;
 exports.endsWith = endsWith;
 exports.equals = equals;
 exports.executeBranchMigrationPlan = executeBranchMigrationPlan;
 exports.exists = exists;
+exports.fileAccess = fileAccess;
+exports.fileUpload = fileUpload;
 exports.ge = ge;
 exports.getAPIKey = getAPIKey;
+exports.getAuthorizationCode = getAuthorizationCode;
+exports.getBranch = getBranch;
 exports.getBranchDetails = getBranchDetails;
 exports.getBranchList = getBranchList;
 exports.getBranchMetadata = getBranchMetadata;
@@ -3412,29 +4889,38 @@ exports.getBranchMigrationHistory = getBranchMigrationHistory;
 exports.getBranchMigrationPlan = getBranchMigrationPlan;
 exports.getBranchSchemaHistory = getBranchSchemaHistory;
 exports.getBranchStats = getBranchStats;
+exports.getCluster = getCluster;
 exports.getColumn = getColumn;
-exports.getCurrentBranchDetails = getCurrentBranchDetails;
-exports.getCurrentBranchName = getCurrentBranchName;
+exports.getDatabaseGithubSettings = getDatabaseGithubSettings;
 exports.getDatabaseList = getDatabaseList;
 exports.getDatabaseMetadata = getDatabaseMetadata;
 exports.getDatabaseURL = getDatabaseURL;
+exports.getFile = getFile;
+exports.getFileItem = getFileItem;
 exports.getGitBranchesMapping = getGitBranchesMapping;
 exports.getHostUrl = getHostUrl;
 exports.getMigrationRequest = getMigrationRequest;
 exports.getMigrationRequestIsMerged = getMigrationRequestIsMerged;
+exports.getPreviewBranch = getPreviewBranch;
 exports.getRecord = getRecord;
+exports.getSchema = getSchema;
 exports.getTableColumns = getTableColumns;
 exports.getTableSchema = getTableSchema;
 exports.getUser = getUser;
 exports.getUserAPIKeys = getUserAPIKeys;
+exports.getUserOAuthAccessTokens = getUserOAuthAccessTokens;
+exports.getUserOAuthClients = getUserOAuthClients;
 exports.getWorkspace = getWorkspace;
 exports.getWorkspaceMembersList = getWorkspaceMembersList;
 exports.getWorkspacesList = getWorkspacesList;
+exports.grantAuthorizationCode = grantAuthorizationCode;
 exports.greaterEquals = greaterEquals;
 exports.greaterThan = greaterThan;
 exports.greaterThanEquals = greaterThanEquals;
 exports.gt = gt;
 exports.gte = gte;
+exports.iContains = iContains;
+exports.iPattern = iPattern;
 exports.includes = includes;
 exports.includesAll = includesAll;
 exports.includesAny = includesAny;
@@ -3448,11 +4934,14 @@ exports.isHostProviderAlias = isHostProviderAlias;
 exports.isHostProviderBuilder = isHostProviderBuilder;
 exports.isIdentifiable = isIdentifiable;
 exports.isNot = isNot;
+exports.isValidExpandedColumn = isValidExpandedColumn;
+exports.isValidSelectableColumns = isValidSelectableColumns;
 exports.isXataRecord = isXataRecord;
 exports.le = le;
 exports.lessEquals = lessEquals;
 exports.lessThan = lessThan;
 exports.lessThanEquals = lessThanEquals;
+exports.listClusters = listClusters;
 exports.listMigrationRequestsCommits = listMigrationRequestsCommits;
 exports.listRegions = listRegions;
 exports.lt = lt;
@@ -3463,24 +4952,36 @@ exports.operationsByTag = operationsByTag;
 exports.parseProviderString = parseProviderString;
 exports.parseWorkspacesUrlParts = parseWorkspacesUrlParts;
 exports.pattern = pattern;
+exports.pgRollJobStatus = pgRollJobStatus;
+exports.pgRollMigrationHistory = pgRollMigrationHistory;
+exports.pgRollStatus = pgRollStatus;
 exports.previewBranchSchemaEdit = previewBranchSchemaEdit;
+exports.pushBranchMigrations = pushBranchMigrations;
+exports.putFile = putFile;
+exports.putFileItem = putFileItem;
 exports.queryMigrationRequests = queryMigrationRequests;
 exports.queryTable = queryTable;
 exports.removeGitBranchesEntry = removeGitBranchesEntry;
 exports.removeWorkspaceMember = removeWorkspaceMember;
+exports.renameDatabase = renameDatabase;
 exports.resendWorkspaceMemberInvite = resendWorkspaceMemberInvite;
 exports.resolveBranch = resolveBranch;
 exports.searchBranch = searchBranch;
 exports.searchTable = searchTable;
 exports.serialize = serialize;
 exports.setTableSchema = setTableSchema;
+exports.sqlQuery = sqlQuery;
 exports.startsWith = startsWith;
 exports.summarizeTable = summarizeTable;
+exports.transformImage = transformImage;
 exports.updateBranchMetadata = updateBranchMetadata;
 exports.updateBranchSchema = updateBranchSchema;
+exports.updateCluster = updateCluster;
 exports.updateColumn = updateColumn;
+exports.updateDatabaseGithubSettings = updateDatabaseGithubSettings;
 exports.updateDatabaseMetadata = updateDatabaseMetadata;
 exports.updateMigrationRequest = updateMigrationRequest;
+exports.updateOAuthAccessToken = updateOAuthAccessToken;
 exports.updateRecordWithID = updateRecordWithID;
 exports.updateTable = updateTable;
 exports.updateUser = updateUser;
@@ -3488,4 +4989,5 @@ exports.updateWorkspace = updateWorkspace;
 exports.updateWorkspaceMemberInvite = updateWorkspaceMemberInvite;
 exports.updateWorkspaceMemberRole = updateWorkspaceMemberRole;
 exports.upsertRecordWithID = upsertRecordWithID;
+exports.vectorSearchTable = vectorSearchTable;
 //# sourceMappingURL=index.cjs.map