bireader 1.0.25 → 1.0.27

package/lib/{cjs/types/src/writer.d.ts → esm/index.d.ts}

@@ -1,4 +1,3377 @@
 /// <reference types="node" />
+export declare function isBuffer(obj: Array<Buffer | Uint8Array>): boolean;
+export declare function check_size(_this: any, write_bytes: number, write_bit?: number, offset?: number): number;
+export declare function buffcheck(obj: Array<Buffer | Uint8Array>): boolean;
+export declare function arraybuffcheck(_this: any, obj: Array<Buffer | Uint8Array>): boolean;
+export declare function extendarray(_this: any, to_padd: number): void;
+export declare function checkSize(_this: any, write_bytes: number, write_bit?: number, offset?: number): number;
+export declare function skip(_this: any, bytes: number, bits?: number): void;
+export declare function goto(_this: any, byte: number, bit?: number): void;
+export declare function remove(_this: any, startOffset?: number, endOffset?: number, consume?: boolean, remove?: boolean, fillValue?: number): any;
+export declare function addData(_this: any, data: Buffer | Uint8Array, consume?: boolean, offset?: number, repalce?: boolean): void;
+export declare function hexDump(_this: any, options?: {
+    length?: number;
+    startByte?: number;
+    supressUnicode?: boolean;
+}): void;
+export declare function AND(_this: any, and_key: any, start?: number, end?: number, consume?: boolean): any;
+export declare function OR(_this: any, or_key: any, start?: number, end?: number, consume?: boolean): any;
+export declare function XOR(_this: any, xor_key: any, start?: number, end?: number, consume?: boolean): any;
+export declare function NOT(_this: any, start?: number, end?: number, consume?: boolean): any;
+export declare function LSHIFT(_this: any, shift_key: any, start?: number, end?: number, consume?: boolean): any;
+export declare function RSHIFT(_this: any, shift_key: any, start?: number, end?: number, consume?: boolean): any;
+export declare function ADD(_this: any, add_key: any, start?: number, end?: number, consume?: boolean): any;
+export declare function wbit(_this: any, value: number, bits: number, unsigned?: boolean, endian?: string): void;
+export declare function rbit(_this: any, bits?: number, unsigned?: boolean, endian?: string): number;
+export declare function wbyte(_this: any, value: number, unsigned?: boolean): void;
+export declare function rbyte(_this: any, unsigned?: boolean): number;
+export declare function wint16(_this: any, value: number, unsigned?: boolean, endian?: string): void;
+export declare function rint16(_this: any, unsigned?: boolean, endian?: string): number;
+export declare function rhalffloat(_this: any, endian?: string): number;
+export declare function whalffloat(_this: any, value: number, endian?: string): void;
+export declare function wint32(_this: any, value: number, unsigned?: boolean, endian?: string): void;
+export declare function rint32(_this: any, unsigned?: boolean, endian?: string): number;
+export declare function rfloat(_this: any, endian?: string): number;
+export declare function wfloat(_this: any, value: number, endian?: string): void;
+export declare function rint64(_this: any, unsigned?: boolean, endian?: string): bigint;
+export declare function wint64(_this: any, value: number, unsigned?: boolean, endian?: string): void;
+export declare function wdfloat(_this: any, value: number, endian?: string): void;
+export declare function rdfloat(_this: any, endian?: string): number;
+export declare function rstring(_this: any, options?: {
+    length?: number;
+    stringType?: string;
+    terminateValue?: number;
+    lengthReadSize?: number;
+    stripNull?: boolean;
+    encoding?: string;
+    endian?: string;
+}): string;
+export declare function wstring(_this: any, string: string, options?: {
+    length?: number;
+    stringType?: string;
+    terminateValue?: number;
+    lengthWriteSize?: number;
+    stripNull?: boolean;
+    encoding?: string;
+    endian?: string;
+}): void;
+/**
+* Binary reader, includes bitfields and strings
+*
+* @param {Buffer|Uint8Array} data - ```Buffer``` or ```Uint8Array```. Always found in ``biwriter.data``
+* @param {number} byteOffset - Byte offset to start reader (default 0)
+* @param {number} bitOffset - Bit offset 0-7 to start reader (default 0)
+* @param {string} endianness - Endianness ```big``` or ```little``` (default ```little```)
+* @param {boolean} strict - Strict mode: if true does not extend supplied array on outside write (default true)
+*/
+export declare class bireader {
+    endian: string;
+    offset: number;
+    bitoffset: number;
+    size: number;
+    strict: boolean;
+    errorDump: boolean;
+    data: any;
+    private isBufferOrUint8Array;
+    extendArray(to_padd: number): void;
+    /**
+    * Binary reader, includes bitfields and strings
+    *
+    * @param {Buffer|Uint8Array} data - ```Buffer``` or ```Uint8Array```. Always found in ``biwriter.data``
+    * @param {number} byteOffset - Byte offset to start reader (default 0)
+    * @param {number} bitOffset - Bit offset 0-7 to start reader (default 0)
+    * @param {string} endianness - Endianness ```big``` or ```little``` (default ```little```)
+    * @param {boolean} strict - Strict mode: if true does not extend supplied array on outside write (default true)
+    */
+    constructor(data: Array<Buffer | Uint8Array>, byteOffset?: number, bitOffset?: number, endianness?: string, strict?: boolean);
+    /**
+    *
+    * Change endian, defaults to little
+    *
+    * Can be changed at any time, doesn't loose position
+    *
+    * @param {string} endian - endianness ```big``` or ```little```
+    */
+    endianness(endian: string): void;
+    /**
+    *Sets endian to big
+    */
+    bigEndian(): void;
+    /**
+    *Sets endian to big
+    */
+    big(): void;
+    /**
+    *Sets endian to big
+    */
+    be(): void;
+    /**
+    * Sets endian to little
+    */
+    littleEndian(): void;
+    /**
+    * Sets endian to little
+    */
+    little(): void;
+    /**
+    * Sets endian to little
+    */
+    le(): void;
+    /**
+    * Offset current byte or bit position
+    * Note: Will extend array if strict mode is off and outside of max size
+    *
+    * @param {number} bytes - Bytes to skip
+    * @param {number} bits - Bits to skip (0-7)
+    */
+    skip(bytes: number, bits?: number): void;
+    /**
+    * Offset current byte or bit position
+    * Note: Will extend array if strict mode is off and outside of max size
+    *
+    * @param {number} bytes - Bytes to skip
+    * @param {number} bits - Bits to skip (0-7)
+    */
+    jump(bytes: number, bits?: number): void;
+    /**
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
+    *
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
+    */
+    goto(byte: number, bit?: number): void;
+    /**
+    * Offset current byte or bit position
+    * Note: Will extend array if strict mode is off and outside of max size
+    *
+    * @param {number} bytes - Bytes to skip
+    * @param {number} bits - Bits to skip (0-7)
+    */
+    seek(bytes: number, bits?: number): void;
+    /**
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
+    *
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
+    */
+    pointer(byte: number, bit?: number): void;
+    /**
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
+    *
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
+    */
+    warp(byte: number, bit?: number): void;
+    /**
+    * Set byte and bit position to start of data
+    */
+    rewind(): void;
+    /**
+    * Set byte and bit position to start of data
+    */
+    gotostart(): void;
+    /**
+    * Get the current byte position
+    *
+    * @return {number} current byte position
+    */
+    tell(): number;
+    /**
+    * Get the current byte position
+    *
+    * @return {number} current byte position
+    */
+    getOffset(): number;
+    /**
+    * Get the current byte position
+    *
+    * @return {number} current byte position
+    */
+    saveOffset(): number;
+    /**
+    * Get the current bit position (0-7)
+    *
+    * @return {number} current bit position
+    */
+    tellB(): number;
+    /**
+    * Get the current bit position (0-7)
+    *
+    * @return {number} current bit position
+    */
+    getOffsetBit(): number;
+    /**
+    * Get the current bit position (0-7)
+    *
+    * @return {number} current bit position
+    */
+    saveOffsetAbsBit(): number;
+    /**
+    * Get the current absolute bit position (from start of data)
+    *
+    * @return {number} current absolute bit position
+    */
+    tellAbsB(): number;
+    /**
+    * Get the current absolute bit position (from start of data)
+    *
+    * @return {number} current absolute bit position
+    */
+    getOffsetAbsBit(): number;
+    /**
+    * Get the current absolute bit position (from start of data)
+    *
+    * @return {number} current absolute bit position
+    */
+    saveOffsetBit(): number;
+    /**
+    * Disallows extending data if position is outside of max size
+    */
+    restrict(): void;
+    /**
+    * Allows extending data if position is outside of max size
+    */
+    unrestrict(): void;
+    /**
+    * XOR data
+    *
+    * @param {number|string|Uint8Array|Buffer} xorKey - Value, string or array to XOR
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    xor(xorKey: number | string | Uint8Array | Buffer, startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * XOR data
+    *
+    * @param {number|string|Uint8Array|Buffer} xorKey - Value, string or array to XOR
+    * @param {number} length - Length in bytes to XOR from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    xorThis(xorKey: number | string | Uint8Array | Buffer, length?: number, consume?: boolean): void;
+    /**
+    * OR data
+    *
+    * @param {number|string|Uint8Array|Buffer} orKey - Value, string or array to OR
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    or(orKey: number | string | Uint8Array | Buffer, startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * OR data
+    *
+    * @param {number|string|Uint8Array|Buffer} orKey - Value, string or array to OR
+    * @param {number} length - Length in bytes to OR from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    orThis(orKey: number | string | Uint8Array | Buffer, length?: number, consume?: boolean): void;
+    /**
+    * AND data
+    *
+    * @param {number|string|Array<number>|Buffer} andKey - Value, string or array to AND
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    and(andKey: number | string | Array<number> | Buffer, startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * AND data
+    *
+    * @param {number|string|Array<number>|Buffer} andKey - Value, string or array to AND
+    * @param {number} length - Length in bytes to AND from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    andThis(andKey: number | string | Array<number> | Buffer, length?: number, consume?: boolean): void;
+    /**
+    * Not data
+    *
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    not(startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * Not data
+    *
+    * @param {number} length - Length in bytes to NOT from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    notThis(length?: number, consume?: boolean): void;
+    /**
+    * Left shift data
+    *
+    * @param {number|string|Array<number>|Buffer} shiftKey - Value, string or array to left shift data
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    lShift(shiftKey: number | string | Array<number> | Buffer, startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * Left shift data
+    *
+    * @param {number|string|Array<number>|Buffer} shiftKey - Value, string or array to left shift data
+    * @param {number} length - Length in bytes to left shift from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    lShiftThis(shiftKey: number | string | Array<number> | Buffer, length?: number, consume?: boolean): void;
+    /**
+    * Right shift data
+    *
+    * @param {number|string|Array<number>|Buffer} shiftKey - Value, string or array to right shift data
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    rShift(shiftKey: number | string | Array<number> | Buffer, startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * Right shift data
+    *
+    * @param {number|string|Array<number>|Buffer} shiftKey - Value, string or array to right shift data
+    * @param {number} length - Length in bytes to right shift from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    rShiftThis(shiftKey: number | string | Array<number> | Buffer, length?: number, consume?: boolean): void;
+    /**
+    * Add value to data
+    *
+    * @param {number|string|Array<number>|Buffer} addKey - Value, string or array to add to data
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    add(addKey: number | string | Array<number> | Buffer, startOffset?: number, endOffset?: number, consume?: boolean): void;
+    /**
+    * Add value to data
+    *
+    * @param {number|string|Array<number>|Buffer} addKey - Value, string or array to add to data
+    * @param {number} length - Length in bytes to add from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    addThis(addKey: number | string | Array<number> | Buffer, length?: number, consume?: boolean): void;
+    /**
+    * Deletes part of data from start to current byte position unless supplied, returns removed
+    * Note: Errors in strict mode
+    *
+    * @param {number} startOffset - Start location (default 0)
+    * @param {number} endOffset - End location (default current position)
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    delete(startOffset?: number, endOffset?: number, consume?: boolean): Array<Buffer | Uint8Array>;
+    /**
+    * Deletes part of data from current byte position to end, returns removed
+    * Note: Errors in strict mode
+    *
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    clip(): Array<Buffer | Uint8Array>;
+    /**
+    * Deletes part of data from current byte position to end, returns removed
+    * Note: Errors in strict mode
+    *
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    trim(): Array<Buffer | Uint8Array>;
+    /**
+    * Deletes part of data from current byte position to supplied length, returns removed
+    * Note: Errors in strict mode
+    *
+    * @param {number} length - Length of data in bytes to remove
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    crop(length: number, consume?: boolean): Array<Buffer | Uint8Array>;
+    /**
+    * Deletes part of data from current position to supplied length, returns removed
+    * Note: Only works in strict mode
+    *
+    * @param {number} length - Length of data in bytes to remove
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    drop(length: number, consume?: boolean): Array<Buffer | Uint8Array>;
+    /**
+    * Returns part of data from current byte position to end of data unless supplied
+    *
+    * @param {number} startOffset - Start location (default current position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move position to end of lifted data (default false)
+    * @param {number} fillValue - Byte value to to fill returned data (does NOT fill unless supplied)
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    lift(startOffset?: number, endOffset?: number, consume?: boolean, fillValue?: number): Array<Buffer | Uint8Array>;
+    /**
+    * Returns part of data from current byte position to end of data unless supplied
+    *
+    * @param {number} startOffset - Start location (default current position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move position to end of lifted data (default false)
+    * @param {number} fillValue - Byte value to to fill returned data (does NOT fill unless supplied)
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    fill(startOffset?: number, endOffset?: number, consume?: boolean, fillValue?: number): Array<Buffer | Uint8Array>;
+    /**
+    * Extract data from current position to length supplied
+    * Note: Does not affect supplied data
+    *
+    * @param {number} length - Length of data in bytes to copy from current offset
+    * @param {number} consume - Moves offset to end of length
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    extract(length: number, consume?: boolean): Array<Buffer | Uint8Array>;
+    /**
+    * Extract data from current position to length supplied
+    * Note: Does not affect supplied data
+    *
+    * @param {number} length - Length of data in bytes to copy from current offset
+    * @param {number} consume - Moves offset to end of length
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    slice(length: number, consume?: boolean): Array<Buffer | Uint8Array>;
+    /**
+    * Extract data from current position to length supplied
+    * Note: Does not affect supplied data
+    *
+    * @param {number} length - Length of data in bytes to copy from current offset
+    * @param {number} consume - Moves offset to end of length
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    wrap(length: number, consume?: boolean): Array<Buffer | Uint8Array>;
+    /**
+    * Inserts data into data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Byte position to add at (defaults to current position)
+    */
+    insert(data: Buffer | Uint8Array, consume?: boolean, offset?: number): void;
+    /**
+    * Inserts data into data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Byte position to add at (defaults to current position)
+    */
+    place(data: Buffer | Uint8Array, consume?: boolean, offset?: number): void;
+    /**
+    * Replaces data in data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to replace in data
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Offset to add it at (defaults to current position)
+    */
+    replace(data: Buffer | Uint8Array, consume?: boolean, offset?: number): void;
+    /**
+    * Replaces data in data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to replace in data
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Offset to add it at (defaults to current position)
+    */
+    overwrite(data: Buffer | Uint8Array, consume?: boolean, offset?: number): void;
+    /**
+    * Adds data to start of supplied data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current write position to end of data (default false)
+    */
+    unshift(data: Buffer | Uint8Array, consume?: boolean): void;
+    /**
+    * Adds data to start of supplied data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current write position to end of data (default false)
+    */
+    prepend(data: Buffer | Uint8Array, consume?: boolean): void;
+    /**
+    * Adds data to end of supplied data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current write position to end of data (default false)
+    */
+    push(data: Buffer | Uint8Array, consume?: boolean): void;
+    /**
+    * Adds data to end of supplied data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current write position to end of data (default false)
+    */
+    append(data: Buffer | Uint8Array, consume?: boolean): void;
+    /**
+    * Returns current data
+    *
+    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    */
+    get(): Array<Buffer | Uint8Array>;
+    /**
+    * Returns current data
+    *
+    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    */
+    return(): Array<Buffer | Uint8Array>;
+    /**
+    * removes data
+    */
+    end(): void;
+    /**
+    * removes data
+    */
+    close(): void;
+    /**
+    * removes data
+    */
+    done(): void;
+    /**
+    * removes data
+    */
+    finished(): void;
+    /**
+    * Console logs data as hex dump
+    *
+    * @param {object} options
+    * ```javascript
+    *   {
+    *       length: 192, // number of bytes to log, default 192 or end of data
+    *       startByte: 0, // byte to start dump (default current byte position)
+    *       supressUnicode: false // Supress unicode character preview for even columns
+    *   }
+    * ```
+    */
+    hexdump(options?: {
+        length?: number;
+        startByte?: number;
+        supressUnicode?: boolean;
+    }): void;
+    /**
+    * Turn hexdump on error off (default on)
+    */
+    errorDumpOff(): void;
+    /**
+    * Turn hexdump on error on (default on)
+    */
+    errorDumpOn(): void;
+    /**
+    *
+    * Write bits, must have at least value and number of bits
+    *
+    * ``Note``: When returning to a byte write, remaining bits are skipped
+    *
+    * @param {number} value - value as int
+    * @param {number} bits - number of bits to write
+    * @param {boolean} unsigned - if value is unsigned
+    * @param {string} endian - ``big`` or ``little``
+    */
+    writeBit(value: number, bits: number, unsigned?: boolean, endian?: string): void;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    * @returns number
+    */
+    readBit(bits?: number, unsigned?: boolean, endian?: string): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    * @returns number
+    */
+    bit(bits: number, unsigned?: boolean, endian?: string): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    * @returns number
+    */
+    bit1(unsigned?: boolean, endian?: string): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit1le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit1be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit1(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit1le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit1be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit2(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit2le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit2be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit2(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit2le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit2be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit3(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit3le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit3be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit3(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit3le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit3be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit4(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit4le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit4be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit4(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit4le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit4be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit5(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit5le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit5be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit5(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit5le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit5be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit6(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit6le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit6be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit6(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit6le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit6be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit7(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit7le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit7be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit7(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit7le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit7be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit8(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit8le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit8be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit8(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit8le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit8be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit9(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit9le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit9be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit9(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit9le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit9be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit10(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit10le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit10be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit10(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit10le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit10be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit11(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit11le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit11be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit11(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit11le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit11be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit12(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit12le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit12be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit12(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit12le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit12be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit13(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit13le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit13be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit13(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit13le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit13be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit14(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit14le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit14be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit14(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit14le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit14be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit15(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit15le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit15be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit15(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit15le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit15be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit16(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit16le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit16be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit16(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit16le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit16be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit17(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit17le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit17be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit17(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit17le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit17be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit18(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit18le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit18be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit18(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit18le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit18be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit19(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit19le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit19be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit19(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit19le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit19be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit20(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit20le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit20be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit20(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit20le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit20be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit21(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit21le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit21be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit21(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit21le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit21be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit22(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit22le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit22be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit22(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit22le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit22be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit23(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit23le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit23be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit23(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit23le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit23be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit24(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit24le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit24be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit24(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit24le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit24be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit25(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit25le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit25be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit25(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit25le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit25be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit26(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit26le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit26be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit26(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit26le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit26be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit27(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit27le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit27be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit27(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit27le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit27be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit28(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit28le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit28be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit28(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit28le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit28be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit29(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit29le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit29be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit29(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit29le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit29be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit30(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit30le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit30be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit30(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit30le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit30be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit31(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit31le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit31be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit31(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit31le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit31be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit32(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit32le(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bit32be(unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit32(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit32le(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @returns number
+    */
+    ubit32be(): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @returns number
+    */
+    readUBitBE(bits: number): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @returns number
+    */
+    ubitbe(bits: number): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    readBitBE(bits: number, unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bitbe(bits: number, unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @returns number
+    */
+    readUBitLE(bits: number): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @returns number
+    */
+    ubitle(bits: number): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    readBitLE(bits: number, unsigned?: boolean): number;
+    /**
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {number} bits - bits to read
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
+    bitle(bits: number, unsigned?: boolean): number;
+    /**
+    * Read byte
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @returns number
+    */
+    readByte(unsigned?: boolean): number;
+    /**
+    * Write byte
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    */
+    writeByte(value: number, unsigned?: boolean): void;
+    /**
+    * Read byte
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @returns number
+    */
+    byte(unsigned?: boolean): number;
+    /**
+    * Read byte
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @returns number
+    */
+    int8(unsigned?: boolean): number;
+    /**
+    * Read unsigned byte
+    *
+    * @returns number
+    */
+    readUByte(): number;
+    /**
+    * Read unsigned byte
+    *
+    * @returns number
+    */
+    uint8(): number;
+    /**
+    * Read unsigned byte
+    *
+    * @returns number
+    */
+    ubyte(): number;
+    /**
+    * Read short
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    readInt16(unsigned?: boolean, endian?: string): number;
+    /**
+    * Write int16
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeInt16(value: number, unsigned?: boolean, endian?: string): void;
+    /**
+    * Read short
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    int16(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read short
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    short(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read short
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    word(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read unsigned short
+    *
+    * @param {string} endian - ```big``` or ```little```
+    *
+    * @returns number
+    */
+    readUInt16(endian?: string): number;
+    /**
+    * Read unsigned short
+    *
+    * @param {string} endian - ```big``` or ```little```
+    *
+    * @returns number
+    */
+    uint16(endian?: string): number;
+    /**
+    * Read unsigned short
+    *
+    * @param {string} endian - ```big``` or ```little```
+    *
+    * @returns number
+    */
+    ushort(endian?: string): number;
+    /**
+    * Read unsigned short
+    *
+    * @param {string} endian - ```big``` or ```little```
+    *
+    * @returns number
+    */
+    uword(endian?: string): number;
+    /**
+    * Read unsigned short in little endian
+    *
+    * @returns number
+    */
+    readUInt16LE(): number;
+    /**
+    * Read unsigned short in little endian
+    *
+    * @returns number
+    */
+    uint16le(): number;
+    /**
+    * Read unsigned short in little endian
+    *
+    * @returns number
+    */
+    ushortle(): number;
+    /**
+    * Read unsigned short in little endian
+    *
+    * @returns number
+    */
+    uwordle(): number;
+    /**
+    * Read signed short in little endian
+    *
+    * @returns number
+    */
+    readInt16LE(): number;
+    /**
+    * Read signed short in little endian
+    *
+    * @returns number
+    */
+    int16le(): number;
+    /**
+    * Read signed short in little endian
+    *
+    * @returns number
+    */
+    shortle(): number;
+    /**
+    * Read signed short in little endian
+    *
+    * @returns number
+    */
+    wordle(): number;
+    /**
+    * Read unsigned short in big endian
+    *
+    * @returns number
+    */
+    readUInt16BE(): number;
+    /**
+    * Read unsigned short in big endian
+    *
+    * @returns number
+    */
+    uint16be(): number;
+    /**
+    * Read unsigned short in big endian
+    *
+    * @returns number
+    */
+    ushortbe(): number;
+    /**
+    * Read unsigned short in big endian
+    *
+    * @returns number
+    */
+    uwordbe(): number;
+    /**
+    * Read signed short in big endian
+    *
+    * @returns number
+    */
+    readInt16BE(): number;
+    /**
+    * Read signed short in big endian
+    *
+    * @returns number
+    */
+    int16be(): number;
+    /**
+    * Read signed short in big endian
+    *
+    * @returns number
+    */
+    shortbe(): number;
+    /**
+    * Read signed short in big endian
+    *
+    * @returns number
+    */
+    wordbe(): number;
+    /**
+    * Read half float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    readHalfFloat(endian?: string): number;
+    /**
+    * Writes half float
+    *
+    * @param {number} value - value as int
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeHalfFloat(value: number, endian?: string): void;
+    /**
+    * Read half float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    halffloat(endian?: string): number;
+    /**
+    * Read half float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    half(endian?: string): number;
+    /**
+    * Read half float
+    *
+    * @returns number
+    */
+    readHalfFloatBE(): number;
+    /**
+    * Read half float
+    *
+    * @returns number
+    */
+    halffloatbe(): number;
+    /**
+    * Read half float
+    *
+    * @returns number
+    */
+    halfbe(): number;
+    /**
+    * Read half float
+    *
+    * @returns number
+    */
+    readHalfFloatLE(): number;
+    /**
+    * Read half float
+    *
+    * @returns number
+    */
+    halffloatle(): number;
+    /**
+    * Read half float
+    *
+    * @returns number
+    */
+    halfle(): number;
+    /**
+    * Read 32 bit integer
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    readInt32(unsigned?: boolean, endian?: string): number;
+    /**
+    * Write int32
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeInt32(value: number, unsigned?: boolean, endian?: string): void;
+    /**
+    * Read 32 bit integer
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    int(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read 32 bit integer
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    double(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read 32 bit integer
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    int32(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read 32 bit integer
+    *
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    long(unsigned?: boolean, endian?: string): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    readUInt(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    uint(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    udouble(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    uint32(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    ulong(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    readInt32BE(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    intbe(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    doublebe(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    int32be(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    longbe(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    readUInt32BE(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    uintbe(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    udoublebe(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    uint32be(): number;
+    /**
+    * Read unsigned 32 bit integer
+    *
+    * @returns number
+    */
+    ulongbe(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    readInt32LE(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    intle(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    doublele(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    int32le(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    longle(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    readUInt32LE(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    uintle(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    udoublele(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    uint32le(): number;
+    /**
+    * Read signed 32 bit integer
+    *
+    * @returns number
+    */
+    ulongle(): number;
+    /**
+    * Read float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    readFloat(endian?: string): number;
+    /**
+   * Write float
+   *
+   * @param {number} value - value as int
+   * @param {string} endian - ``big`` or ``little`
+   */
+    writeFloat(value: number, endian?: string): void;
+    /**
+    * Read float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    float(endian?: string): number;
+    /**
+    * Read float
+    *
+    * @returns number
+    */
+    readFloatBE(): number;
+    /**
+    * Read float
+    *
+    * @returns number
+    */
+    floatbe(): number;
+    /**
+    * Read float
+    *
+    * @returns number
+    */
+    readFloatLE(): number;
+    /**
+    * Read float
+    *
+    * @returns number
+    */
+    floatle(): number;
+    /**
+    * Read signed 64 bit integer
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    readInt64(unsigned?: boolean, endian?: string): bigint;
+    /**
+    * Write 64 bit integer
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeInt64(value: number, unsigned?: boolean, endian?: string): void;
+    /**
+    * Read signed 64 bit integer
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    int64(unsigned?: boolean, endian?: string): bigint;
+    /**
+    * Read signed 64 bit integer
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    bigint(unsigned?: boolean, endian?: string): bigint;
+    /**
+    * Read signed 64 bit integer
+    * @param {boolean} unsigned - if value is unsigned or not
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    quad(unsigned?: boolean, endian?: string): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    readUInt64(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    uint64(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    ubigint(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    uquad(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    readInt64BE(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    int64be(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    bigintbe(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    quadbe(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    readUInt64BE(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    uint64be(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    ubigintbe(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    uquadbe(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    readInt64LE(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    int64le(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    bigintle(): bigint;
+    /**
+    * Read signed 64 bit integer
+    *
+    * @returns number
+    */
+    quadle(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    readUInt64LE(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    uint64le(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    ubigintle(): bigint;
+    /**
+    * Read unsigned 64 bit integer
+    *
+    * @returns number
+    */
+    uquadle(): bigint;
+    /**
+    * Read double float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    readDoubleFloat(endian?: string): number;
+    /**
+    * Writes double float
+    *
+    * @param {number} value - value as int
+    * @param {number} offset - byte offset (default last write position)
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeDoubleFloat(value: number, endian?: string): void;
+    /**
+    * Read double float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    doublefloat(endian?: string): number;
+    /**
+    * Read double float
+    *
+    * @param {string} endian - ```big``` or ```little```
+    * @returns number
+    */
+    dfloat(endian?: string): number;
+    /**
+    * Read double float
+    *
+    * @returns number
+    */
+    readDoubleFloatBE(): number;
+    /**
+    * Read double float
+    *
+    * @returns number
+    */
+    dfloatebe(): number;
+    /**
+    * Read double float
+    *
+    * @returns number
+    */
+    doublefloatbe(): number;
+    /**
+    * Read double float
+    *
+    * @returns number
+    */
+    readDoubleFloatLE(): number;
+    /**
+    * Read double float
+    *
+    * @returns number
+    */
+    dfloatle(): number;
+    /**
+    * Read double float
+    *
+    * @returns number
+    */
+    doublefloatle(): number;
+    /**
+    * Reads string, use options object for different types
+    *
+    * @param {object} options
+    * ```javascript
+    * {
+    *  length: number, //for fixed length, non-terminate value utf strings
+    *  stringType: "utf-8", //utf-8, utf-16, pascal or wide-pascal
+    *  terminateValue: 0x00, // only for non-fixed length utf strings
+    *  lengthReadSize: 1, //for pascal strings. 1, 2 or 4 byte length read size
+    *  stripNull: true, // removes 0x00 characters
+    *  encoding: "utf-8", //TextEncoder accepted types
+    *  endian: "little", //for wide-pascal and utf-16
+    * }
+    * ```
+    * @return string
+    */
+    readString(options?: {
+        length?: number;
+        stringType?: string;
+        terminateValue?: number;
+        lengthReadSize?: number;
+        stripNull?: boolean;
+        encoding?: string;
+        endian?: string;
+    }): string;
+    /**
+    * Writes string, use options object for different types
+    *
+    *
+    * @param {string} string - text string
+    * @param {object} options - options:
+    * ```javascript
+    * {
+    *  length: string.length,  //for fixed length, non-terminate value utf strings
+    *  stringType: "utf-8", //utf-8, utf-16, pascal or wide-pascal
+    *  terminateValue: 0x00, // only with stringType: "utf"
+    *  lengthWriteSize: 1, //for pascal strings. 1, 2 or 4 byte length write size
+    *  encoding: "utf-8", //TextEncoder accepted types
+    *  endian: "little", //for wide-pascal and utf-16
+    * }
+    * ```
+    */
+    writeString(string: string, options?: {
+        length?: number;
+        stringType?: string;
+        terminateValue?: number;
+        lengthWriteSize?: number;
+        stripNull?: boolean;
+        encoding?: string;
+        endian?: string;
+    }): void;
+    /**
+    * Reads string, use options object for different types
+    *
+    * @param {object} options
+    * ```javascript
+    * {
+    *  length: number, //for fixed length, non-terminate value utf strings
+    *  stringType: "utf-8", //utf-8, utf-16, pascal or wide-pascal
+    *  terminateValue: 0x00, // only for non-fixed length utf strings
+    *  lengthReadSize: 1, //for pascal strings. 1, 2 or 4 byte length read size
+    *  stripNull: true, // removes 0x00 characters
+    *  encoding: "utf-8", //TextEncoder accepted types
+    *  endian: "little", //for wide-pascal and utf-16
+    * }
+    * ```
+    * @return string
+    */
+    string(options?: {
+        length?: number;
+        stringType?: string;
+        terminateValue?: number;
+        lengthReadSize?: number;
+        stripNull?: boolean;
+        encoding?: string;
+        endian?: string;
+    }): string;
+    /**
+    * Reads UTF-8 (C) string
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    utf8string(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads UTF-8 (C) string
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    cstring(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads ANSI string
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    ansistring(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads UTF-16 (Unicode) string
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    utf16string(length?: number, terminateValue?: number, stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads UTF-16 (Unicode) string
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    unistring(length?: number, terminateValue?: number, stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads UTF-16 (Unicode) string in little endian order
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    utf16stringle(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads UTF-16 (Unicode) string in little endian order
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    unistringle(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads UTF-16 (Unicode) string in big endian order
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    utf16stringbe(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads UTF-16 (Unicode) string in big endian order
+    *
+    * @param {number} length - for fixed length utf strings
+    * @param {number} terminateValue - for non-fixed length utf strings
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    unistringbe(length?: number, terminateValue?: number, stripNull?: boolean): string;
+    /**
+    * Reads Pascal string
+    *
+    * @param {number} lengthReadSize - 1, 2 or 4 byte length write size (default 1)
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    pstring(lengthReadSize?: number, stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Pascal string 1 byte length read
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    pstring1(stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Pascal string 1 byte length read in little endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    pstring1le(stripNull?: boolean): string;
+    /**
+    * Reads Pascal string 1 byte length read in big endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    pstring1be(stripNull?: boolean): string;
+    /**
+    * Reads Pascal string 2 byte length read
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    pstring2(stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Pascal string 2 byte length read in little endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    pstring2le(stripNull?: boolean): string;
+    /**
+    * Reads Pascal string 2 byte length read in big endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    pstring2be(stripNull?: boolean): string;
+    /**
+    * Reads Pascal string 4 byte length read
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    pstring4(stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Pascal string 4 byte length read in little endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    pstring4le(stripNull?: boolean): string;
+    /**
+    * Reads Pascal string 4 byte length read in big endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    pstring4be(stripNull?: boolean): string;
+    /**
+    * Reads Wide-Pascal string
+    *
+    * @param {number} lengthReadSize - 1, 2 or 4 byte length write size (default 1)
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    wpstring(lengthReadSize?: number, stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Wide-Pascal string 1 byte length read
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    wpstring1(stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Wide-Pascal string 2 byte length read
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    wpstring2(stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Wide-Pascal string 2 byte length read in little endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    wpstring2le(stripNull?: boolean): string;
+    /**
+    * Reads Wide-Pascal string 2 byte length read in big endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    wpstring2be(stripNull?: boolean): string;
+    /**
+    * Reads Wide-Pascal string 4 byte length read
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    * @param {string} endian - ``big`` or ``little``
+    *
+    * @return string
+    */
+    wpstring4(stripNull?: boolean, endian?: string): string;
+    /**
+    * Reads Wide-Pascal string 4 byte length read in big endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    wpstring4be(stripNull?: boolean): string;
+    /**
+    * Reads Wide-Pascal string 4 byte length read in little endian order
+    *
+    * @param {boolean} stripNull - removes 0x00 characters
+    *
+    * @return string
+    */
+    wpstring4le(stripNull?: boolean): string;
+}
 /**
 * Binary writer, includes bitfields and strings
 *
@@ -16,10 +3389,8 @@ export declare class biwriter {
     strict: boolean;
     errorDump: boolean;
     data: any;
-    private isBuffer;
     private isBufferOrUint8Array;
     extendArray(to_padd: number): void;
-    private check_size;
     /**
     * Binary writer, includes bitfields and strings
     *
@@ -2626,14 +5997,14 @@ export declare class biwriter {
     * @param {number} value - value as int
     * @param {string} endian - ``big`` or ``little`
     */
-    ushort(value: number, offset?: number, endian?: string): void;
+    ushort(value: number, endian?: string): void;
     /**
     * Write unsigned int16
     *
     * @param {number} value - value as int
     * @param {string} endian - ``big`` or ``little`
     */
-    uword(value: number, offset?: number, endian?: string): void;
+    uword(value: number, endian?: string): void;
     /**
     * Write signed int16
     *
@@ -2763,13 +6134,13 @@ export declare class biwriter {
     *
     * @param {number} value - value as int
     */
-    writeHalfFloatBE(value: number, offset?: number): void;
+    writeHalfFloatBE(value: number): void;
     /**
     * Writes half float
     *
     * @param {number} value - value as int
     */
-    halffloatbe(value: number, offset?: number): void;
+    halffloatbe(value: number): void;
     /**
     * Writes half float
     *
@@ -2972,13 +6343,13 @@ export declare class biwriter {
     *
     * @param {number} value - value as int
     */
-    writeUInt32BE(value: number, offset?: number): void;
+    writeUInt32BE(value: number): void;
     /**
     * Write unsigned int32
     *
     * @param {number} value - value as int
     */
-    uint32be(value: number, offset?: number): void;
+    uint32be(value: number): void;
     /**
     * Write unsigned int32
     *
@@ -3571,4 +6942,4 @@ export declare class biwriter {
     */
     wpstring4be(string: string): void;
 }
-//# sourceMappingURL=writer.d.ts.map
+//# sourceMappingURL=index.d.ts.map