@xata.io/client 0.0.0-next.vdf3a7b8c70c130a3e9c73decc8494a3f8c8febcb → 0.0.0-next.ve109eeeef360444eb9f061f3d745eed662493f78

package/dist/index.cjs

@@ -24,6 +24,1789 @@ const TraceAttributes = {
   CLOUDFLARE_RAY_ID: "cf.ray"
 };
 
+const lookup = [];
+const revLookup = [];
+const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+  revLookup[code.charCodeAt(i)] = i;
+}
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function getLens(b64) {
+  const len = b64.length;
+  if (len % 4 > 0) {
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  }
+  let validLen = b64.indexOf("=");
+  if (validLen === -1) validLen = len;
+  const placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function _byteLength(_b64, validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+  let tmp;
+  const lens = getLens(b64);
+  const validLen = lens[0];
+  const placeHoldersLen = lens[1];
+  const arr = new Uint8Array(_byteLength(b64, validLen, placeHoldersLen));
+  let curByte = 0;
+  const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+  let i;
+  for (i = 0; i < len; i += 4) {
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+    arr[curByte++] = tmp >> 16 & 255;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 2) {
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 1) {
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  let tmp;
+  const output = [];
+  for (let i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  let tmp;
+  const len = uint8.length;
+  const extraBytes = len % 3;
+  const parts = [];
+  const maxChunkLength = 16383;
+  for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+  }
+  return parts.join("");
+}
+
+const K_MAX_LENGTH = 2147483647;
+const MAX_ARGUMENTS_LENGTH = 4096;
+class Buffer extends Uint8Array {
+  /**
+   * Constructs a new `Buffer` instance.
+   *
+   * @param value
+   * @param encodingOrOffset
+   * @param length
+   */
+  constructor(value, encodingOrOffset, length) {
+    if (typeof value === "number") {
+      if (typeof encodingOrOffset === "string") {
+        throw new TypeError("The first argument must be of type string, received type number");
+      }
+      if (value < 0) {
+        throw new RangeError("The buffer size cannot be negative");
+      }
+      super(value < 0 ? 0 : Buffer._checked(value) | 0);
+    } else if (typeof value === "string") {
+      if (typeof encodingOrOffset !== "string") {
+        encodingOrOffset = "utf8";
+      }
+      if (!Buffer.isEncoding(encodingOrOffset)) {
+        throw new TypeError("Unknown encoding: " + encodingOrOffset);
+      }
+      const length2 = Buffer.byteLength(value, encodingOrOffset) | 0;
+      super(length2);
+      const written = this.write(value, 0, this.length, encodingOrOffset);
+      if (written !== length2) {
+        throw new TypeError(
+          "Number of bytes written did not match expected length (wrote " + written + ", expected " + length2 + ")"
+        );
+      }
+    } else if (ArrayBuffer.isView(value)) {
+      if (Buffer._isInstance(value, Uint8Array)) {
+        const copy = new Uint8Array(value);
+        const array = copy.buffer;
+        const byteOffset = copy.byteOffset;
+        const length2 = copy.byteLength;
+        if (byteOffset < 0 || array.byteLength < byteOffset) {
+          throw new RangeError("offset is outside of buffer bounds");
+        }
+        if (array.byteLength < byteOffset + (length2 || 0)) {
+          throw new RangeError("length is outside of buffer bounds");
+        }
+        super(new Uint8Array(array, byteOffset, length2));
+      } else {
+        const array = value;
+        const length2 = array.length < 0 ? 0 : Buffer._checked(array.length) | 0;
+        super(new Uint8Array(length2));
+        for (let i = 0; i < length2; i++) {
+          this[i] = array[i] & 255;
+        }
+      }
+    } else if (value == null) {
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+      );
+    } else if (Buffer._isInstance(value, ArrayBuffer) || value && Buffer._isInstance(value.buffer, ArrayBuffer)) {
+      const array = value;
+      const byteOffset = encodingOrOffset;
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError("offset is outside of buffer bounds");
+      }
+      if (array.byteLength < byteOffset + (length || 0)) {
+        throw new RangeError("length is outside of buffer bounds");
+      }
+      super(new Uint8Array(array, byteOffset, length));
+    } else if (Array.isArray(value)) {
+      const array = value;
+      const length2 = array.length < 0 ? 0 : Buffer._checked(array.length) | 0;
+      super(new Uint8Array(length2));
+      for (let i = 0; i < length2; i++) {
+        this[i] = array[i] & 255;
+      }
+    } else {
+      throw new TypeError("Unable to determine the correct way to allocate buffer for type " + typeof value);
+    }
+  }
+  /**
+   * Return JSON representation of the buffer.
+   */
+  toJSON() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this)
+    };
+  }
+  /**
+   * Writes `string` to the buffer at `offset` according to the character encoding in `encoding`. The `length`
+   * parameter is the number of bytes to write. If the buffer does not contain enough space to fit the entire string,
+   * only part of `string` will be written. However, partially encoded characters will not be written.
+   *
+   * @param string String to write to `buf`.
+   * @param offset Number of bytes to skip before starting to write `string`. Default: `0`.
+   * @param length Maximum number of bytes to write: Default: `buf.length - offset`.
+   * @param encoding The character encoding of `string`. Default: `utf8`.
+   */
+  write(string, offset, length, encoding) {
+    if (typeof offset === "undefined") {
+      encoding = "utf8";
+      length = this.length;
+      offset = 0;
+    } else if (typeof length === "undefined" && typeof offset === "string") {
+      encoding = offset;
+      length = this.length;
+      offset = 0;
+    } else if (typeof offset === "number" && isFinite(offset)) {
+      offset = offset >>> 0;
+      if (typeof length === "number" && isFinite(length)) {
+        length = length >>> 0;
+        encoding ?? (encoding = "utf8");
+      } else if (typeof length === "string") {
+        encoding = length;
+        length = void 0;
+      }
+    } else {
+      throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+    }
+    const remaining = this.length - offset;
+    if (typeof length === "undefined" || length > remaining) {
+      length = remaining;
+    }
+    if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+      throw new RangeError("Attempt to write outside buffer bounds");
+    }
+    encoding || (encoding = "utf8");
+    switch (Buffer._getEncoding(encoding)) {
+      case "hex":
+        return Buffer._hexWrite(this, string, offset, length);
+      case "utf8":
+        return Buffer._utf8Write(this, string, offset, length);
+      case "ascii":
+      case "latin1":
+      case "binary":
+        return Buffer._asciiWrite(this, string, offset, length);
+      case "ucs2":
+      case "utf16le":
+        return Buffer._ucs2Write(this, string, offset, length);
+      case "base64":
+        return Buffer._base64Write(this, string, offset, length);
+    }
+  }
+  /**
+   * Decodes the buffer to a string according to the specified character encoding.
+   * Passing `start` and `end` will decode only a subset of the buffer.
+   *
+   * Note that if the encoding is `utf8` and a byte sequence in the input is not valid UTF-8, then each invalid byte
+   * will be replaced with `U+FFFD`.
+   *
+   * @param encoding
+   * @param start
+   * @param end
+   */
+  toString(encoding, start, end) {
+    const length = this.length;
+    if (length === 0) {
+      return "";
+    }
+    if (arguments.length === 0) {
+      return Buffer._utf8Slice(this, 0, length);
+    }
+    if (typeof start === "undefined" || start < 0) {
+      start = 0;
+    }
+    if (start > this.length) {
+      return "";
+    }
+    if (typeof end === "undefined" || end > this.length) {
+      end = this.length;
+    }
+    if (end <= 0) {
+      return "";
+    }
+    end >>>= 0;
+    start >>>= 0;
+    if (end <= start) {
+      return "";
+    }
+    if (!encoding) {
+      encoding = "utf8";
+    }
+    switch (Buffer._getEncoding(encoding)) {
+      case "hex":
+        return Buffer._hexSlice(this, start, end);
+      case "utf8":
+        return Buffer._utf8Slice(this, start, end);
+      case "ascii":
+        return Buffer._asciiSlice(this, start, end);
+      case "latin1":
+      case "binary":
+        return Buffer._latin1Slice(this, start, end);
+      case "ucs2":
+      case "utf16le":
+        return Buffer._utf16leSlice(this, start, end);
+      case "base64":
+        return Buffer._base64Slice(this, start, end);
+    }
+  }
+  /**
+   * Returns true if this buffer's is equal to the provided buffer, meaning they share the same exact data.
+   *
+   * @param otherBuffer
+   */
+  equals(otherBuffer) {
+    if (!Buffer.isBuffer(otherBuffer)) {
+      throw new TypeError("Argument must be a Buffer");
+    }
+    if (this === otherBuffer) {
+      return true;
+    }
+    return Buffer.compare(this, otherBuffer) === 0;
+  }
+  /**
+   * Compares the buffer with `otherBuffer` and returns a number indicating whether the buffer comes before, after,
+   * or is the same as `otherBuffer` in sort order. Comparison is based on the actual sequence of bytes in each
+   * buffer.
+   *
+   * - `0` is returned if `otherBuffer` is the same as this buffer.
+   * - `1` is returned if `otherBuffer` should come before this buffer when sorted.
+   * - `-1` is returned if `otherBuffer` should come after this buffer when sorted.
+   *
+   * @param otherBuffer The buffer to compare to.
+   * @param targetStart The offset within `otherBuffer` at which to begin comparison.
+   * @param targetEnd The offset within `otherBuffer` at which to end comparison (exclusive).
+   * @param sourceStart The offset within this buffer at which to begin comparison.
+   * @param sourceEnd The offset within this buffer at which to end the comparison (exclusive).
+   */
+  compare(otherBuffer, targetStart, targetEnd, sourceStart, sourceEnd) {
+    if (Buffer._isInstance(otherBuffer, Uint8Array)) {
+      otherBuffer = Buffer.from(otherBuffer, otherBuffer.byteOffset, otherBuffer.byteLength);
+    }
+    if (!Buffer.isBuffer(otherBuffer)) {
+      throw new TypeError("Argument must be a Buffer or Uint8Array");
+    }
+    targetStart ?? (targetStart = 0);
+    targetEnd ?? (targetEnd = otherBuffer ? otherBuffer.length : 0);
+    sourceStart ?? (sourceStart = 0);
+    sourceEnd ?? (sourceEnd = this.length);
+    if (targetStart < 0 || targetEnd > otherBuffer.length || sourceStart < 0 || sourceEnd > this.length) {
+      throw new RangeError("Out of range index");
+    }
+    if (sourceStart >= sourceEnd && targetStart >= targetEnd) {
+      return 0;
+    }
+    if (sourceStart >= sourceEnd) {
+      return -1;
+    }
+    if (targetStart >= targetEnd) {
+      return 1;
+    }
+    targetStart >>>= 0;
+    targetEnd >>>= 0;
+    sourceStart >>>= 0;
+    sourceEnd >>>= 0;
+    if (this === otherBuffer) {
+      return 0;
+    }
+    let x = sourceEnd - sourceStart;
+    let y = targetEnd - targetStart;
+    const len = Math.min(x, y);
+    const thisCopy = this.slice(sourceStart, sourceEnd);
+    const targetCopy = otherBuffer.slice(targetStart, targetEnd);
+    for (let i = 0; i < len; ++i) {
+      if (thisCopy[i] !== targetCopy[i]) {
+        x = thisCopy[i];
+        y = targetCopy[i];
+        break;
+      }
+    }
+    if (x < y) return -1;
+    if (y < x) return 1;
+    return 0;
+  }
+  /**
+   * Copies data from a region of this buffer to a region in `targetBuffer`, even if the `targetBuffer` memory
+   * region overlaps with this buffer.
+   *
+   * @param targetBuffer The target buffer to copy into.
+   * @param targetStart The offset within `targetBuffer` at which to begin writing.
+   * @param sourceStart The offset within this buffer at which to begin copying.
+   * @param sourceEnd The offset within this buffer at which to end copying (exclusive).
+   */
+  copy(targetBuffer, targetStart, sourceStart, sourceEnd) {
+    if (!Buffer.isBuffer(targetBuffer)) throw new TypeError("argument should be a Buffer");
+    if (!sourceStart) sourceStart = 0;
+    if (!targetStart) targetStart = 0;
+    if (!sourceEnd && sourceEnd !== 0) sourceEnd = this.length;
+    if (targetStart >= targetBuffer.length) targetStart = targetBuffer.length;
+    if (!targetStart) targetStart = 0;
+    if (sourceEnd > 0 && sourceEnd < sourceStart) sourceEnd = sourceStart;
+    if (sourceEnd === sourceStart) return 0;
+    if (targetBuffer.length === 0 || this.length === 0) return 0;
+    if (targetStart < 0) {
+      throw new RangeError("targetStart out of bounds");
+    }
+    if (sourceStart < 0 || sourceStart >= this.length) throw new RangeError("Index out of range");
+    if (sourceEnd < 0) throw new RangeError("sourceEnd out of bounds");
+    if (sourceEnd > this.length) sourceEnd = this.length;
+    if (targetBuffer.length - targetStart < sourceEnd - sourceStart) {
+      sourceEnd = targetBuffer.length - targetStart + sourceStart;
+    }
+    const len = sourceEnd - sourceStart;
+    if (this === targetBuffer && typeof Uint8Array.prototype.copyWithin === "function") {
+      this.copyWithin(targetStart, sourceStart, sourceEnd);
+    } else {
+      Uint8Array.prototype.set.call(targetBuffer, this.subarray(sourceStart, sourceEnd), targetStart);
+    }
+    return len;
+  }
+  /**
+   * Returns a new `Buffer` that references the same memory as the original, but offset and cropped by the `start`
+   * and `end` indices. This is the same behavior as `buf.subarray()`.
+   *
+   * This method is not compatible with the `Uint8Array.prototype.slice()`, which is a superclass of Buffer. To copy
+   * the slice, use `Uint8Array.prototype.slice()`.
+   *
+   * @param start
+   * @param end
+   */
+  slice(start, end) {
+    if (!start) {
+      start = 0;
+    }
+    const len = this.length;
+    start = ~~start;
+    end = end === void 0 ? len : ~~end;
+    if (start < 0) {
+      start += len;
+      if (start < 0) {
+        start = 0;
+      }
+    } else if (start > len) {
+      start = len;
+    }
+    if (end < 0) {
+      end += len;
+      if (end < 0) {
+        end = 0;
+      }
+    } else if (end > len) {
+      end = len;
+    }
+    if (end < start) {
+      end = start;
+    }
+    const newBuf = this.subarray(start, end);
+    Object.setPrototypeOf(newBuf, Buffer.prototype);
+    return newBuf;
+  }
+  /**
+   * Writes `byteLength` bytes of `value` to `buf` at the specified `offset` as little-endian. Supports up to 48 bits
+   * of accuracy. Behavior is undefined when value is anything other than an unsigned integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param byteLength Number of bytes to write, between 0 and 6.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUIntLE(value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+      const maxBytes = Math.pow(2, 8 * byteLength) - 1;
+      Buffer._checkInt(this, value, offset, byteLength, maxBytes, 0);
+    }
+    let mul = 1;
+    let i = 0;
+    this[offset] = value & 255;
+    while (++i < byteLength && (mul *= 256)) {
+      this[offset + i] = value / mul & 255;
+    }
+    return offset + byteLength;
+  }
+  /**
+   * Writes `byteLength` bytes of `value` to `buf` at the specified `offset` as big-endian. Supports up to 48 bits of
+   * accuracy. Behavior is undefined when `value` is anything other than an unsigned integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param byteLength Number of bytes to write, between 0 and 6.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUIntBE(value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+      const maxBytes = Math.pow(2, 8 * byteLength) - 1;
+      Buffer._checkInt(this, value, offset, byteLength, maxBytes, 0);
+    }
+    let i = byteLength - 1;
+    let mul = 1;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      this[offset + i] = value / mul & 255;
+    }
+    return offset + byteLength;
+  }
+  /**
+   * Writes `byteLength` bytes of `value` to `buf` at the specified `offset` as little-endian. Supports up to 48 bits
+   * of accuracy. Behavior is undefined when `value` is anything other than a signed integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param byteLength Number of bytes to write, between 0 and 6.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeIntLE(value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      const limit = Math.pow(2, 8 * byteLength - 1);
+      Buffer._checkInt(this, value, offset, byteLength, limit - 1, -limit);
+    }
+    let i = 0;
+    let mul = 1;
+    let sub = 0;
+    this[offset] = value & 255;
+    while (++i < byteLength && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+        sub = 1;
+      }
+      this[offset + i] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength;
+  }
+  /**
+   * Writes `byteLength` bytes of `value` to `buf` at the specified `offset` as big-endian. Supports up to 48 bits
+   * of accuracy. Behavior is undefined when `value` is anything other than a signed integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param byteLength Number of bytes to write, between 0 and 6.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeIntBE(value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      const limit = Math.pow(2, 8 * byteLength - 1);
+      Buffer._checkInt(this, value, offset, byteLength, limit - 1, -limit);
+    }
+    let i = byteLength - 1;
+    let mul = 1;
+    let sub = 0;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+        sub = 1;
+      }
+      this[offset + i] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength;
+  }
+  /**
+   * Reads `byteLength` number of bytes from `buf` at the specified `offset` and interprets the result as an
+   * unsigned, little-endian integer supporting up to 48 bits of accuracy.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param byteLength Number of bytes to read, between 0 and 6.
+   * @param noAssert
+   */
+  readUIntLE(offset, byteLength, noAssert) {
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, byteLength, this.length);
+    }
+    let val = this[offset];
+    let mul = 1;
+    let i = 0;
+    while (++i < byteLength && (mul *= 256)) {
+      val += this[offset + i] * mul;
+    }
+    return val;
+  }
+  /**
+   * Reads `byteLength` number of bytes from `buf` at the specified `offset` and interprets the result as an
+   * unsigned, big-endian integer supporting up to 48 bits of accuracy.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param byteLength Number of bytes to read, between 0 and 6.
+   * @param noAssert
+   */
+  readUIntBE(offset, byteLength, noAssert) {
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, byteLength, this.length);
+    }
+    let val = this[offset + --byteLength];
+    let mul = 1;
+    while (byteLength > 0 && (mul *= 256)) {
+      val += this[offset + --byteLength] * mul;
+    }
+    return val;
+  }
+  /**
+   * Reads `byteLength` number of bytes from `buf` at the specified `offset` and interprets the result as a
+   * little-endian, two's complement signed value supporting up to 48 bits of accuracy.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param byteLength Number of bytes to read, between 0 and 6.
+   * @param noAssert
+   */
+  readIntLE(offset, byteLength, noAssert) {
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, byteLength, this.length);
+    }
+    let val = this[offset];
+    let mul = 1;
+    let i = 0;
+    while (++i < byteLength && (mul *= 256)) {
+      val += this[offset + i] * mul;
+    }
+    mul *= 128;
+    if (val >= mul) {
+      val -= Math.pow(2, 8 * byteLength);
+    }
+    return val;
+  }
+  /**
+   * Reads `byteLength` number of bytes from `buf` at the specified `offset` and interprets the result as a
+   * big-endian, two's complement signed value supporting up to 48 bits of accuracy.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param byteLength Number of bytes to read, between 0 and 6.
+   * @param noAssert
+   */
+  readIntBE(offset, byteLength, noAssert) {
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, byteLength, this.length);
+    }
+    let i = byteLength;
+    let mul = 1;
+    let val = this[offset + --i];
+    while (i > 0 && (mul *= 256)) {
+      val += this[offset + --i] * mul;
+    }
+    mul *= 128;
+    if (val >= mul) {
+      val -= Math.pow(2, 8 * byteLength);
+    }
+    return val;
+  }
+  /**
+   * Reads an unsigned 8-bit integer from `buf` at the specified `offset`.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readUInt8(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 1, this.length);
+    }
+    return this[offset];
+  }
+  /**
+   * Reads an unsigned, little-endian 16-bit integer from `buf` at the specified `offset`.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readUInt16LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 2, this.length);
+    }
+    return this[offset] | this[offset + 1] << 8;
+  }
+  /**
+   * Reads an unsigned, big-endian 16-bit integer from `buf` at the specified `offset`.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readUInt16BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 2, this.length);
+    }
+    return this[offset] << 8 | this[offset + 1];
+  }
+  /**
+   * Reads an unsigned, little-endian 32-bit integer from `buf` at the specified `offset`.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readUInt32LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 4, this.length);
+    }
+    return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+  }
+  /**
+   * Reads an unsigned, big-endian 32-bit integer from `buf` at the specified `offset`.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readUInt32BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 4, this.length);
+    }
+    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+  }
+  /**
+   * Reads a signed 8-bit integer from `buf` at the specified `offset`. Integers read from a `Buffer` are interpreted
+   * as two's complement signed values.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readInt8(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 1, this.length);
+    }
+    if (!(this[offset] & 128)) {
+      return this[offset];
+    }
+    return (255 - this[offset] + 1) * -1;
+  }
+  /**
+   * Reads a signed, little-endian 16-bit integer from `buf` at the specified `offset`. Integers read from a `Buffer`
+   * are interpreted as two's complement signed values.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readInt16LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 2, this.length);
+    }
+    const val = this[offset] | this[offset + 1] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  }
+  /**
+   * Reads a signed, big-endian 16-bit integer from `buf` at the specified `offset`. Integers read from a `Buffer`
+   * are interpreted as two's complement signed values.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readInt16BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 2, this.length);
+    }
+    const val = this[offset + 1] | this[offset] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  }
+  /**
+   * Reads a signed, little-endian 32-bit integer from `buf` at the specified `offset`. Integers read from a `Buffer`
+   * are interpreted as two's complement signed values.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readInt32LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 4, this.length);
+    }
+    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+  }
+  /**
+   * Reads a signed, big-endian 32-bit integer from `buf` at the specified `offset`. Integers read from a `Buffer`
+   * are interpreted as two's complement signed values.
+   *
+   * @param offset Number of bytes to skip before starting to read.
+   * @param noAssert
+   */
+  readInt32BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkOffset(offset, 4, this.length);
+    }
+    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+  }
+  /**
+   * Interprets `buf` as an array of unsigned 16-bit integers and swaps the byte order in-place.
+   * Throws a `RangeError` if `buf.length` is not a multiple of 2.
+   */
+  swap16() {
+    const len = this.length;
+    if (len % 2 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    }
+    for (let i = 0; i < len; i += 2) {
+      this._swap(this, i, i + 1);
+    }
+    return this;
+  }
+  /**
+   * Interprets `buf` as an array of unsigned 32-bit integers and swaps the byte order in-place.
+   * Throws a `RangeError` if `buf.length` is not a multiple of 4.
+   */
+  swap32() {
+    const len = this.length;
+    if (len % 4 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    }
+    for (let i = 0; i < len; i += 4) {
+      this._swap(this, i, i + 3);
+      this._swap(this, i + 1, i + 2);
+    }
+    return this;
+  }
+  /**
+   * Interprets `buf` as an array of unsigned 64-bit integers and swaps the byte order in-place.
+   * Throws a `RangeError` if `buf.length` is not a multiple of 8.
+   */
+  swap64() {
+    const len = this.length;
+    if (len % 8 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    }
+    for (let i = 0; i < len; i += 8) {
+      this._swap(this, i, i + 7);
+      this._swap(this, i + 1, i + 6);
+      this._swap(this, i + 2, i + 5);
+      this._swap(this, i + 3, i + 4);
+    }
+    return this;
+  }
+  /**
+   * Swaps two octets.
+   *
+   * @param b
+   * @param n
+   * @param m
+   */
+  _swap(b, n, m) {
+    const i = b[n];
+    b[n] = b[m];
+    b[m] = i;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset`. The `value` must be a valid unsigned 8-bit integer.
+   * Behavior is undefined when `value` is anything other than an unsigned 8-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUInt8(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 1, 255, 0);
+    }
+    this[offset] = value & 255;
+    return offset + 1;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as little-endian. The `value` must be a valid unsigned 16-bit
+   * integer. Behavior is undefined when `value` is anything other than an unsigned 16-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUInt16LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 2, 65535, 0);
+    }
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    return offset + 2;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as big-endian. The `value` must be a valid unsigned 16-bit
+   * integer. Behavior is undefined when `value` is anything other than an unsigned 16-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUInt16BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 2, 65535, 0);
+    }
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as little-endian. The `value` must be a valid unsigned 32-bit
+   * integer. Behavior is undefined when `value` is anything other than an unsigned 32-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUInt32LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 4, 4294967295, 0);
+    }
+    this[offset + 3] = value >>> 24;
+    this[offset + 2] = value >>> 16;
+    this[offset + 1] = value >>> 8;
+    this[offset] = value & 255;
+    return offset + 4;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as big-endian. The `value` must be a valid unsigned 32-bit
+   * integer. Behavior is undefined when `value` is anything other than an unsigned 32-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeUInt32BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 4, 4294967295, 0);
+    }
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset`. The `value` must be a valid signed 8-bit integer.
+   * Behavior is undefined when `value` is anything other than a signed 8-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeInt8(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 1, 127, -128);
+    }
+    if (value < 0) {
+      value = 255 + value + 1;
+    }
+    this[offset] = value & 255;
+    return offset + 1;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as little-endian. The `value` must be a valid signed 16-bit
+   * integer. Behavior is undefined when `value` is anything other than a signed 16-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeInt16LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 2, 32767, -32768);
+    }
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    return offset + 2;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as big-endian. The `value` must be a valid signed 16-bit
+   * integer. Behavior is undefined when `value` is anything other than a signed 16-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeInt16BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 2, 32767, -32768);
+    }
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as little-endian. The `value` must be a valid signed 32-bit
+   * integer. Behavior is undefined when `value` is anything other than a signed 32-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeInt32LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    }
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    this[offset + 2] = value >>> 16;
+    this[offset + 3] = value >>> 24;
+    return offset + 4;
+  }
+  /**
+   * Writes `value` to `buf` at the specified `offset` as big-endian. The `value` must be a valid signed 32-bit
+   * integer. Behavior is undefined when `value` is anything other than a signed 32-bit integer.
+   *
+   * @param value Number to write.
+   * @param offset Number of bytes to skip before starting to write.
+   * @param noAssert
+   * @returns `offset` plus the number of bytes written.
+   */
+  writeInt32BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      Buffer._checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    }
+    if (value < 0) {
+      value = 4294967295 + value + 1;
+    }
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  }
+  /**
+   * Fills `buf` with the specified `value`. If the `offset` and `end` are not given, the entire `buf` will be
+   * filled. The `value` is coerced to a `uint32` value if it is not a string, `Buffer`, or integer. If the resulting
+   * integer is greater than `255` (decimal), then `buf` will be filled with `value & 255`.
+   *
+   * If the final write of a `fill()` operation falls on a multi-byte character, then only the bytes of that
+   * character that fit into `buf` are written.
+   *
+   * If `value` contains invalid characters, it is truncated; if no valid fill data remains, an exception is thrown.
+   *
+   * @param value
+   * @param encoding
+   */
+  fill(value, offset, end, encoding) {
+    if (typeof value === "string") {
+      if (typeof offset === "string") {
+        encoding = offset;
+        offset = 0;
+        end = this.length;
+      } else if (typeof end === "string") {
+        encoding = end;
+        end = this.length;
+      }
+      if (encoding !== void 0 && typeof encoding !== "string") {
+        throw new TypeError("encoding must be a string");
+      }
+      if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      if (value.length === 1) {
+        const code = value.charCodeAt(0);
+        if (encoding === "utf8" && code < 128) {
+          value = code;
+        }
+      }
+    } else if (typeof value === "number") {
+      value = value & 255;
+    } else if (typeof value === "boolean") {
+      value = Number(value);
+    }
+    offset ?? (offset = 0);
+    end ?? (end = this.length);
+    if (offset < 0 || this.length < offset || this.length < end) {
+      throw new RangeError("Out of range index");
+    }
+    if (end <= offset) {
+      return this;
+    }
+    offset = offset >>> 0;
+    end = end === void 0 ? this.length : end >>> 0;
+    value || (value = 0);
+    let i;
+    if (typeof value === "number") {
+      for (i = offset; i < end; ++i) {
+        this[i] = value;
+      }
+    } else {
+      const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value, encoding);
+      const len = bytes.length;
+      if (len === 0) {
+        throw new TypeError('The value "' + value + '" is invalid for argument "value"');
+      }
+      for (i = 0; i < end - offset; ++i) {
+        this[i + offset] = bytes[i % len];
+      }
+    }
+    return this;
+  }
+  /**
+   * Returns the index of the specified value.
+   *
+   * If `value` is:
+   * - a string, `value` is interpreted according to the character encoding in `encoding`.
+   * - a `Buffer` or `Uint8Array`, `value` will be used in its entirety. To compare a partial Buffer, use `slice()`.
+   * - a number, `value` will be interpreted as an unsigned 8-bit integer value between `0` and `255`.
+   *
+   * Any other types will throw a `TypeError`.
+   *
+   * @param value What to search for.
+   * @param byteOffset Where to begin searching in `buf`. If negative, then calculated from the end.
+   * @param encoding If `value` is a string, this is the encoding used to search.
+   * @returns The index of the first occurrence of `value` in `buf`, or `-1` if not found.
+   */
+  indexOf(value, byteOffset, encoding) {
+    return this._bidirectionalIndexOf(this, value, byteOffset, encoding, true);
+  }
+  /**
+   * Gets the last index of the specified value.
+   *
+   * @see indexOf()
+   * @param value
+   * @param byteOffset
+   * @param encoding
+   */
+  lastIndexOf(value, byteOffset, encoding) {
+    return this._bidirectionalIndexOf(this, value, byteOffset, encoding, false);
+  }
+  _bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+    if (buffer.length === 0) {
+      return -1;
+    }
+    if (typeof byteOffset === "string") {
+      encoding = byteOffset;
+      byteOffset = 0;
+    } else if (typeof byteOffset === "undefined") {
+      byteOffset = 0;
+    } else if (byteOffset > 2147483647) {
+      byteOffset = 2147483647;
+    } else if (byteOffset < -2147483648) {
+      byteOffset = -2147483648;
+    }
+    byteOffset = +byteOffset;
+    if (byteOffset !== byteOffset) {
+      byteOffset = dir ? 0 : buffer.length - 1;
+    }
+    if (byteOffset < 0) {
+      byteOffset = buffer.length + byteOffset;
+    }
+    if (byteOffset >= buffer.length) {
+      if (dir) {
+        return -1;
+      } else {
+        byteOffset = buffer.length - 1;
+      }
+    } else if (byteOffset < 0) {
+      if (dir) {
+        byteOffset = 0;
+      } else {
+        return -1;
+      }
+    }
+    if (typeof val === "string") {
+      val = Buffer.from(val, encoding);
+    }
+    if (Buffer.isBuffer(val)) {
+      if (val.length === 0) {
+        return -1;
+      }
+      return Buffer._arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+    } else if (typeof val === "number") {
+      val = val & 255;
+      if (typeof Uint8Array.prototype.indexOf === "function") {
+        if (dir) {
+          return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+        } else {
+          return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+        }
+      }
+      return Buffer._arrayIndexOf(buffer, Buffer.from([val]), byteOffset, encoding, dir);
+    }
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  /**
+   * Equivalent to `buf.indexOf() !== -1`.
+   *
+   * @param value
+   * @param byteOffset
+   * @param encoding
+   */
+  includes(value, byteOffset, encoding) {
+    return this.indexOf(value, byteOffset, encoding) !== -1;
+  }
+  /**
+   * Creates a new buffer from the given parameters.
+   *
+   * @param data
+   * @param encoding
+   */
+  static from(a, b, c) {
+    return new Buffer(a, b, c);
+  }
+  /**
+   * Returns true if `obj` is a Buffer.
+   *
+   * @param obj
+   */
+  static isBuffer(obj) {
+    return obj != null && obj !== Buffer.prototype && Buffer._isInstance(obj, Buffer);
+  }
+  /**
+   * Returns true if `encoding` is a supported encoding.
+   *
+   * @param encoding
+   */
+  static isEncoding(encoding) {
+    switch (encoding.toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "ascii":
+      case "binary":
+      case "latin1":
+      case "ucs2":
+      case "utf16le":
+      case "base64":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Gives the actual byte length of a string for an encoding. This is not the same as `string.length` since that
+   * returns the number of characters in the string.
+   *
+   * @param string The string to test.
+   * @param encoding The encoding to use for calculation. Defaults is `utf8`.
+   */
+  static byteLength(string, encoding) {
+    if (Buffer.isBuffer(string)) {
+      return string.length;
+    }
+    if (typeof string !== "string" && (ArrayBuffer.isView(string) || Buffer._isInstance(string, ArrayBuffer))) {
+      return string.byteLength;
+    }
+    if (typeof string !== "string") {
+      throw new TypeError(
+        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+      );
+    }
+    const len = string.length;
+    const mustMatch = arguments.length > 2 && arguments[2] === true;
+    if (!mustMatch && len === 0) {
+      return 0;
+    }
+    switch (encoding?.toLowerCase()) {
+      case "ascii":
+      case "latin1":
+      case "binary":
+        return len;
+      case "utf8":
+        return Buffer._utf8ToBytes(string).length;
+      case "hex":
+        return len >>> 1;
+      case "ucs2":
+      case "utf16le":
+        return len * 2;
+      case "base64":
+        return Buffer._base64ToBytes(string).length;
+      default:
+        return mustMatch ? -1 : Buffer._utf8ToBytes(string).length;
+    }
+  }
+  /**
+   * Returns a Buffer which is the result of concatenating all the buffers in the list together.
+   *
+   * - If the list has no items, or if the `totalLength` is 0, then it returns a zero-length buffer.
+   * - If the list has exactly one item, then the first item is returned.
+   * - If the list has more than one item, then a new buffer is created.
+   *
+   * It is faster to provide the `totalLength` if it is known. However, it will be calculated if not provided at
+   * a small computational expense.
+   *
+   * @param list An array of Buffer objects to concatenate.
+   * @param totalLength Total length of the buffers when concatenated.
+   */
+  static concat(list, totalLength) {
+    if (!Array.isArray(list)) {
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    }
+    if (list.length === 0) {
+      return Buffer.alloc(0);
+    }
+    let i;
+    if (totalLength === void 0) {
+      totalLength = 0;
+      for (i = 0; i < list.length; ++i) {
+        totalLength += list[i].length;
+      }
+    }
+    const buffer = Buffer.allocUnsafe(totalLength);
+    let pos = 0;
+    for (i = 0; i < list.length; ++i) {
+      let buf = list[i];
+      if (Buffer._isInstance(buf, Uint8Array)) {
+        if (pos + buf.length > buffer.length) {
+          if (!Buffer.isBuffer(buf)) {
+            buf = Buffer.from(buf);
+          }
+          buf.copy(buffer, pos);
+        } else {
+          Uint8Array.prototype.set.call(buffer, buf, pos);
+        }
+      } else if (!Buffer.isBuffer(buf)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      } else {
+        buf.copy(buffer, pos);
+      }
+      pos += buf.length;
+    }
+    return buffer;
+  }
+  /**
+   * The same as `buf1.compare(buf2)`.
+   */
+  static compare(buf1, buf2) {
+    if (Buffer._isInstance(buf1, Uint8Array)) {
+      buf1 = Buffer.from(buf1, buf1.byteOffset, buf1.byteLength);
+    }
+    if (Buffer._isInstance(buf2, Uint8Array)) {
+      buf2 = Buffer.from(buf2, buf2.byteOffset, buf2.byteLength);
+    }
+    if (!Buffer.isBuffer(buf1) || !Buffer.isBuffer(buf2)) {
+      throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+    }
+    if (buf1 === buf2) {
+      return 0;
+    }
+    let x = buf1.length;
+    let y = buf2.length;
+    for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+      if (buf1[i] !== buf2[i]) {
+        x = buf1[i];
+        y = buf2[i];
+        break;
+      }
+    }
+    if (x < y) {
+      return -1;
+    }
+    if (y < x) {
+      return 1;
+    }
+    return 0;
+  }
+  /**
+   * Allocates a new buffer of `size` octets.
+   *
+   * @param size The number of octets to allocate.
+   * @param fill If specified, the buffer will be initialized by calling `buf.fill(fill)`, or with zeroes otherwise.
+   * @param encoding The encoding used for the call to `buf.fill()` while initializing.
+   */
+  static alloc(size, fill, encoding) {
+    if (typeof size !== "number") {
+      throw new TypeError('"size" argument must be of type number');
+    } else if (size < 0) {
+      throw new RangeError('The value "' + size + '" is invalid for option "size"');
+    }
+    if (size <= 0) {
+      return new Buffer(size);
+    }
+    if (fill !== void 0) {
+      return typeof encoding === "string" ? new Buffer(size).fill(fill, 0, size, encoding) : new Buffer(size).fill(fill);
+    }
+    return new Buffer(size);
+  }
+  /**
+   * Allocates a new buffer of `size` octets without initializing memory. The contents of the buffer are unknown.
+   *
+   * @param size
+   */
+  static allocUnsafe(size) {
+    if (typeof size !== "number") {
+      throw new TypeError('"size" argument must be of type number');
+    } else if (size < 0) {
+      throw new RangeError('The value "' + size + '" is invalid for option "size"');
+    }
+    return new Buffer(size < 0 ? 0 : Buffer._checked(size) | 0);
+  }
+  /**
+   * Returns true if the given `obj` is an instance of `type`.
+   *
+   * @param obj
+   * @param type
+   */
+  static _isInstance(obj, type) {
+    return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+  }
+  static _checked(length) {
+    if (length >= K_MAX_LENGTH) {
+      throw new RangeError(
+        "Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes"
+      );
+    }
+    return length | 0;
+  }
+  static _blitBuffer(src, dst, offset, length) {
+    let i;
+    for (i = 0; i < length; ++i) {
+      if (i + offset >= dst.length || i >= src.length) {
+        break;
+      }
+      dst[i + offset] = src[i];
+    }
+    return i;
+  }
+  static _utf8Write(buf, string, offset, length) {
+    return Buffer._blitBuffer(Buffer._utf8ToBytes(string, buf.length - offset), buf, offset, length);
+  }
+  static _asciiWrite(buf, string, offset, length) {
+    return Buffer._blitBuffer(Buffer._asciiToBytes(string), buf, offset, length);
+  }
+  static _base64Write(buf, string, offset, length) {
+    return Buffer._blitBuffer(Buffer._base64ToBytes(string), buf, offset, length);
+  }
+  static _ucs2Write(buf, string, offset, length) {
+    return Buffer._blitBuffer(Buffer._utf16leToBytes(string, buf.length - offset), buf, offset, length);
+  }
+  static _hexWrite(buf, string, offset, length) {
+    offset = Number(offset) || 0;
+    const remaining = buf.length - offset;
+    if (!length) {
+      length = remaining;
+    } else {
+      length = Number(length);
+      if (length > remaining) {
+        length = remaining;
+      }
+    }
+    const strLen = string.length;
+    if (length > strLen / 2) {
+      length = strLen / 2;
+    }
+    let i;
+    for (i = 0; i < length; ++i) {
+      const parsed = parseInt(string.substr(i * 2, 2), 16);
+      if (parsed !== parsed) {
+        return i;
+      }
+      buf[offset + i] = parsed;
+    }
+    return i;
+  }
+  static _utf8ToBytes(string, units) {
+    units = units || Infinity;
+    const length = string.length;
+    const bytes = [];
+    let codePoint;
+    let leadSurrogate = null;
+    for (let i = 0; i < length; ++i) {
+      codePoint = string.charCodeAt(i);
+      if (codePoint > 55295 && codePoint < 57344) {
+        if (!leadSurrogate) {
+          if (codePoint > 56319) {
+            if ((units -= 3) > -1) {
+              bytes.push(239, 191, 189);
+            }
+            continue;
+          } else if (i + 1 === length) {
+            if ((units -= 3) > -1) {
+              bytes.push(239, 191, 189);
+            }
+            continue;
+          }
+          leadSurrogate = codePoint;
+          continue;
+        }
+        if (codePoint < 56320) {
+          if ((units -= 3) > -1) {
+            bytes.push(239, 191, 189);
+          }
+          leadSurrogate = codePoint;
+          continue;
+        }
+        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+      } else if (leadSurrogate) {
+        if ((units -= 3) > -1) {
+          bytes.push(239, 191, 189);
+        }
+      }
+      leadSurrogate = null;
+      if (codePoint < 128) {
+        if ((units -= 1) < 0) {
+          break;
+        }
+        bytes.push(codePoint);
+      } else if (codePoint < 2048) {
+        if ((units -= 2) < 0) {
+          break;
+        }
+        bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+      } else if (codePoint < 65536) {
+        if ((units -= 3) < 0) {
+          break;
+        }
+        bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+      } else if (codePoint < 1114112) {
+        if ((units -= 4) < 0) {
+          break;
+        }
+        bytes.push(
+          codePoint >> 18 | 240,
+          codePoint >> 12 & 63 | 128,
+          codePoint >> 6 & 63 | 128,
+          codePoint & 63 | 128
+        );
+      } else {
+        throw new Error("Invalid code point");
+      }
+    }
+    return bytes;
+  }
+  static _base64ToBytes(str) {
+    return toByteArray(base64clean(str));
+  }
+  static _asciiToBytes(str) {
+    const byteArray = [];
+    for (let i = 0; i < str.length; ++i) {
+      byteArray.push(str.charCodeAt(i) & 255);
+    }
+    return byteArray;
+  }
+  static _utf16leToBytes(str, units) {
+    let c, hi, lo;
+    const byteArray = [];
+    for (let i = 0; i < str.length; ++i) {
+      if ((units -= 2) < 0) break;
+      c = str.charCodeAt(i);
+      hi = c >> 8;
+      lo = c % 256;
+      byteArray.push(lo);
+      byteArray.push(hi);
+    }
+    return byteArray;
+  }
+  static _hexSlice(buf, start, end) {
+    const len = buf.length;
+    if (!start || start < 0) {
+      start = 0;
+    }
+    if (!end || end < 0 || end > len) {
+      end = len;
+    }
+    let out = "";
+    for (let i = start; i < end; ++i) {
+      out += hexSliceLookupTable[buf[i]];
+    }
+    return out;
+  }
+  static _base64Slice(buf, start, end) {
+    if (start === 0 && end === buf.length) {
+      return fromByteArray(buf);
+    } else {
+      return fromByteArray(buf.slice(start, end));
+    }
+  }
+  static _utf8Slice(buf, start, end) {
+    end = Math.min(buf.length, end);
+    const res = [];
+    let i = start;
+    while (i < end) {
+      const firstByte = buf[i];
+      let codePoint = null;
+      let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+      if (i + bytesPerSequence <= end) {
+        let secondByte, thirdByte, fourthByte, tempCodePoint;
+        switch (bytesPerSequence) {
+          case 1:
+            if (firstByte < 128) {
+              codePoint = firstByte;
+            }
+            break;
+          case 2:
+            secondByte = buf[i + 1];
+            if ((secondByte & 192) === 128) {
+              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+              if (tempCodePoint > 127) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 3:
+            secondByte = buf[i + 1];
+            thirdByte = buf[i + 2];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 4:
+            secondByte = buf[i + 1];
+            thirdByte = buf[i + 2];
+            fourthByte = buf[i + 3];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                codePoint = tempCodePoint;
+              }
+            }
+        }
+      }
+      if (codePoint === null) {
+        codePoint = 65533;
+        bytesPerSequence = 1;
+      } else if (codePoint > 65535) {
+        codePoint -= 65536;
+        res.push(codePoint >>> 10 & 1023 | 55296);
+        codePoint = 56320 | codePoint & 1023;
+      }
+      res.push(codePoint);
+      i += bytesPerSequence;
+    }
+    return Buffer._decodeCodePointsArray(res);
+  }
+  static _decodeCodePointsArray(codePoints) {
+    const len = codePoints.length;
+    if (len <= MAX_ARGUMENTS_LENGTH) {
+      return String.fromCharCode.apply(String, codePoints);
+    }
+    let res = "";
+    let i = 0;
+    while (i < len) {
+      res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+    }
+    return res;
+  }
+  static _asciiSlice(buf, start, end) {
+    let ret = "";
+    end = Math.min(buf.length, end);
+    for (let i = start; i < end; ++i) {
+      ret += String.fromCharCode(buf[i] & 127);
+    }
+    return ret;
+  }
+  static _latin1Slice(buf, start, end) {
+    let ret = "";
+    end = Math.min(buf.length, end);
+    for (let i = start; i < end; ++i) {
+      ret += String.fromCharCode(buf[i]);
+    }
+    return ret;
+  }
+  static _utf16leSlice(buf, start, end) {
+    const bytes = buf.slice(start, end);
+    let res = "";
+    for (let i = 0; i < bytes.length - 1; i += 2) {
+      res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+    }
+    return res;
+  }
+  static _arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+    let indexSize = 1;
+    let arrLength = arr.length;
+    let valLength = val.length;
+    if (encoding !== void 0) {
+      encoding = Buffer._getEncoding(encoding);
+      if (encoding === "ucs2" || encoding === "utf16le") {
+        if (arr.length < 2 || val.length < 2) {
+          return -1;
+        }
+        indexSize = 2;
+        arrLength /= 2;
+        valLength /= 2;
+        byteOffset /= 2;
+      }
+    }
+    function read(buf, i2) {
+      if (indexSize === 1) {
+        return buf[i2];
+      } else {
+        return buf.readUInt16BE(i2 * indexSize);
+      }
+    }
+    let i;
+    if (dir) {
+      let foundIndex = -1;
+      for (i = byteOffset; i < arrLength; i++) {
+        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+          if (foundIndex === -1) foundIndex = i;
+          if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+        } else {
+          if (foundIndex !== -1) i -= i - foundIndex;
+          foundIndex = -1;
+        }
+      }
+    } else {
+      if (byteOffset + valLength > arrLength) {
+        byteOffset = arrLength - valLength;
+      }
+      for (i = byteOffset; i >= 0; i--) {
+        let found = true;
+        for (let j = 0; j < valLength; j++) {
+          if (read(arr, i + j) !== read(val, j)) {
+            found = false;
+            break;
+          }
+        }
+        if (found) {
+          return i;
+        }
+      }
+    }
+    return -1;
+  }
+  static _checkOffset(offset, ext, length) {
+    if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+    if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
+  }
+  static _checkInt(buf, value, offset, ext, max, min) {
+    if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+    if (offset + ext > buf.length) throw new RangeError("Index out of range");
+  }
+  static _getEncoding(encoding) {
+    let toLowerCase = false;
+    let originalEncoding = "";
+    for (; ; ) {
+      switch (encoding) {
+        case "hex":
+          return "hex";
+        case "utf8":
+          return "utf8";
+        case "ascii":
+          return "ascii";
+        case "binary":
+          return "binary";
+        case "latin1":
+          return "latin1";
+        case "ucs2":
+          return "ucs2";
+        case "utf16le":
+          return "utf16le";
+        case "base64":
+          return "base64";
+        default: {
+          if (toLowerCase) {
+            throw new TypeError("Unknown or unsupported encoding: " + originalEncoding);
+          }
+          toLowerCase = true;
+          originalEncoding = encoding;
+          encoding = encoding.toLowerCase();
+        }
+      }
+    }
+  }
+}
+const hexSliceLookupTable = function() {
+  const alphabet = "0123456789abcdef";
+  const table = new Array(256);
+  for (let i = 0; i < 16; ++i) {
+    const i16 = i * 16;
+    for (let j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet[i] + alphabet[j];
+    }
+  }
+  return table;
+}();
+const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+function base64clean(str) {
+  str = str.split("=")[0];
+  str = str.trim().replace(INVALID_BASE64_RE, "");
+  if (str.length < 2) return "";
+  while (str.length % 4 !== 0) {
+    str = str + "=";
+  }
+  return str;
+}
+
 function notEmpty(value) {
   return value !== null && value !== void 0;
 }
