@ohos-ports/bare-buffer 3.7.1-beta.0

package/index.d.ts

@@ -0,0 +1,769 @@
+import constants from './lib/constants'
+
+/** The set of encodings supported by `Buffer` methods that convert between bytes and strings. */
+type BufferEncoding =
+  | 'ascii'
+  | 'base64'
+  | 'binary'
+  | 'hex'
+  | 'latin1'
+  | 'ucs-2'
+  | 'ucs2'
+  | 'utf-16le'
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf8'
+
+interface Buffer extends Uint8Array<ArrayBuffer> {
+  /**
+   * Compare this buffer's contents against `target` lexicographically, optionally comparing only
+   * a sub-range of each, returning -1, 0, or 1 for sort ordering.
+   * @param target - The buffer to compare against.
+   * @param targetStart - Offset within `target` to start comparing from; defaults to `0`.
+   * @param targetEnd - Offset within `target` (exclusive) to stop comparing at; defaults to
+   * `target.byteLength`.
+   * @param sourceStart - Offset within this buffer to start comparing from; defaults to `0`.
+   * @param sourceEnd - Offset within this buffer (exclusive) to stop comparing at; defaults to
+   * `this.byteLength`.
+   * @throws {TypeError} thrown if `target` is not a view.
+   * @throws {RangeError} thrown if an offset or length is not an integer, or if either view's
+   * range lies outside its backing store.
+   */
+  compare(
+    target: Buffer | ArrayBufferView,
+    targetStart?: number,
+    targetEnd?: number,
+    sourceStart?: number,
+    sourceEnd?: number
+  ): number
+
+  /**
+   * Copy bytes from this buffer into `target`, returning the number of bytes copied. A target of
+   * wider elements, such as a `Uint16Array`, receives the bytes it spans.
+   * @param target - The buffer or view to copy into.
+   * @param targetStart - Offset within `target` to start writing at; defaults to `0`.
+   * @param sourceStart - Offset within this buffer to start copying from; defaults to `0`.
+   * @param sourceEnd - Offset within this buffer (exclusive) to stop copying at; defaults to
+   * `this.byteLength`.
+   * @throws {TypeError} thrown if `target` is not a view.
+   * @throws {RangeError} thrown if an offset is not an integer, is negative, or if `sourceStart`
+   * is past the end of this buffer.
+   */
+  copy(
+    target: Buffer | ArrayBufferView,
+    targetStart?: number,
+    sourceStart?: number,
+    sourceEnd?: number
+  ): number
+
+  /**
+   * Check whether this buffer and `target` have identical contents.
+   * @param target - The buffer or view to compare this buffer's contents against.
+   * @throws {TypeError} thrown if `target` is not a view.
+   * @throws {RangeError} thrown if either view's range lies outside its backing store.
+   */
+  equals(target: Buffer | ArrayBufferView): boolean
+
+  /**
+   * Fill this buffer with `value`, repeating as needed, and return it.
+   * @param value - The value to fill with — a string or view (repeated across the range), or a
+   * number/boolean byte. A view fills with the bytes it spans.
+   * @param encoding - Encoding used to interpret `value` when it's a string; defaults to `'utf8'`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   * @throws {TypeError} thrown if `value` is not a value that can fill.
+   * @throws {RangeError} thrown if an offset or length is not an integer.
+   */
+  fill(value: string, encoding?: BufferEncoding): this
+  fill(value: string, offset?: number, encoding?: BufferEncoding): this
+  fill(value: string, offset?: number, end?: number, encoding?: BufferEncoding): this
+  fill(value: Buffer | ArrayBufferView | number | boolean, offset?: number, end?: number): this
+
+  /**
+   * Check whether this buffer contains `value`.
+   * @param value - The value to search for — a string, view, number byte, or boolean.
+   * @param encoding - Encoding used to interpret `value` when it's a string; defaults to `'utf8'`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   * @throws {TypeError} thrown if `value` is not a string, view, number, or boolean.
+   * @throws {RangeError} thrown if an offset or length is not an integer, or if either view's
+   * range lies outside its backing store.
+   */
+  includes(value: string, encoding?: BufferEncoding): boolean
+  includes(value: string, offset?: number, encoding?: BufferEncoding): boolean
+  includes(value: Buffer | ArrayBufferView | number | boolean, offset?: number): boolean
+
+  /**
+   * Return the first index at which `value` occurs in this buffer, or `-1` if not found.
+   * @param value - The value to search for — a string, view, number byte, or boolean.
+   * @param encoding - Encoding used to interpret `value` when it's a string; defaults to `'utf8'`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   * @throws {TypeError} thrown if `value` is not a string, view, number, or boolean.
+   * @throws {RangeError} thrown if an offset or length is not an integer, or if either view's
+   * range lies outside its backing store.
+   */
+  indexOf(value: string, encoding?: BufferEncoding): number
+  indexOf(value: string, offset?: number, encoding?: BufferEncoding): number
+  indexOf(value: Buffer | ArrayBufferView | number | boolean, offset?: number): number
+
+  /**
+   * Return the last index at which `value` occurs in this buffer, or `-1` if not found.
+   * @param value - The value to search for — a string, view, number byte, or boolean.
+   * @param encoding - Encoding used to interpret `value` when it's a string; defaults to `'utf8'`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   * @throws {TypeError} thrown if `value` is not a string, view, number, or boolean.
+   * @throws {RangeError} thrown if an offset or length is not an integer, or if either view's
+   * range lies outside its backing store.
+   */
+  lastIndexOf(value: string, encoding?: BufferEncoding): number
+  lastIndexOf(value: string, offset?: number, encoding?: BufferEncoding): number
+  lastIndexOf(value: Buffer | ArrayBufferView | number | boolean, offset?: number): number
+
+  /**
+   * Swap the byte order of each 16-bit group in this buffer in place, and return it.
+   * @throws {RangeError} thrown if the buffer's length is not a multiple of 2 bytes, or if its
+   * range lies outside its backing store.
+   */
+  swap16(): this
+  /**
+   * Swap the byte order of each 32-bit group in this buffer in place, and return it.
+   * @throws {RangeError} thrown if the buffer's length is not a multiple of 4 bytes, or if its
+   * range lies outside its backing store.
+   */
+  swap32(): this
+  /**
+   * Swap the byte order of each 64-bit group in this buffer in place, and return it.
+   * @throws {RangeError} thrown if the buffer's length is not a multiple of 8 bytes, or if its
+   * range lies outside its backing store.
+   */
+  swap64(): this
+
+  /**
+   * Decode this buffer (or a slice of it) to a string using `encoding`.
+   * @param encoding - Encoding used to decode the bytes; defaults to `'utf8'`.
+   * @param start - Byte offset to start decoding from; defaults to `0`.
+   * @param end - Byte offset (exclusive) to stop decoding at; defaults to `this.byteLength`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   * @throws {RangeError} thrown if an offset or length is not an integer, if this buffer's range
+   * lies outside its backing store, or if the decoded string would exceed
+   * `Buffer.constants.MAX_STRING_LENGTH`.
+   */
+  toString(encoding?: BufferEncoding, start?: number, end?: number): string
+
+  /**
+   * Return an array of this buffer's bytes, used when the buffer is passed to `JSON.stringify()`.
+   */
+  toJSON(): number[]
+
+  /**
+   * Read a 64-bit big-endian double at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readDoubleBE(offset?: number): number
+  /**
+   * Read a 64-bit little-endian double at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readDoubleLE(offset?: number): number
+
+  /**
+   * Read a 32-bit big-endian float at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readFloatBE(offset?: number): number
+  /**
+   * Read a 32-bit little-endian float at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readFloatLE(offset?: number): number
+
+  /**
+   * Read a signed 8-bit integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readInt8(offset?: number): number
+
+  /**
+   * Read a signed 16-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readInt16BE(offset?: number): number
+  /**
+   * Read a signed 16-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readInt16LE(offset?: number): number
+
+  /**
+   * Read a signed 32-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readInt32BE(offset?: number): number
+  /**
+   * Read a signed 32-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readInt32LE(offset?: number): number
+
+  /**
+   * Read a signed, big-endian, `byteLength`-byte integer at `offset`.
+   * @param offset - Byte offset to read from.
+   * @param byteLength - Number of bytes to read, from `1` to `6`.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  readIntBE(offset: number, byteLength: number): number
+  /**
+   * Read a signed, little-endian, `byteLength`-byte integer at `offset`.
+   * @param offset - Byte offset to read from.
+   * @param byteLength - Number of bytes to read, from `1` to `6`.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  readIntLE(offset: number, byteLength: number): number
+
+  /**
+   * Read a signed 64-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readBigInt64BE(offset?: number): bigint
+  /**
+   * Read a signed 64-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readBigInt64LE(offset?: number): bigint
+
+  /**
+   * Read an unsigned 8-bit integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUInt8(offset?: number): number
+  /**
+   * Read an unsigned 8-bit integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUint8(offset?: number): number
+
+  /**
+   * Read an unsigned 16-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUInt16BE(offset?: number): number
+  /**
+   * Read an unsigned 16-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUint16BE(offset?: number): number
+  /**
+   * Read an unsigned 16-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUInt16LE(offset?: number): number
+  /**
+   * Read an unsigned 16-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUint16LE(offset?: number): number
+
+  /**
+   * Read an unsigned 32-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUInt32BE(offset?: number): number
+  /**
+   * Read an unsigned 32-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUint32BE(offset?: number): number
+  /**
+   * Read an unsigned 32-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUInt32LE(offset?: number): number
+  /**
+   * Read an unsigned 32-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readUint32LE(offset?: number): number
+
+  /**
+   * Read an unsigned, big-endian, `byteLength`-byte integer at `offset`.
+   * @param offset - Byte offset to read from.
+   * @param byteLength - Number of bytes to read, from `1` to `6`.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  readUIntBE(offset: number, byteLength: number): number
+  /**
+   * Read an unsigned, big-endian, `byteLength`-byte integer at `offset`.
+   * @param offset - Byte offset to read from.
+   * @param byteLength - Number of bytes to read, from `1` to `6`.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  readUintBE(offset: number, byteLength: number): number
+  /**
+   * Read an unsigned, little-endian, `byteLength`-byte integer at `offset`.
+   * @param offset - Byte offset to read from.
+   * @param byteLength - Number of bytes to read, from `1` to `6`.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  readUIntLE(offset: number, byteLength: number): number
+  /**
+   * Read an unsigned, little-endian, `byteLength`-byte integer at `offset`.
+   * @param offset - Byte offset to read from.
+   * @param byteLength - Number of bytes to read, from `1` to `6`.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  readUintLE(offset: number, byteLength: number): number
+
+  /**
+   * Read an unsigned 64-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readBigUInt64BE(offset?: number): bigint
+  /**
+   * Read an unsigned 64-bit big-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readBigUint64BE(offset?: number): bigint
+  /**
+   * Read an unsigned 64-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readBigUInt64LE(offset?: number): bigint
+  /**
+   * Read an unsigned 64-bit little-endian integer at `offset`.
+   * @param offset - Byte offset to read from; defaults to `0`.
+   */
+  readBigUint64LE(offset?: number): bigint
+
+  /**
+   * Write `string` into this buffer using `encoding`, returning the number of bytes written.
+   * @param string - The string to write.
+   * @param encoding - Encoding used to encode `string`; defaults to `'utf8'`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`, or if `string`
+   * is not valid in it, as a hex or base64 string can fail to be.
+   * @throws {TypeError} thrown if `string` is not a string.
+   * @throws {RangeError} thrown if an offset or length is not an integer, or if this buffer's
+   * range lies outside its backing store.
+   */
+  write(string: string, encoding?: BufferEncoding): number
+  write(string: string, offset?: number, encoding?: BufferEncoding): number
+  write(string: string, offset?: number, length?: number, encoding?: BufferEncoding): number
+
+  /**
+   * Write a 64-bit big-endian double at `offset`.
+   * @param value - The double-precision number to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeDoubleBE(value: number, offset?: number): number
+  /**
+   * Write a 64-bit little-endian double at `offset`.
+   * @param value - The double-precision number to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeDoubleLE(value: number, offset?: number): number
+
+  /**
+   * Write a 32-bit big-endian float at `offset`.
+   * @param value - The single-precision number to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeFloatBE(value: number, offset?: number): number
+  /**
+   * Write a 32-bit little-endian float at `offset`.
+   * @param value - The single-precision number to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeFloatLE(value: number, offset?: number): number
+
+  /**
+   * Write a signed 8-bit integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 1`, the offset immediately following the written value.
+   */
+  writeInt8(value: number, offset?: number): number
+
+  /**
+   * Write a signed 16-bit big-endian integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 2`, the offset immediately following the written value.
+   */
+  writeInt16BE(value: number, offset?: number): number
+  /**
+   * Write a signed 16-bit little-endian integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 2`, the offset immediately following the written value.
+   */
+  writeInt16LE(value: number, offset?: number): number
+
+  /**
+   * Write a signed 32-bit big-endian integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeInt32BE(value: number, offset?: number): number
+  /**
+   * Write a signed 32-bit little-endian integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeInt32LE(value: number, offset?: number): number
+
+  /**
+   * Write a signed, big-endian, `byteLength`-byte integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to.
+   * @param byteLength - Number of bytes to write, from `1` to `6`.
+   * @returns `offset + byteLength`, the offset immediately following the written value.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  writeIntBE(value: number, offset: number, byteLength: number): number
+  /**
+   * Write a signed, little-endian, `byteLength`-byte integer at `offset`.
+   * @param value - The signed integer to write.
+   * @param offset - Byte offset to write to.
+   * @param byteLength - Number of bytes to write, from `1` to `6`.
+   * @returns `offset + byteLength`, the offset immediately following the written value.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  writeIntLE(value: number, offset: number, byteLength: number): number
+
+  /**
+   * Write a signed 64-bit big-endian integer at `offset`.
+   * @param value - The signed `bigint` to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeBigInt64BE(value: bigint, offset?: number): number
+  /**
+   * Write a signed 64-bit little-endian integer at `offset`.
+   * @param value - The signed `bigint` to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeBigInt64LE(value: bigint, offset?: number): number
+
+  /**
+   * Write an unsigned 8-bit integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 1`, the offset immediately following the written value.
+   */
+  writeUInt8(value: number, offset?: number): number
+  /**
+   * Write an unsigned 8-bit integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 1`, the offset immediately following the written value.
+   */
+  writeUint8(value: number, offset?: number): number
+
+  /**
+   * Write an unsigned 16-bit big-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 2`, the offset immediately following the written value.
+   */
+  writeUInt16BE(value: number, offset?: number): number
+  /**
+   * Write an unsigned 16-bit big-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 2`, the offset immediately following the written value.
+   */
+  writeUint16BE(value: number, offset?: number): number
+  /**
+   * Write an unsigned 16-bit little-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 2`, the offset immediately following the written value.
+   */
+  writeUInt16LE(value: number, offset?: number): number
+  /**
+   * Write an unsigned 16-bit little-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 2`, the offset immediately following the written value.
+   */
+  writeUint16LE(value: number, offset?: number): number
+
+  /**
+   * Write an unsigned 32-bit big-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeUInt32BE(value: number, offset?: number): number
+  /**
+   * Write an unsigned 32-bit big-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeUint32BE(value: number, offset?: number): number
+  /**
+   * Write an unsigned 32-bit little-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeUInt32LE(value: number, offset?: number): number
+  /**
+   * Write an unsigned 32-bit little-endian integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 4`, the offset immediately following the written value.
+   */
+  writeUint32LE(value: number, offset?: number): number
+
+  /**
+   * Write an unsigned, big-endian, `byteLength`-byte integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to.
+   * @param byteLength - Number of bytes to write, from `1` to `6`.
+   * @returns `offset + byteLength`, the offset immediately following the written value.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  writeUIntBE(value: number, offset: number, byteLength: number): number
+  /**
+   * Write an unsigned, big-endian, `byteLength`-byte integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to.
+   * @param byteLength - Number of bytes to write, from `1` to `6`.
+   * @returns `offset + byteLength`, the offset immediately following the written value.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  writeUintBE(value: number, offset: number, byteLength: number): number
+  /**
+   * Write an unsigned, little-endian, `byteLength`-byte integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to.
+   * @param byteLength - Number of bytes to write, from `1` to `6`.
+   * @returns `offset + byteLength`, the offset immediately following the written value.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  writeUIntLE(value: number, offset: number, byteLength: number): number
+  /**
+   * Write an unsigned, little-endian, `byteLength`-byte integer at `offset`.
+   * @param value - The unsigned integer to write.
+   * @param offset - Byte offset to write to.
+   * @param byteLength - Number of bytes to write, from `1` to `6`.
+   * @returns `offset + byteLength`, the offset immediately following the written value.
+   * @throws {RangeError} thrown if `byteLength` is not between `1` and `6`.
+   */
+  writeUintLE(value: number, offset: number, byteLength: number): number
+
+  /**
+   * Write an unsigned 64-bit big-endian integer at `offset`.
+   * @param value - The unsigned `bigint` to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeBigUint64BE(value: bigint, offset?: number): number
+  /**
+   * Write an unsigned 64-bit big-endian integer at `offset`.
+   * @param value - The unsigned `bigint` to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeBigUInt64BE(value: bigint, offset?: number): number
+  /**
+   * Write an unsigned 64-bit little-endian integer at `offset`.
+   * @param value - The unsigned `bigint` to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeBigUint64LE(value: bigint, offset?: number): number
+  /**
+   * Write an unsigned 64-bit little-endian integer at `offset`.
+   * @param value - The unsigned `bigint` to write.
+   * @param offset - Byte offset to write to; defaults to `0`.
+   * @returns `offset + 8`, the offset immediately following the written value.
+   */
+  writeBigUInt64LE(value: bigint, offset?: number): number
+}
+
+declare class Buffer extends Uint8Array<ArrayBuffer> {
+  /**
+   * Create a `Buffer` viewing `arrayBuffer`, optionally starting at `offset` for `length` bytes.
+   * @param arrayBuffer - The `ArrayBuffer` to view.
+   * @param offset - Byte offset into `arrayBuffer` to start the view at; defaults to `0`.
+   * @param length - Number of bytes to view from `offset`; defaults to the rest of `arrayBuffer`.
+   * @throws {RangeError} thrown if the resulting length would exceed `Buffer.constants.MAX_LENGTH`.
+   */
+  constructor(arrayBuffer: ArrayBuffer, offset?: number, length?: number)
+}
+
+/** A fixed-length view of binary data, backed by an `ArrayBuffer` and extending `Uint8Array`. */
+declare namespace Buffer {
+  /**
+   * The size, in bytes, of the internal buffer pool used to satisfy small allocations. Setting it
+   * to `0` turns pooling off.
+   * @throws {TypeError} thrown if assigned a value that is not a number.
+   * @throws {RangeError} thrown if assigned a value that is not an integer between `0` and
+   * `Buffer.constants.MAX_LENGTH`.
+   */
+  export let poolSize: number
+
+  /**
+   * Check whether `value` is a `Buffer`.
+   * @param value - The value to check.
+   */
+  export function isBuffer(value: unknown): value is Buffer
+
+  /**
+   * Check whether `encoding` is a supported `BufferEncoding`.
+   * @param encoding - The encoding name to check.
+   */
+  export function isEncoding(encoding: string): encoding is BufferEncoding
+
+  /**
+   * Check whether `buffer` contains only valid ASCII-encoded data.
+   * @param buffer - The buffer or view to check.
+   * @throws {TypeError} thrown if `buffer` is not a view.
+   * @throws {RangeError} thrown if `buffer`'s range lies outside its backing store.
+   */
+  export function isASCII(buffer: Buffer | ArrayBufferView): boolean
+  /**
+   * Check whether `buffer` contains only valid ASCII-encoded data.
+   * @param buffer - The buffer or view to check.
+   * @throws {TypeError} thrown if `buffer` is not a view.
+   * @throws {RangeError} thrown if `buffer`'s range lies outside its backing store.
+   */
+  export function isAscii(buffer: Buffer | ArrayBufferView): boolean
+
+  /**
+   * Check whether `buffer` contains only valid UTF-8-encoded data.
+   * @param buffer - The buffer or view to check.
+   * @throws {TypeError} thrown if `buffer` is not a view.
+   * @throws {RangeError} thrown if `buffer`'s range lies outside its backing store.
+   */
+  export function isUTF8(buffer: Buffer | ArrayBufferView): boolean
+  /**
+   * Check whether `buffer` contains only valid UTF-8-encoded data.
+   * @param buffer - The buffer or view to check.
+   * @throws {TypeError} thrown if `buffer` is not a view.
+   * @throws {RangeError} thrown if `buffer`'s range lies outside its backing store.
+   */
+  export function isUtf8(buffer: Buffer | ArrayBufferView): boolean
+
+  /**
+   * Allocate a new, zero-filled `Buffer` of `size` bytes, optionally filled with `fill`.
+   * @param size - Number of bytes to allocate.
+   * @param fill - Value to fill the buffer with — a string, view, number byte, or boolean.
+   * @param encoding - Encoding used to interpret `fill` when it's a string; defaults to `'utf8'`.
+   * @throws {RangeError} thrown if `size` is not an integer between `0` and
+   * `Buffer.constants.MAX_LENGTH`.
+   * @throws {TypeError} thrown if `size` is not a number, or `fill` is not a value that can fill.
+   */
+  export function alloc(size: number, fill: string, encoding?: BufferEncoding): Buffer
+  export function alloc(size: number, fill?: Buffer | ArrayBufferView | number | boolean): Buffer
+
+  /**
+   * Allocate a new `Buffer` of `size` bytes without zeroing its contents first.
+   * @param size - Number of bytes to allocate.
+   * @throws {RangeError} thrown if `size` is not an integer between `0` and
+   * `Buffer.constants.MAX_LENGTH`.
+   * @throws {TypeError} thrown if `size` is not a number.
+   */
+  export function allocUnsafe(size: number): Buffer
+
+  /**
+   * Allocate a new `Buffer` of `size` bytes without zeroing its contents first, bypassing the
+   * internal buffer pool.
+   * @param size - Number of bytes to allocate.
+   * @throws {RangeError} thrown if `size` is not an integer between `0` and
+   * `Buffer.constants.MAX_LENGTH`.
+   * @throws {TypeError} thrown if `size` is not a number.
+   */
+  export function allocUnsafeSlow(size: number): Buffer
+
+  /**
+   * Return the number of bytes `string` would occupy once encoded as `encoding`.
+   * @param string - The value whose encoded length to measure — a string, or an
+   * `ArrayBufferView`/`ArrayBufferLike` (whose own `byteLength` is returned unchanged).
+   * @param encoding - Encoding used to measure `string` when it's a string; defaults to `'utf8'`.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   */
+  export function byteLength(
+    string: ArrayBufferView | ArrayBufferLike | string,
+    encoding?: BufferEncoding
+  ): number
+
+  /**
+   * Compare two buffers' contents lexicographically, returning -1, 0, or 1 for sort ordering.
+   * @param a - The first buffer to compare.
+   * @param b - The second buffer to compare.
+   * @throws {TypeError} thrown if `a` or `b` is not a view.
+   * @throws {RangeError} thrown if either view's range lies outside its backing store.
+   */
+  export function compare(a: Buffer | ArrayBufferView, b: Buffer | ArrayBufferView): number
+
+  /**
+   * Concatenate `buffers` into a single new `Buffer`, optionally truncated or zero-padded to
+   * `length`.
+   * @param buffers - The buffers to concatenate, in order.
+   * @param length - Total byte length of the result; defaults to the sum of `buffers`' lengths.
+   * @throws {RangeError} thrown if an offset or length is not an integer.
+   */
+  export function concat(buffers: Buffer[], length?: number): Buffer
+
+  /**
+   * Return `buffer` unchanged if it is already a `Buffer`, otherwise wrap its underlying
+   * `ArrayBuffer` in a new `Buffer`.
+   * @param buffer - The buffer or view to coerce into a `Buffer`.
+   */
+  export function coerce(buffer: Buffer | ArrayBufferView): Buffer
+
+  /**
+   * Copy the bytes of `view`, starting at `offset` for `length` elements, into a new `Buffer`.
+   * @param view - The typed array (or other `ArrayBufferLike` view) to copy bytes from.
+   * @param offset - Index of the first element to copy; defaults to `0`.
+   * @param length - Number of elements to copy; defaults to the rest of `view`.
+   * @throws {RangeError} thrown if `offset + length` exceeds `view.length`.
+   * @throws {RangeError} thrown if an offset or length is not an integer.
+   */
+  export function copyBytesFrom(view: ArrayBufferLike, offset?: number, length?: number): Buffer
+
+  /**
+   * Create a new `Buffer` from an array, array-like, string, or `ArrayBuffer`.
+   * @param data - The array, array-like, string, buffer, or `ArrayBuffer` to create a new `Buffer`
+   * from.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`, or if `string`
+   * is not valid in it, as a hex or base64 string can fail to be.
+   * @throws {RangeError} thrown if an offset or length is not an integer.
+   */
+  export function from(data: Iterable<number>): Buffer
+  export function from(data: ArrayLike<number>): Buffer
+  export function from(string: string, encoding?: BufferEncoding): Buffer
+  export function from(arrayBuffer: ArrayBufferLike, offset?: number, length?: number): Buffer
+
+  /**
+   * Decode a base64-encoded string into a Latin-1 binary string.
+   * @param data - The base64-encoded string to decode.
+   */
+  export function atob(data: unknown): string
+  /**
+   * Encode a Latin-1 binary string into a base64 string.
+   * @param data - The value to encode; non-strings are coerced with `String()`.
+   */
+  export function btoa(data: unknown): string
+
+  /**
+   * Re-encode `buffer` from one encoding to another, returning a new `Buffer`.
+   * @param buffer - The buffer to re-encode.
+   * @param from - The encoding `buffer` is currently in.
+   * @param to - The encoding to convert to.
+   * @throws {Error} thrown if the encoding is not a recognized `BufferEncoding`.
+   */
+  export function transcode(buffer: Buffer, from: BufferEncoding, to: BufferEncoding): Buffer
+
+  export { Buffer, type BufferEncoding, constants }
+}
+
+export = Buffer