@@ -118,155 +1901,15 @@ function promiseMap(inputValues, mapper) {
   return inputValues.reduce(reducer, Promise.resolve([]));
 }
 
-function getEnvironment() {
-  try {
-    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(),
-        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) {
-  }
-  try {
-    if (isObject(Deno) && isObject(Deno.env)) {
-      return {
-        apiKey: Deno.env.get("XATA_API_KEY") ?? getGlobalApiKey(),
-        databaseURL: Deno.env.get("XATA_DATABASE_URL") ?? getGlobalDatabaseURL(),
-        branch: Deno.env.get("XATA_BRANCH") ?? getGlobalBranch(),
-        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) {
-  }
-  return {
-    apiKey: getGlobalApiKey(),
-    databaseURL: getGlobalDatabaseURL(),
-    branch: getGlobalBranch(),
-    deployPreview: void 0,
-    deployPreviewBranch: void 0,
-    vercelGitCommitRef: void 0,
-    vercelGitRepoOwner: void 0
-  };
-}
-function getEnableBrowserVariable() {
-  try {
-    if (isObject(process) && isObject(process.env) && process.env.XATA_ENABLE_BROWSER !== void 0) {
-      return process.env.XATA_ENABLE_BROWSER === "true";
-    }
-  } catch (err) {
-  }
-  try {
-    if (isObject(Deno) && isObject(Deno.env) && Deno.env.get("XATA_ENABLE_BROWSER") !== void 0) {
-      return Deno.env.get("XATA_ENABLE_BROWSER") === "true";
-    }
-  } catch (err) {
-  }
-  try {
-    return XATA_ENABLE_BROWSER === true || XATA_ENABLE_BROWSER === "true";
-  } catch (err) {
-    return void 0;
-  }
-}
-function getGlobalApiKey() {
-  try {
-    return XATA_API_KEY;
-  } catch (err) {
-    return void 0;
-  }
-}
-function getGlobalDatabaseURL() {
-  try {
-    return XATA_DATABASE_URL;
-  } catch (err) {
-    return void 0;
-  }
-}
-function getGlobalBranch() {
-  try {
-    return XATA_BRANCH;
-  } catch (err) {
-    return void 0;
-  }
-}
-function getDatabaseURL() {
-  try {
-    const { databaseURL } = getEnvironment();
-    return databaseURL;
-  } catch (err) {
-    return void 0;
-  }
-}
-function getAPIKey() {
-  try {
-    const { apiKey } = getEnvironment();
-    return apiKey;
-  } catch (err) {
-    return void 0;
-  }
-}
-function getBranch() {
-  try {
-    const { branch } = getEnvironment();
-    return branch;
-  } catch (err) {
-    return void 0;
-  }
-}
-function buildPreviewBranchName({ org, branch }) {
-  return `preview-${org}-${branch}`;
-}
-function getPreviewBranch() {
-  try {
-    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$6 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$6(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$6 = (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 __typeError$6 = (msg) => {
+  throw TypeError(msg);
 };
-var __privateSet$4 = (obj, member, value, setter) => {
-  __accessCheck$6(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod$4 = (obj, member, method) => {
-  __accessCheck$6(obj, member, "access private method");
-  return method;
-};
-var _fetch, _queue, _concurrency, _enqueue, enqueue_fn;
+var __accessCheck$6 = (obj, member, msg) => member.has(obj) || __typeError$6("Cannot " + msg);
+var __privateGet$5 = (obj, member, getter) => (__accessCheck$6(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$6 = (obj, member, value) => member.has(obj) ? __typeError$6("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$4 = (obj, member, value, setter) => (__accessCheck$6(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod$4 = (obj, member, method) => (__accessCheck$6(obj, member, "access private method"), method);
+var _fetch, _queue, _concurrency, _ApiRequestPool_instances, enqueue_fn;
 const REQUEST_TIMEOUT = 5 * 60 * 1e3;
 function getFetchImplementation(userFetch) {
   const globalFetch = typeof fetch !== "undefined" ? fetch : void 0;
@@ -279,10 +1922,10 @@ function getFetchImplementation(userFetch) {
 }
 class ApiRequestPool {
   constructor(concurrency = 10) {
-    __privateAdd$6(this, _enqueue);
-    __privateAdd$6(this, _fetch, void 0);
-    __privateAdd$6(this, _queue, void 0);
-    __privateAdd$6(this, _concurrency, void 0);
+    __privateAdd$6(this, _ApiRequestPool_instances);
+    __privateAdd$6(this, _fetch);
+    __privateAdd$6(this, _queue);
+    __privateAdd$6(this, _concurrency);
     __privateSet$4(this, _queue, []);
     __privateSet$4(this, _concurrency, concurrency);
     this.running = 0;
@@ -317,7 +1960,7 @@ class ApiRequestPool {
       }
       return response;
     };
-    return __privateMethod$4(this, _enqueue, enqueue_fn).call(this, async () => {
+    return __privateMethod$4(this, _ApiRequestPool_instances, enqueue_fn).call(this, async () => {
       return await runRequest();
     });
   }
@@ -325,7 +1968,7 @@ class ApiRequestPool {
 _fetch = new WeakMap();
 _queue = new WeakMap();
 _concurrency = new WeakMap();
-_enqueue = new WeakSet();
+_ApiRequestPool_instances = new WeakSet();
 enqueue_fn = function(task) {
   const promise = new Promise((resolve) => __privateGet$5(this, _queue).push(resolve)).finally(() => {
     this.started--;
@@ -528,7 +2171,7 @@ function defaultOnOpen(response) {
   }
 }
 
-const VERSION = "0.29.2";
+const VERSION = "0.29.4";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -608,35 +2251,30 @@ function parseProviderString(provider = "production") {
     return provider;
   }
   const [main, workspaces] = provider.split(",");
-  if (!main || !workspaces)
-    return null;
+  if (!main || !workspaces) return null;
   return { main, workspaces };
 }
 function buildProviderString(provider) {
-  if (isHostProviderAlias(provider))
-    return provider;
+  if (isHostProviderAlias(provider)) return provider;
   return `${provider.main},${provider.workspaces}`;
 }
 function parseWorkspacesUrlParts(url) {
-  if (!isString(url))
-    return null;
+  if (!isString(url)) return null;
   const matches = {
     production: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.sh\/db\/([^:]+):?(.*)?/),
     staging: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.staging-xata\.dev\/db\/([^:]+):?(.*)?/),
     dev: url.match(/(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.dev-xata\.dev\/db\/([^:]+):?(.*)?/),
-    local: url.match(/(?:https?:\/\/)?([^.]+)(?:\.([^.]+))\.localhost:([^:]+):?(.*)?/)
+    local: url.match(/(?:https?:\/\/)?([^.]+)(?:\.([^.]+))\.localhost:(?:\d+)\/db\/([^:]+):?(.*)?/)
   };
   const [host, match] = Object.entries(matches).find(([, match2]) => match2 !== null) ?? [];
-  if (!isHostProviderAlias(host) || !match)
-    return null;
+  if (!isHostProviderAlias(host) || !match) return null;
   return { workspace: match[1], region: match[2], database: match[3], branch: match[4], 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)
-      return acc;
+    if (value === void 0 || value === null) return acc;
     return { ...acc, [key]: value };
   }, {});
   const query = new URLSearchParams(cleanQueryParams).toString();
@@ -684,8 +2322,7 @@ function hostHeader(url) {
   return groups?.host ? { Host: groups.host } : {};
 }
 async function parseBody(body, headers) {
-  if (!isDefined(body))
-    return void 0;
+  if (!isDefined(body)) return void 0;
   if (isBlob(body) || typeof body.text === "function") {
     return body;
   }
@@ -764,8 +2401,7 @@ async function fetch$1({
         [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 (message) console.warn(message);
       if (response.status === 204) {
         return {};
       }
@@ -849,16 +2485,48 @@ function parseUrl(url) {
 
 const dataPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "dataPlane" });
 
-const applyMigration = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/apply", method: "post", ...variables, signal });
+const applyMigration = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/apply",
+  method: "post",
+  ...variables,
+  signal
+});
+const startMigration = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/start",
+  method: "post",
+  ...variables,
+  signal
+});
 const adaptTable = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/migrations/adapt/{tableName}",
   method: "post",
   ...variables,
   signal
 });
-const getBranchMigrationJobStatus = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/status", method: "get", ...variables, signal });
-const getMigrationJobStatus = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/jobs/{jobId}", method: "get", ...variables, signal });
-const getMigrationHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/history", method: "get", ...variables, signal });
+const adaptAllTables = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/adapt",
+  method: "post",
+  ...variables,
+  signal
+});
+const getBranchMigrationJobStatus = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/status",
+  method: "get",
+  ...variables,
+  signal
+});
+const getMigrationJobStatus = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/jobs/{jobId}",
+  method: "get",
+  ...variables,
+  signal
+});
+const getMigrationHistory = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/history",
+  method: "get",
+  ...variables,
+  signal
+});
 const getBranchList = (variables, signal) => dataPlaneFetch({
   url: "/dbs/{dbName}",
   method: "get",
@@ -871,82 +2539,167 @@ const getDatabaseSettings = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
-const updateDatabaseSettings = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/settings", method: "patch", ...variables, signal });
-const getBranchDetails = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}",
+const updateDatabaseSettings = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/settings", method: "patch", ...variables, signal });
+const getBranchDetails = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}",
+  method: "get",
+  ...variables,
+  signal
+});
+const createBranch = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}", method: "put", ...variables, signal });
+const deleteBranch = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const 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",
+  ...variables,
+  signal
+});
+const getBranchMetadata = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/metadata",
+  method: "get",
+  ...variables,
+  signal
+});
+const getBranchStats = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/stats",
+  method: "get",
+  ...variables,
+  signal
+});
+const getGitBranchesMapping = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables, signal });
+const addGitBranchesEntry = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables, signal });
+const removeGitBranchesEntry = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/gitBranches",
+  method: "delete",
+  ...variables,
+  signal
+});
+const resolveBranch = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/resolveBranch",
+  method: "get",
+  ...variables,
+  signal
+});
+const getBranchMigrationHistory = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations",
+  method: "get",
+  ...variables,
+  signal
+});
+const getBranchMigrationPlan = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/plan",
+  method: "post",
+  ...variables,
+  signal
+});
+const executeBranchMigrationPlan = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/migrations/execute",
+  method: "post",
+  ...variables,
+  signal
+});
+const queryMigrationRequests = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/query",
+  method: "post",
+  ...variables,
+  signal
+});
+const createMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations", method: "post", ...variables, signal });
+const getMigrationRequest = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateMigrationRequest = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}",
+  method: "patch",
+  ...variables,
+  signal
+});
+const listMigrationRequestsCommits = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}/commits",
+  method: "post",
+  ...variables,
+  signal
+});
+const compareMigrationRequest = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}/compare",
+  method: "post",
+  ...variables,
+  signal
+});
+const getMigrationRequestIsMerged = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}/merge",
   method: "get",
   ...variables,
   signal
 });
-const createBranch = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}", method: "put", ...variables, signal });
-const deleteBranch = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}",
-  method: "delete",
+const mergeMigrationRequest = (variables, signal) => dataPlaneFetch({
+  url: "/dbs/{dbName}/migrations/{mrNumber}/merge",
+  method: "post",
   ...variables,
   signal
 });
-const getSchema = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}/schema",
-  method: "get",
+const getBranchSchemaHistory = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/history",
+  method: "post",
   ...variables,
   signal
 });
-const copyBranch = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}/copy",
+const compareBranchWithUserSchema = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/compare",
   method: "post",
   ...variables,
   signal
 });
-const updateBranchMetadata = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}/metadata",
-  method: "put",
+const compareBranchSchemas = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/compare/{branchName}",
+  method: "post",
   ...variables,
   signal
 });
-const getBranchMetadata = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}/metadata",
-  method: "get",
+const updateBranchSchema = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/update",
+  method: "post",
   ...variables,
   signal
 });
-const getBranchStats = (variables, signal) => dataPlaneFetch({
-  url: "/db/{dbBranchName}/stats",
-  method: "get",
+const previewBranchSchemaEdit = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/preview",
+  method: "post",
   ...variables,
   signal
 });
-const getGitBranchesMapping = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables, signal });
-const addGitBranchesEntry = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables, signal });
-const removeGitBranchesEntry = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables, signal });
-const resolveBranch = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/resolveBranch", method: "get", ...variables, signal });
-const getBranchMigrationHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations", method: "get", ...variables, signal });
-const getBranchMigrationPlan = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/plan", method: "post", ...variables, signal });
-const executeBranchMigrationPlan = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/migrations/execute", method: "post", ...variables, signal });
-const queryMigrationRequests = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/query", method: "post", ...variables, signal });
-const createMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations", method: "post", ...variables, signal });
-const getMigrationRequest = (variables, signal) => dataPlaneFetch({
-  url: "/dbs/{dbName}/migrations/{mrNumber}",
-  method: "get",
+const applyBranchSchemaEdit = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/apply",
+  method: "post",
   ...variables,
   signal
 });
-const updateMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}", method: "patch", ...variables, signal });
-const listMigrationRequestsCommits = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}/commits", method: "post", ...variables, signal });
-const compareMigrationRequest = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}/compare", method: "post", ...variables, signal });
-const getMigrationRequestIsMerged = (variables, signal) => dataPlaneFetch({ url: "/dbs/{dbName}/migrations/{mrNumber}/merge", method: "get", ...variables, signal });
-const mergeMigrationRequest = (variables, signal) => dataPlaneFetch({
-  url: "/dbs/{dbName}/migrations/{mrNumber}/merge",
+const pushBranchMigrations = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/schema/push",
   method: "post",
   ...variables,
   signal
 });
-const getBranchSchemaHistory = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/history", method: "post", ...variables, signal });
-const compareBranchWithUserSchema = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/compare", method: "post", ...variables, signal });
-const compareBranchSchemas = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/compare/{branchName}", method: "post", ...variables, signal });
-const updateBranchSchema = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/update", method: "post", ...variables, signal });
-const previewBranchSchemaEdit = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/preview", method: "post", ...variables, signal });
-const applyBranchSchemaEdit = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/schema/apply", method: "post", ...variables, signal });
-const 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",
@@ -959,14 +2712,24 @@ const deleteTable = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
-const updateTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}", method: "patch", ...variables, signal });
+const updateTable = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}",
+  method: "patch",
+  ...variables,
+  signal
+});
 const getTableSchema = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/schema",
   method: "get",
   ...variables,
   signal
 });
-const setTableSchema = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/schema", method: "put", ...variables, signal });
+const setTableSchema = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/schema",
+  method: "put",
+  ...variables,
+  signal
+});
 const getTableColumns = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/columns",
   method: "get",
@@ -974,7 +2737,12 @@ const getTableColumns = (variables, signal) => dataPlaneFetch({
   signal
 });
 const addTableColumn = (variables, signal) => dataPlaneFetch(
-  { url: "/db/{dbBranchName}/tables/{tableName}/columns", method: "post", ...variables, signal }
+  {
+    url: "/db/{dbBranchName}/tables/{tableName}/columns",
+    method: "post",
+    ...variables,
+    signal
+  }
 );
 const getColumn = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
@@ -982,15 +2750,30 @@ const getColumn = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
-const updateColumn = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}", method: "patch", ...variables, signal });
+const updateColumn = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
+  method: "patch",
+  ...variables,
+  signal
+});
 const deleteColumn = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
   method: "delete",
   ...variables,
   signal
 });
-const 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 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",
@@ -1033,11 +2816,36 @@ const getRecord = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
-const insertRecordWithID = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "put", ...variables, signal });
-const updateRecordWithID = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "patch", ...variables, signal });
-const upsertRecordWithID = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "post", ...variables, signal });
-const deleteRecord = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "delete", ...variables, signal });
-const bulkInsertTableRecords = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables, signal });
+const insertRecordWithID = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+  method: "put",
+  ...variables,
+  signal
+});
+const updateRecordWithID = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+  method: "patch",
+  ...variables,
+  signal
+});
+const upsertRecordWithID = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+  method: "post",
+  ...variables,
+  signal
+});
+const deleteRecord = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const bulkInsertTableRecords = (variables, signal) => dataPlaneFetch({
+  url: "/db/{dbBranchName}/tables/{tableName}/bulk",
+  method: "post",
+  ...variables,
+  signal
+});
 const queryTable = (variables, signal) => dataPlaneFetch({
   url: "/db/{dbBranchName}/tables/{tableName}/query",
   method: "post",
@@ -1056,16 +2864,36 @@ const searchTable = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
-const vectorSearchTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/vectorSearch", method: "post", ...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 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",
@@ -1087,7 +2915,9 @@ const sqlQuery = (variables, signal) => dataPlaneFetch({
 const operationsByTag$2 = {
   migrations: {
     applyMigration,
+    startMigration,
     adaptTable,
+    adaptAllTables,
     getBranchMigrationJobStatus,
     getMigrationJobStatus,
     getMigrationHistory,
@@ -1150,7 +2980,16 @@ const operationsByTag$2 = {
     deleteRecord,
     bulkInsertTableRecords
   },
-  files: { getFileItem, putFileItem, deleteFileItem, getFile, putFile, deleteFile, fileAccess, fileUpload },
+  files: {
+    getFileItem,
+    putFileItem,
+    deleteFileItem,
+    getFile,
+    putFile,
+    deleteFile,
+    fileAccess,
+    fileUpload
+  },
   searchAndFilter: {
     queryTable,
     searchBranch,
@@ -1228,7 +3067,12 @@ const deleteOAuthAccessToken = (variables, signal) => controlPlaneFetch({
   ...variables,
   signal
 });
-const updateOAuthAccessToken = (variables, signal) => controlPlaneFetch({ url: "/user/oauth/tokens/{token}", method: "patch", ...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",
@@ -1259,49 +3103,150 @@ const deleteWorkspace = (variables, signal) => controlPlaneFetch({
   ...variables,
   signal
 });
-const getWorkspaceSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/settings", method: "get", ...variables, signal });
-const updateWorkspaceSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/settings", method: "patch", ...variables, signal });
-const getWorkspaceMembersList = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members", method: "get", ...variables, signal });
-const updateWorkspaceMemberRole = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables, signal });
+const getWorkspaceSettings = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/settings",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateWorkspaceSettings = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/settings",
+  method: "patch",
+  ...variables,
+  signal
+});
+const getWorkspaceMembersList = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/members",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateWorkspaceMemberRole = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/members/{userId}",
+  method: "put",
+  ...variables,
+  signal
+});
 const removeWorkspaceMember = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/members/{userId}",
   method: "delete",
   ...variables,
   signal
 });
-const inviteWorkspaceMember = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables, signal });
-const updateWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables, signal });
-const cancelWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "delete", ...variables, signal });
-const acceptWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept", method: "post", ...variables, signal });
-const resendWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/invites/{inviteId}/resend", method: "post", ...variables, signal });
-const listClusters = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "get", ...variables, signal });
-const createCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters", method: "post", ...variables, signal });
+const inviteWorkspaceMember = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/invites",
+  method: "post",
+  ...variables,
+  signal
+});
+const updateWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/invites/{inviteId}",
+  method: "patch",
+  ...variables,
+  signal
+});
+const cancelWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/invites/{inviteId}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const acceptWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept",
+  method: "post",
+  ...variables,
+  signal
+});
+const resendWorkspaceMemberInvite = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/invites/{inviteId}/resend",
+  method: "post",
+  ...variables,
+  signal
+});
+const listClusters = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/clusters",
+  method: "get",
+  ...variables,
+  signal
+});
+const createCluster = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/clusters",
+  method: "post",
+  ...variables,
+  signal
+});
 const getCluster = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/clusters/{clusterId}",
   method: "get",
   ...variables,
   signal
 });
-const updateCluster = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/clusters/{clusterId}", method: "patch", ...variables, signal });
+const updateCluster = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/clusters/{clusterId}",
+  method: "patch",
+  ...variables,
+  signal
+});
+const deleteCluster = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/clusters/{clusterId}",
+  method: "delete",
+  ...variables,
+  signal
+});
 const getDatabaseList = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/dbs",
   method: "get",
   ...variables,
   signal
 });
-const createDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "put", ...variables, signal });
+const createDatabase = (variables, signal) => controlPlaneFetch({
+  url: "/workspaces/{workspaceId}/dbs/{dbName}",
+  method: "put",
+  ...variables,
+  signal
+});
 const deleteDatabase = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/dbs/{dbName}",
   method: "delete",
   ...variables,
   signal
 });
-const getDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "get", ...variables, signal });
-const updateDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "patch", ...variables, signal });
-const renameDatabase = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/rename", method: "post", ...variables, signal });
-const getDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "get", ...variables, signal });
-const updateDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "put", ...variables, signal });
-const deleteDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "delete", ...variables, signal });
+const 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",
@@ -1339,7 +3284,13 @@ const operationsByTag$1 = {
     acceptWorkspaceMemberInvite,
     resendWorkspaceMemberInvite
   },
-  xbcontrolOther: { listClusters, createCluster, getCluster, updateCluster },
+  xbcontrolOther: {
+    listClusters,
+    createCluster,
+    getCluster,
+    updateCluster,
+    deleteCluster
+  },
   databases: {
     getDatabaseList,
     createDatabase,
@@ -1359,7 +3310,7 @@ const operationsByTag = deepMerge(operationsByTag$2, operationsByTag$1);
 const buildApiClient = () => class {
   constructor(options = {}) {
     const provider = options.host ?? "production";
-    const apiKey = options.apiKey ?? getAPIKey();
+    const apiKey = options.apiKey;
     const trace = options.trace ?? defaultTrace;
     const clientID = generateUUID();
     if (!apiKey) {
@@ -1426,8 +3377,7 @@ function buildTransformString(transformations) {
   ).join(",");
 }
 function transformImage(url, ...transformations) {
-  if (!isDefined(url))
-    return void 0;
+  if (!isDefined(url)) return void 0;
   const newTransformations = buildTransformString(transformations);
   const { hostname, pathname, search } = new URL(url);
   const pathParts = pathname.split("/");
@@ -1540,8 +3490,7 @@ class XataFile {
   }
 }
 const parseInputFileEntry = async (entry) => {
-  if (!isDefined(entry))
-    return null;
+  if (!isDefined(entry)) return null;
   const { id, name, mediaType, base64Content, enablePublicUrl, signedUrlTimeout, uploadUrlTimeout } = await entry;
   return compactObject({
     id,
@@ -1556,24 +3505,19 @@ const parseInputFileEntry = async (entry) => {
 };
 
 function cleanFilter(filter) {
-  if (!isDefined(filter))
-    return void 0;
-  if (!isObject(filter))
-    return filter;
+  if (!isDefined(filter)) return void 0;
+  if (!isObject(filter)) return filter;
   const values = Object.fromEntries(
     Object.entries(filter).reduce((acc, [key, value]) => {
-      if (!isDefined(value))
-        return acc;
+      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;
+        if (clean.length === 0) return acc;
         return [...acc, [key, clean]];
       }
       if (isObject(value)) {
         const clean = cleanFilter(value);
-        if (!isDefined(clean))
-          return acc;
+        if (!isDefined(clean)) return acc;
         return [...acc, [key, clean]];
       }
       return [...acc, [key, value]];
@@ -1583,10 +3527,8 @@ function cleanFilter(filter) {
 }
 
 function stringifyJson(value) {
-  if (!isDefined(value))
-    return value;
-  if (isString(value))
-    return value;
+  if (!isDefined(value)) return value;
+  if (isString(value)) return value;
   try {
     return JSON.stringify(value);
   } catch (e) {
@@ -1601,28 +3543,17 @@ function parseJson(value) {
   }
 }
 
-var __accessCheck$5 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$5 = (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$3 = (obj, member, value, setter) => {
-  __accessCheck$5(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
+var __typeError$5 = (msg) => {
+  throw TypeError(msg);
 };
+var __accessCheck$5 = (obj, member, msg) => member.has(obj) || __typeError$5("Cannot " + msg);
+var __privateGet$4 = (obj, member, getter) => (__accessCheck$5(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$5 = (obj, member, value) => member.has(obj) ? __typeError$5("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$3 = (obj, member, value, setter) => (__accessCheck$5(obj, member, "write to private field"), member.set(obj, value), value);
 var _query, _page;
 class Page {
   constructor(query, meta, records = []) {
-    __privateAdd$5(this, _query, void 0);
+    __privateAdd$5(this, _query);
     __privateSet$3(this, _query, query);
     this.meta = meta;
     this.records = new PageRecordArray(this, records);
@@ -1709,7 +3640,7 @@ class RecordArray extends Array {
 const _PageRecordArray = class _PageRecordArray extends Array {
   constructor(...args) {
     super(..._PageRecordArray.parseConstructorParams(...args));
-    __privateAdd$5(this, _page, void 0);
+    __privateAdd$5(this, _page);
     __privateSet$3(this, _page, isObject(args[0]?.meta) ? args[0] : { meta: { page: { cursor: "", more: false } }, records: [] });
   }
   static parseConstructorParams(...args) {
@@ -1780,34 +3711,20 @@ const _PageRecordArray = class _PageRecordArray extends Array {
 _page = new WeakMap();
 let PageRecordArray = _PageRecordArray;
 
-var __accessCheck$4 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$4 = (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$2 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod$3 = (obj, member, method) => {
-  __accessCheck$4(obj, member, "access private method");
-  return method;
+var __typeError$4 = (msg) => {
+  throw TypeError(msg);
 };
-var _table$1, _repository, _data, _cleanFilterConstraint, cleanFilterConstraint_fn;
+var __accessCheck$4 = (obj, member, msg) => member.has(obj) || __typeError$4("Cannot " + msg);
+var __privateGet$3 = (obj, member, getter) => (__accessCheck$4(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$4 = (obj, member, value) => member.has(obj) ? __typeError$4("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$4(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod$3 = (obj, member, method) => (__accessCheck$4(obj, member, "access private method"), method);
+var _table$1, _repository, _data, _Query_instances, cleanFilterConstraint_fn;
 const _Query = class _Query {
   constructor(repository, table, data, rawParent) {
-    __privateAdd$4(this, _cleanFilterConstraint);
-    __privateAdd$4(this, _table$1, void 0);
-    __privateAdd$4(this, _repository, void 0);
+    __privateAdd$4(this, _Query_instances);
+    __privateAdd$4(this, _table$1);
+    __privateAdd$4(this, _repository);
     __privateAdd$4(this, _data, { filter: {} });
     // Implements pagination
     this.meta = { page: { cursor: "start", more: true, size: PAGINATION_DEFAULT_SIZE } };
@@ -1885,12 +3802,12 @@ const _Query = class _Query {
   filter(a, b) {
     if (arguments.length === 1) {
       const constraints = Object.entries(a ?? {}).map(([column, constraint]) => ({
-        [column]: __privateMethod$3(this, _cleanFilterConstraint, cleanFilterConstraint_fn).call(this, column, constraint)
+        [column]: __privateMethod$3(this, _Query_instances, cleanFilterConstraint_fn).call(this, column, constraint)
       }));
       const $all = compact([__privateGet$3(this, _data).filter?.$all].flat().concat(constraints));
       return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
     } else {
-      const constraints = isDefined(a) && isDefined(b) ? [{ [a]: __privateMethod$3(this, _cleanFilterConstraint, cleanFilterConstraint_fn).call(this, a, b) }] : void 0;
+      const constraints = isDefined(a) && isDefined(b) ? [{ [a]: __privateMethod$3(this, _Query_instances, cleanFilterConstraint_fn).call(this, a, b) }] : void 0;
       const $all = compact([__privateGet$3(this, _data).filter?.$all].flat().concat(constraints));
       return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
     }
@@ -1969,8 +3886,7 @@ const _Query = class _Query {
   }
   async getFirstOrThrow(options = {}) {
     const records = await this.getMany({ ...options, pagination: { size: 1 } });
-    if (records[0] === void 0)
-      throw new Error("No results found.");
+    if (records[0] === void 0) throw new Error("No results found.");
     return records[0];
   }
   async summarize(params = {}) {
@@ -2025,7 +3941,7 @@ const _Query = class _Query {
 _table$1 = new WeakMap();
 _repository = new WeakMap();
 _data = new WeakMap();
-_cleanFilterConstraint = new WeakSet();
+_Query_instances = new WeakSet();
 cleanFilterConstraint_fn = function(column, value) {
   const columnType = __privateGet$3(this, _table$1).schema?.columns.find(({ name }) => name === column)?.type;
   if (columnType === "multiple" && (isString(value) || isStringArray(value))) {
@@ -2086,8 +4002,7 @@ function isSortFilterString(value) {
 }
 function isSortFilterBase(filter) {
   return isObject(filter) && Object.entries(filter).every(([key, value]) => {
-    if (key === "*")
-      return value === "random";
+    if (key === "*") return value === "random";
     return value === "asc" || value === "desc";
   });
 }
@@ -2108,29 +4023,15 @@ function buildSortFilter(filter) {
   }
 }
 
-var __accessCheck$3 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$3 = (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 __typeError$3 = (msg) => {
+  throw TypeError(msg);
 };
-var __privateSet$1 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod$2 = (obj, member, method) => {
-  __accessCheck$3(obj, member, "access private method");
-  return method;
-};
-var _table, _getFetchProps, _db, _schemaTables, _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, _getSchemaTables, getSchemaTables_fn, _transformObjectToApi, transformObjectToApi_fn;
+var __accessCheck$3 = (obj, member, msg) => member.has(obj) || __typeError$3("Cannot " + msg);
+var __privateGet$2 = (obj, member, getter) => (__accessCheck$3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$3 = (obj, member, value) => member.has(obj) ? __typeError$3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$3(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod$2 = (obj, member, method) => (__accessCheck$3(obj, member, "access private method"), method);
+var _table, _getFetchProps, _db, _schemaTables, _trace, _RestRepository_instances, insertRecordWithoutId_fn, insertRecordWithId_fn, insertRecords_fn, updateRecordWithID_fn, updateRecords_fn, upsertRecordWithID_fn, deleteRecord_fn, deleteRecords_fn, getSchemaTables_fn, transformObjectToApi_fn;
 const BULK_OPERATION_MAX_SIZE = 1e3;
 class Repository extends Query {
 }
@@ -2141,21 +4042,12 @@ class RestRepository extends Query {
       { name: options.table, schema: options.schemaTables?.find((table) => table.name === options.table) },
       {}
     );
-    __privateAdd$3(this, _insertRecordWithoutId);
-    __privateAdd$3(this, _insertRecordWithId);
-    __privateAdd$3(this, _insertRecords);
-    __privateAdd$3(this, _updateRecordWithID);
-    __privateAdd$3(this, _updateRecords);
-    __privateAdd$3(this, _upsertRecordWithID);
-    __privateAdd$3(this, _deleteRecord);
-    __privateAdd$3(this, _deleteRecords);
-    __privateAdd$3(this, _getSchemaTables);
-    __privateAdd$3(this, _transformObjectToApi);
-    __privateAdd$3(this, _table, void 0);
-    __privateAdd$3(this, _getFetchProps, void 0);
-    __privateAdd$3(this, _db, void 0);
-    __privateAdd$3(this, _schemaTables, void 0);
-    __privateAdd$3(this, _trace, void 0);
+    __privateAdd$3(this, _RestRepository_instances);
+    __privateAdd$3(this, _table);
+    __privateAdd$3(this, _getFetchProps);
+    __privateAdd$3(this, _db);
+    __privateAdd$3(this, _schemaTables);
+    __privateAdd$3(this, _trace);
     __privateSet$1(this, _table, options.table);
     __privateSet$1(this, _db, options.db);
     __privateSet$1(this, _schemaTables, options.schemaTables);
@@ -2174,31 +4066,28 @@ class RestRepository extends Query {
     return __privateGet$2(this, _trace).call(this, "create", async () => {
       const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
-        if (a.length === 0)
-          return [];
-        const ids = await __privateMethod$2(this, _insertRecords, insertRecords_fn).call(this, a, { ifVersion, createOnly: true });
+        if (a.length === 0) return [];
+        const ids = await __privateMethod$2(this, _RestRepository_instances, insertRecords_fn).call(this, a, { ifVersion, createOnly: true });
         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");
+        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: true, ifVersion });
+        return await __privateMethod$2(this, _RestRepository_instances, insertRecordWithId_fn).call(this, a, b, columns, { createOnly: true, ifVersion });
       }
       if (isObject(a) && isString(a.xata_id)) {
-        if (a.xata_id === "")
-          throw new Error("The id can't be empty");
+        if (a.xata_id === "") throw new Error("The id can't be empty");
         const columns = isValidSelectableColumns(b) ? b : void 0;
-        return await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.xata_id, { ...a, xata_id: void 0 }, columns, {
+        return await __privateMethod$2(this, _RestRepository_instances, insertRecordWithId_fn).call(this, a.xata_id, { ...a, xata_id: void 0 }, columns, {
           createOnly: true,
           ifVersion
         });
       }
       if (isObject(a)) {
         const columns = isValidSelectableColumns(b) ? b : void 0;
-        return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a, columns);
+        return __privateMethod$2(this, _RestRepository_instances, insertRecordWithoutId_fn).call(this, a, columns);
       }
       throw new Error("Invalid arguments for create method");
     });
@@ -2207,8 +4096,7 @@ class RestRepository extends Query {
     return __privateGet$2(this, _trace).call(this, "read", async () => {
       const columns = isValidSelectableColumns(b) ? b : ["*"];
       if (Array.isArray(a)) {
-        if (a.length === 0)
-          return [];
+        if (a.length === 0) return [];
         const ids = a.map((item) => extractId(item));
         const finalObjects = await this.getAll({ filter: { xata_id: { $any: compact(ids) } }, columns });
         const dictionary = finalObjects.reduce((acc, object) => {
@@ -2231,7 +4119,7 @@ class RestRepository extends Query {
             queryParams: { columns },
             ...__privateGet$2(this, _getFetchProps).call(this)
           });
-          const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+          const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
           return initObject(
             __privateGet$2(this, _db),
             schemaTables,
@@ -2272,11 +4160,10 @@ class RestRepository extends Query {
     return __privateGet$2(this, _trace).call(this, "update", async () => {
       const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
-        if (a.length === 0)
-          return [];
+        if (a.length === 0) return [];
         const existing = await this.read(a, ["xata_id"]);
         const updates = a.filter((_item, index) => existing[index] !== null);
-        await __privateMethod$2(this, _updateRecords, updateRecords_fn).call(this, updates, {
+        await __privateMethod$2(this, _RestRepository_instances, updateRecords_fn).call(this, updates, {
           ifVersion,
           upsert: false
         });
@@ -2287,15 +4174,14 @@ class RestRepository extends Query {
       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 });
+          return await __privateMethod$2(this, _RestRepository_instances, updateRecordWithID_fn).call(this, a, b, columns, { ifVersion });
         }
         if (isObject(a) && isString(a.xata_id)) {
           const columns = isValidSelectableColumns(b) ? b : void 0;
-          return await __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.xata_id, { ...a, xata_id: void 0 }, columns, { ifVersion });
+          return await __privateMethod$2(this, _RestRepository_instances, updateRecordWithID_fn).call(this, a.xata_id, { ...a, xata_id: void 0 }, columns, { ifVersion });
         }
       } catch (error) {
-        if (error.status === 422)
-          return null;
+        if (error.status === 422) return null;
         throw error;
       }
       throw new Error("Invalid arguments for update method");
@@ -2324,9 +4210,8 @@ class RestRepository extends Query {
     return __privateGet$2(this, _trace).call(this, "createOrUpdate", async () => {
       const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
-        if (a.length === 0)
-          return [];
-        await __privateMethod$2(this, _updateRecords, updateRecords_fn).call(this, a, {
+        if (a.length === 0) return [];
+        await __privateMethod$2(this, _RestRepository_instances, updateRecords_fn).call(this, a, {
           ifVersion,
           upsert: true
         });
@@ -2335,16 +4220,14 @@ class RestRepository extends Query {
         return result;
       }
       if (isString(a) && isObject(b)) {
-        if (a === "")
-          throw new Error("The id can't be empty");
+        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 });
+        return await __privateMethod$2(this, _RestRepository_instances, upsertRecordWithID_fn).call(this, a, b, columns, { ifVersion });
       }
       if (isObject(a) && isString(a.xata_id)) {
-        if (a.xata_id === "")
-          throw new Error("The id can't be empty");
+        if (a.xata_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.xata_id, { ...a, xata_id: void 0 }, columns, { ifVersion });
+        return await __privateMethod$2(this, _RestRepository_instances, upsertRecordWithID_fn).call(this, a.xata_id, { ...a, xata_id: void 0 }, columns, { ifVersion });
       }
       if (!isDefined(a) && isObject(b)) {
         return await this.create(b, c);
@@ -2359,24 +4242,21 @@ class RestRepository extends Query {
     return __privateGet$2(this, _trace).call(this, "createOrReplace", async () => {
       const ifVersion = parseIfVersion(b, c, d);
       if (Array.isArray(a)) {
-        if (a.length === 0)
-          return [];
-        const ids = await __privateMethod$2(this, _insertRecords, insertRecords_fn).call(this, a, { ifVersion, createOnly: false });
+        if (a.length === 0) return [];
+        const ids = await __privateMethod$2(this, _RestRepository_instances, insertRecords_fn).call(this, a, { ifVersion, createOnly: false });
         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");
+        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 });
+        return await __privateMethod$2(this, _RestRepository_instances, insertRecordWithId_fn).call(this, a, b, columns, { createOnly: false, ifVersion });
       }
       if (isObject(a) && isString(a.xata_id)) {
-        if (a.xata_id === "")
-          throw new Error("The id can't be empty");
+        if (a.xata_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.xata_id, { ...a, xata_id: void 0 }, columns, {
+        return await __privateMethod$2(this, _RestRepository_instances, insertRecordWithId_fn).call(this, a.xata_id, { ...a, xata_id: void 0 }, columns, {
           createOnly: false,
           ifVersion
         });
@@ -2393,25 +4273,22 @@ class RestRepository extends Query {
   async delete(a, b) {
     return __privateGet$2(this, _trace).call(this, "delete", async () => {
       if (Array.isArray(a)) {
-        if (a.length === 0)
-          return [];
+        if (a.length === 0) return [];
         const ids = a.map((o) => {
-          if (isString(o))
-            return o;
-          if (isString(o.xata_id))
-            return o.xata_id;
+          if (isString(o)) return o;
+          if (isString(o.xata_id)) return o.xata_id;
           throw new Error("Invalid arguments for delete method");
         });
         const columns = isValidSelectableColumns(b) ? b : ["*"];
         const result = await this.read(a, columns);
-        await __privateMethod$2(this, _deleteRecords, deleteRecords_fn).call(this, ids);
+        await __privateMethod$2(this, _RestRepository_instances, deleteRecords_fn).call(this, ids);
         return result;
       }
       if (isString(a)) {
-        return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a, b);
+        return __privateMethod$2(this, _RestRepository_instances, deleteRecord_fn).call(this, a, b);
       }
       if (isObject(a) && isString(a.xata_id)) {
-        return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a.xata_id, b);
+        return __privateMethod$2(this, _RestRepository_instances, deleteRecord_fn).call(this, a.xata_id, b);
       }
       throw new Error("Invalid arguments for delete method");
     });
@@ -2455,7 +4332,7 @@ class RestRepository extends Query {
         },
         ...__privateGet$2(this, _getFetchProps).call(this)
       });
-      const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+      const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
       return {
         records: records.map((item) => initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), item, ["*"])),
         totalCount
@@ -2480,7 +4357,7 @@ class RestRepository extends Query {
         },
         ...__privateGet$2(this, _getFetchProps).call(this)
       });
-      const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+      const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
       return {
         records: records.map((item) => initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), item, ["*"])),
         totalCount
@@ -2522,7 +4399,7 @@ class RestRepository extends Query {
         fetchOptions: data.fetchOptions,
         ...__privateGet$2(this, _getFetchProps).call(this)
       });
-      const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+      const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
       const records = objects.map(
         (record) => initObject(
           __privateGet$2(this, _db),
@@ -2556,7 +4433,7 @@ class RestRepository extends Query {
         },
         ...__privateGet$2(this, _getFetchProps).call(this)
       });
-      const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+      const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
       return {
         ...result,
         summaries: result.summaries.map(
@@ -2604,9 +4481,9 @@ _getFetchProps = new WeakMap();
 _db = new WeakMap();
 _schemaTables = new WeakMap();
 _trace = new WeakMap();
-_insertRecordWithoutId = new WeakSet();
+_RestRepository_instances = new WeakSet();
 insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
-  const record = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+  const record = await __privateMethod$2(this, _RestRepository_instances, transformObjectToApi_fn).call(this, object);
   const response = await insertRecord({
     pathParams: {
       workspace: "{workspaceId}",
@@ -2618,14 +4495,12 @@ insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
     body: record,
     ...__privateGet$2(this, _getFetchProps).call(this)
   });
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+  const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
   return initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), response, columns);
 };
-_insertRecordWithId = new WeakSet();
 insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { createOnly, ifVersion }) {
-  if (!recordId)
-    return null;
-  const record = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+  if (!recordId) return null;
+  const record = await __privateMethod$2(this, _RestRepository_instances, transformObjectToApi_fn).call(this, object);
   const response = await insertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
@@ -2638,13 +4513,12 @@ insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { crea
     queryParams: { createOnly, columns, ifVersion },
     ...__privateGet$2(this, _getFetchProps).call(this)
   });
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+  const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
   return initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), response, columns);
 };
-_insertRecords = new WeakSet();
 insertRecords_fn = async function(objects, { createOnly, ifVersion }) {
   const operations = await promiseMap(objects, async (object) => {
-    const record = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+    const record = await __privateMethod$2(this, _RestRepository_instances, transformObjectToApi_fn).call(this, object);
     return { insert: { table: __privateGet$2(this, _table), record, createOnly, ifVersion } };
   });
   const chunkedOperations = chunk(operations, BULK_OPERATION_MAX_SIZE);
@@ -2669,11 +4543,9 @@ insertRecords_fn = async function(objects, { createOnly, ifVersion }) {
   }
   return ids;
 };
-_updateRecordWithID = new WeakSet();
 updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
-  if (!recordId)
-    return null;
-  const { xata_id: _id, ...record } = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+  if (!recordId) return null;
+  const { xata_id: _id, ...record } = await __privateMethod$2(this, _RestRepository_instances, transformObjectToApi_fn).call(this, object);
   try {
     const response = await updateRecordWithID({
       pathParams: {
@@ -2687,7 +4559,7 @@ updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
       body: record,
       ...__privateGet$2(this, _getFetchProps).call(this)
     });
-    const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+    const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
     return initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), response, columns);
   } catch (e) {
     if (isObject(e) && e.status === 404) {
@@ -2696,10 +4568,9 @@ updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
     throw e;
   }
 };
-_updateRecords = new WeakSet();
 updateRecords_fn = async function(objects, { ifVersion, upsert }) {
   const operations = await promiseMap(objects, async ({ xata_id, ...object }) => {
-    const fields = await __privateMethod$2(this, _transformObjectToApi, transformObjectToApi_fn).call(this, object);
+    const fields = await __privateMethod$2(this, _RestRepository_instances, transformObjectToApi_fn).call(this, object);
     return { update: { table: __privateGet$2(this, _table), id: xata_id, ifVersion, upsert, fields } };
   });
   const chunkedOperations = chunk(operations, BULK_OPERATION_MAX_SIZE);
@@ -2724,10 +4595,8 @@ updateRecords_fn = async function(objects, { ifVersion, upsert }) {
   }
   return ids;
 };
-_upsertRecordWithID = new WeakSet();
 upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
-  if (!recordId)
-    return null;
+  if (!recordId) return null;
   const response = await upsertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
@@ -2740,13 +4609,11 @@ upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
     body: object,
     ...__privateGet$2(this, _getFetchProps).call(this)
   });
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+  const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
   return initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), response, columns);
 };
-_deleteRecord = new WeakSet();
 deleteRecord_fn = async function(recordId, columns = ["*"]) {
-  if (!recordId)
-    return null;
+  if (!recordId) return null;
   try {
     const response = await deleteRecord({
       pathParams: {
@@ -2759,7 +4626,7 @@ deleteRecord_fn = async function(recordId, columns = ["*"]) {
       queryParams: { columns },
       ...__privateGet$2(this, _getFetchProps).call(this)
     });
-    const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+    const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
     return initObject(__privateGet$2(this, _db), schemaTables, __privateGet$2(this, _table), response, columns);
   } catch (e) {
     if (isObject(e) && e.status === 404) {
@@ -2768,7 +4635,6 @@ deleteRecord_fn = async function(recordId, columns = ["*"]) {
     throw e;
   }
 };
-_deleteRecords = new WeakSet();
 deleteRecords_fn = async function(recordIds) {
   const chunkedOperations = chunk(
     compact(recordIds).map((id) => ({ delete: { table: __privateGet$2(this, _table), id } })),
@@ -2786,10 +4652,8 @@ deleteRecords_fn = async function(recordIds) {
     });
   }
 };
-_getSchemaTables = new WeakSet();
 getSchemaTables_fn = async function() {
-  if (__privateGet$2(this, _schemaTables))
-    return __privateGet$2(this, _schemaTables);
+  if (__privateGet$2(this, _schemaTables)) return __privateGet$2(this, _schemaTables);
   const { schema } = await getBranchDetails({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
     ...__privateGet$2(this, _getFetchProps).call(this)
@@ -2797,16 +4661,13 @@ getSchemaTables_fn = async function() {
   __privateSet$1(this, _schemaTables, schema.tables);
   return schema.tables;
 };
-_transformObjectToApi = new WeakSet();
 transformObjectToApi_fn = async function(object) {
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables, getSchemaTables_fn).call(this);
+  const schemaTables = await __privateMethod$2(this, _RestRepository_instances, getSchemaTables_fn).call(this);
   const schema = schemaTables.find((table) => table.name === __privateGet$2(this, _table));
-  if (!schema)
-    throw new Error(`Table ${__privateGet$2(this, _table)} not found in schema`);
+  if (!schema) throw new Error(`Table ${__privateGet$2(this, _table)} not found in schema`);
   const result = {};
   for (const [key, value] of Object.entries(object)) {
-    if (["xata_version", "xata_createdat", "xata_updatedat"].includes(key))
-      continue;
+    if (["xata_version", "xata_createdat", "xata_updatedat"].includes(key)) continue;
     const type = schema.columns.find((column) => column.name === key)?.type;
     switch (type) {
       case "link": {
@@ -2836,11 +4697,9 @@ const initObject = (db, schemaTables, table, object, selectedColumns) => {
   const data = {};
   Object.assign(data, { ...object });
   const { columns } = schemaTables.find(({ name }) => name === table) ?? {};
-  if (!columns)
-    console.error(`Table ${table} not found in schema`);
+  if (!columns) console.error(`Table ${table} not found in schema`);
   for (const column of columns ?? []) {
-    if (!isValidColumn(selectedColumns, column))
-      continue;
+    if (!isValidColumn(selectedColumns, column)) continue;
     const value = data[column.name];
     switch (column.type) {
       case "datetime": {
@@ -2926,15 +4785,12 @@ const initObject = (db, schemaTables, table, object, selectedColumns) => {
   return record;
 };
 function extractId(value) {
-  if (isString(value))
-    return value;
-  if (isObject(value) && isString(value.xata_id))
-    return value.xata_id;
+  if (isString(value)) return value;
+  if (isObject(value) && isString(value.xata_id)) return value.xata_id;
   return void 0;
 }
 function isValidColumn(columns, column) {
-  if (columns.includes("*"))
-    return true;
+  if (columns.includes("*")) return true;
   return columns.filter((item) => isString(item) && item.startsWith(column.name)).length > 0;
 }
 function parseIfVersion(...args) {
@@ -2974,19 +4830,12 @@ const includesAll = (value) => ({ $includesAll: value });
 const includesNone = (value) => ({ $includesNone: value });
 const includesAny = (value) => ({ $includesAny: value });
 
-var __accessCheck$2 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$1 = (obj, member, getter) => {
-  __accessCheck$2(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$2 = (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 __typeError$2 = (msg) => {
+  throw TypeError(msg);
 };
+var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
+var __privateGet$1 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var _tables;
 class SchemaPlugin extends XataPlugin {
   constructor() {
@@ -2998,8 +4847,7 @@ class SchemaPlugin extends XataPlugin {
       {},
       {
         get: (_target, table) => {
-          if (!isString(table))
-            throw new Error("Invalid table name");
+          if (!isString(table)) throw new Error("Invalid table name");
           if (__privateGet$1(this, _tables)[table] === void 0) {
             __privateGet$1(this, _tables)[table] = new RestRepository({ db, pluginOptions, table, schemaTables: pluginOptions.tables });
           }
@@ -3090,30 +4938,23 @@ function getContentType(file) {
   return "application/octet-stream";
 }
 
-var __accessCheck$1 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateAdd$1 = (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 __typeError$1 = (msg) => {
+  throw TypeError(msg);
 };
-var __privateMethod$1 = (obj, member, method) => {
-  __accessCheck$1(obj, member, "access private method");
-  return method;
-};
-var _search, search_fn;
+var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
+var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod$1 = (obj, member, method) => (__accessCheck$1(obj, member, "access private method"), method);
+var _SearchPlugin_instances, search_fn;
 class SearchPlugin extends XataPlugin {
   constructor(db) {
     super();
     this.db = db;
-    __privateAdd$1(this, _search);
+    __privateAdd$1(this, _SearchPlugin_instances);
   }
   build(pluginOptions) {
     return {
       all: async (query, options = {}) => {
-        const { records, totalCount } = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const { records, totalCount } = await __privateMethod$1(this, _SearchPlugin_instances, search_fn).call(this, query, options, pluginOptions);
         return {
           totalCount,
           records: records.map((record) => {
@@ -3123,7 +4964,7 @@ class SearchPlugin extends XataPlugin {
         };
       },
       byTable: async (query, options = {}) => {
-        const { records: rawRecords, totalCount } = await __privateMethod$1(this, _search, search_fn).call(this, query, options, pluginOptions);
+        const { records: rawRecords, totalCount } = await __privateMethod$1(this, _SearchPlugin_instances, search_fn).call(this, query, options, pluginOptions);
         const records = rawRecords.reduce((acc, record) => {
           const table = record.xata_table;
           const items = acc[table] ?? [];
@@ -3135,7 +4976,7 @@ class SearchPlugin extends XataPlugin {
     };
   }
 }
-_search = new WeakSet();
+_SearchPlugin_instances = new WeakSet();
 search_fn = async function(query, options, pluginOptions) {
   const { tables, fuzziness, highlight, prefix, page } = options ?? {};
   const { records, totalCount } = await searchBranch({
@@ -3171,8 +5012,7 @@ function arrayString(val) {
   return result;
 }
 function prepareValue(value) {
-  if (!isDefined(value))
-    return null;
+  if (!isDefined(value)) return null;
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -3199,8 +5039,8 @@ function prepareParams(param1, param2) {
     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 };
+    const { statement, params, consistency, responseType } = param1;
+    return { statement, params: params?.map((value) => prepareValue(value)), consistency, responseType };
   }
   throw new Error("Invalid query");
 }
@@ -3211,7 +5051,7 @@ class SQLPlugin extends XataPlugin {
       if (!isParamsObject(query) && (!isTemplateStringsArray(query) || !Array.isArray(parameters))) {
         throw new Error("Invalid usage of `xata.sql`. Please use it as a tagged template or with an object.");
       }
-      const { statement, params, consistency } = prepareParams(query, parameters);
+      const { statement, params, consistency, responseType } = prepareParams(query, parameters);
       const {
         records,
         rows,
@@ -3219,7 +5059,7 @@ class SQLPlugin extends XataPlugin {
         columns = []
       } = await sqlQuery({
         pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", region: "{region}" },
-        body: { statement, params, consistency },
+        body: { statement, params, consistency, responseType },
         ...pluginOptions
       });
       return { records, rows, warning, columns };
@@ -3251,8 +5091,7 @@ function buildDomain(host, region) {
 function buildConnectionString({ apiKey, workspacesApiUrl, branch }) {
   const url = isString(workspacesApiUrl) ? workspacesApiUrl : workspacesApiUrl("", {});
   const parts = parseWorkspacesUrlParts(url);
-  if (!parts)
-    throw new Error("Invalid workspaces URL");
+  if (!parts) throw new Error("Invalid workspaces URL");
   const { workspace: workspaceSlug, region, database, host } = parts;
   const domain = buildDomain(host, region);
   const workspace = workspaceSlug.split("-").pop();
@@ -3277,39 +5116,24 @@ class TransactionPlugin extends XataPlugin {
   }
 }
 
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (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 = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
+var __typeError = (msg) => {
+  throw TypeError(msg);
 };
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 const buildClient = (plugins) => {
-  var _options, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _a;
+  var _options, _instances, parseOptions_fn, getFetchProps_fn, _a;
   return _a = class {
     constructor(options = {}, tables) {
-      __privateAdd(this, _parseOptions);
-      __privateAdd(this, _getFetchProps);
-      __privateAdd(this, _options, void 0);
-      const safeOptions = __privateMethod(this, _parseOptions, parseOptions_fn).call(this, options);
+      __privateAdd(this, _instances);
+      __privateAdd(this, _options);
+      const safeOptions = __privateMethod(this, _instances, parseOptions_fn).call(this, options);
       __privateSet(this, _options, safeOptions);
       const pluginOptions = {
-        ...__privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
+        ...__privateMethod(this, _instances, getFetchProps_fn).call(this, safeOptions),
         host: safeOptions.host,
         tables,
         branch: safeOptions.branch
@@ -3326,8 +5150,7 @@ const buildClient = (plugins) => {
       this.sql = sql;
       this.files = files;
       for (const [key, namespace] of Object.entries(plugins ?? {})) {
-        if (namespace === void 0)
-          continue;
+        if (namespace === void 0) continue;
         this[key] = namespace.build(pluginOptions);
       }
     }
@@ -3336,8 +5159,8 @@ const buildClient = (plugins) => {
       const branch = __privateGet(this, _options).branch;
       return { databaseURL, branch };
     }
-  }, _options = new WeakMap(), _parseOptions = new WeakSet(), parseOptions_fn = function(options) {
-    const enableBrowser = options?.enableBrowser ?? getEnableBrowserVariable() ?? false;
+  }, _options = new WeakMap(), _instances = new WeakSet(), parseOptions_fn = function(options) {
+    const enableBrowser = options?.enableBrowser ?? false;
     const isBrowser = typeof window !== "undefined" && typeof Deno === "undefined";
     if (isBrowser && !enableBrowser) {
       throw new Error(
@@ -3345,8 +5168,9 @@ const buildClient = (plugins) => {
       );
     }
     const fetch = getFetchImplementation(options?.fetch);
-    const databaseURL = options?.databaseURL || getDatabaseURL();
-    const apiKey = options?.apiKey || getAPIKey();
+    const databaseURL = options?.databaseURL;
+    const apiKey = options?.apiKey;
+    const branch = options?.branch;
     const trace = options?.trace ?? defaultTrace;
     const clientName = options?.clientName;
     const host = options?.host ?? "production";
@@ -3357,25 +5181,8 @@ const buildClient = (plugins) => {
     if (!databaseURL) {
       throw new Error("Option databaseURL is required");
     }
-    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.`
-      );
+    if (!branch) {
+      throw new Error("Option branch is required");
     }
     return {
       fetch,
@@ -3389,7 +5196,7 @@ const buildClient = (plugins) => {
       clientName,
       xataAgentExtra
     };
-  }, _getFetchProps = new WeakSet(), getFetchProps_fn = function({
+  }, getFetchProps_fn = function({
     fetch,
     apiKey,
     databaseURL,
@@ -3430,26 +5237,19 @@ class Serializer {
   }
   toJSON(data) {
     function visit(obj) {
-      if (Array.isArray(obj))
-        return obj.map(visit);
+      if (Array.isArray(obj)) return obj.map(visit);
       const type = typeof obj;
-      if (type === "undefined")
-        return { [META]: "undefined" };
-      if (type === "bigint")
-        return { [META]: "bigint", [VALUE]: obj.toString() };
-      if (obj === null || type !== "object")
-        return obj;
+      if (type === "undefined") return { [META]: "undefined" };
+      if (type === "bigint") return { [META]: "bigint", [VALUE]: obj.toString() };
+      if (obj === null || type !== "object") return obj;
       const constructor = obj.constructor;
       const o = { [META]: constructor.name };
       for (const [key, value] of Object.entries(obj)) {
         o[key] = visit(value);
       }
-      if (constructor === Date)
-        o[VALUE] = obj.toISOString();
-      if (constructor === Map)
-        o[VALUE] = Object.fromEntries(obj);
-      if (constructor === Set)
-        o[VALUE] = [...obj];
+      if (constructor === Date) o[VALUE] = obj.toISOString();
+      if (constructor === Map) o[VALUE] = Object.fromEntries(obj);
+      if (constructor === Set) o[VALUE] = [...obj];
       return o;
     }
     return JSON.stringify(visit(data));
@@ -3462,16 +5262,11 @@ class Serializer {
         if (constructor) {
           return Object.assign(Object.create(constructor.prototype), rest);
         }
-        if (clazz === "Date")
-          return new Date(val);
-        if (clazz === "Set")
-          return new Set(val);
-        if (clazz === "Map")
-          return new Map(Object.entries(val));
-        if (clazz === "bigint")
-          return BigInt(val);
-        if (clazz === "undefined")
-          return void 0;
+        if (clazz === "Date") return new Date(val);
+        if (clazz === "Set") return new Set(val);
+        if (clazz === "Map") return new Map(Object.entries(val));
+        if (clazz === "bigint") return BigInt(val);
+        if (clazz === "undefined") return void 0;
         return rest;
       }
       return value;
@@ -3486,6 +5281,47 @@ const deserialize = (json) => {
   return defaultSerializer.fromJSON(json);
 };
 
+function parseEnvironment(environment) {
+  try {
+    if (typeof environment === "function") {
+      return new Proxy(
+        {},
+        {
+          get(target) {
+            return environment(target);
+          }
+        }
+      );
+    }
+    if (isObject(environment)) {
+      return environment;
+    }
+  } catch (error) {
+  }
+  return {};
+}
+function buildPreviewBranchName({ org, branch }) {
+  return `preview-${org}-${branch}`;
+}
+function getDeployPreviewBranch(environment) {
+  try {
+    const { deployPreview, deployPreviewBranch, vercelGitCommitRef, vercelGitRepoOwner } = parseEnvironment(environment);
+    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;
+  }
+}
+
 class XataError extends Error {
   constructor(message, status) {
     super(message);
@@ -3494,6 +5330,7 @@ class XataError extends Error {
 }
 
 exports.BaseClient = BaseClient;
+exports.Buffer = Buffer;
 exports.FetcherError = FetcherError;
 exports.FilesPlugin = FilesPlugin;
 exports.Operations = operationsByTag;
@@ -3519,6 +5356,7 @@ exports.XataError = XataError;
 exports.XataFile = XataFile;
 exports.XataPlugin = XataPlugin;
 exports.acceptWorkspaceMemberInvite = acceptWorkspaceMemberInvite;
+exports.adaptAllTables = adaptAllTables;
 exports.adaptTable = adaptTable;
 exports.addGitBranchesEntry = addGitBranchesEntry;
 exports.addTableColumn = addTableColumn;
@@ -3546,6 +5384,7 @@ exports.createTable = createTable;
 exports.createUserAPIKey = createUserAPIKey;
 exports.createWorkspace = createWorkspace;
 exports.deleteBranch = deleteBranch;
+exports.deleteCluster = deleteCluster;
 exports.deleteColumn = deleteColumn;
 exports.deleteDatabase = deleteDatabase;
 exports.deleteDatabaseGithubSettings = deleteDatabaseGithubSettings;
@@ -3566,9 +5405,7 @@ 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;
@@ -3583,7 +5420,7 @@ exports.getDatabaseGithubSettings = getDatabaseGithubSettings;
 exports.getDatabaseList = getDatabaseList;
 exports.getDatabaseMetadata = getDatabaseMetadata;
 exports.getDatabaseSettings = getDatabaseSettings;
-exports.getDatabaseURL = getDatabaseURL;
+exports.getDeployPreviewBranch = getDeployPreviewBranch;
 exports.getFile = getFile;
 exports.getFileItem = getFileItem;
 exports.getGitBranchesMapping = getGitBranchesMapping;
@@ -3592,7 +5429,6 @@ exports.getMigrationHistory = getMigrationHistory;
 exports.getMigrationJobStatus = getMigrationJobStatus;
 exports.getMigrationRequest = getMigrationRequest;
 exports.getMigrationRequestIsMerged = getMigrationRequestIsMerged;
-exports.getPreviewBranch = getPreviewBranch;
 exports.getRecord = getRecord;
 exports.getSchema = getSchema;
 exports.getTableColumns = getTableColumns;
@@ -3659,6 +5495,7 @@ exports.searchTable = searchTable;
 exports.serialize = serialize;
 exports.setTableSchema = setTableSchema;
 exports.sqlQuery = sqlQuery;
+exports.startMigration = startMigration;
 exports.startsWith = startsWith;
 exports.summarizeTable = summarizeTable;
 exports.transformImage = transformImage;