@andrew_l/tl-pack 0.1.81 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Andrew L. <andrew.io.dev@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,24 +1,33 @@
-# TLPack for JavaScript/NodeJs <!-- omit in toc -->
+# TL Pack - Binary Serialization Library <!-- omit in toc -->
 
-![license](https://img.shields.io/npm/l/%40andrew_l%2Ftl-pack) ![npm version](https://img.shields.io/npm/v/%40andrew_l%2Ftl-pack) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/%40andrew_l%2Ftl-pack)
+![license](https://img.shields.io/npm/l/%40andrew_l%2Ftl-pack) <!-- omit in toc -->
+![npm version](https://img.shields.io/npm/v/%40andrew_l%2Ftl-pack) <!-- omit in toc -->
+![npm bundle size](https://img.shields.io/bundlephobia/minzip/%40andrew_l%2Ftl-pack) <!-- omit in toc -->
 
-This library is another implementation of binary serialization like **MessagePack** inspired by TL (Type Language) developed by old VK team.
+Binary serialization library, inspired by the TL (Type Language) format, created by the VK team. Unlike official TL, this version does not require a schema for serialization/deserialization. It provides a compact and fast alternative to other binary serialization formats like MessagePack.
 
-You don't needed in schema for data serialization/deserialization unlike official TL implementation at least in this version.
+⚡ **Benchmark**: Slightly faster and more compact than **@msgpack/msgpack**  
+⚠️ **Note**: Benchmark claims may vary.
 
-## Benchmark
+<!-- install placeholder -->
 
-A bit faster and a bit more compact than **@msgpack/msgpack**
+## ✨ Features
 
-## Synopsis
+- **No Schema Required**: Unlike traditional serialization formats, this version does not require a predefined schema for object serialization.
+- **Compact & Fast**: Designed to be lightweight and fast, with smaller binary output.
+- **Custom Extension Support**: Easily extend serialization to custom types.
+- **Stream Support**: Supports streaming serialization/deserialization in Node.js.
+
+## 🚀 Example Usage
+
+### Basic Example
 
 ```javascript
 import { BinaryWriter, BinaryReader } from '@andrew_l/tl-pack';
 
 const writer = new BinaryWriter();
 
-// use to compress this part of data
-// writer.writeObjectGzip
+// Serialize an object with various data types
 writer.writeObject({
   null: null,
   uint8: 255,
@@ -55,6 +64,31 @@ console.log(reader.readObject());
  */
 ```
 
+### Stream Example (Node.js Only)
+
+```javascript
+import { Readable } from 'node:stream';
+import { TLEncode, TLDecode } from '@andrew_l/tl-pack/stream';
+
+const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+const dataStream = new Readable({ objectMode: true });
+
+dataStream._read = () => {
+  const chunk = values.shift();
+
+  dataStream.push(chunk || null);
+};
+
+const encode = new TLEncode();
+const decode = new TLDecode();
+
+dataStream.pipe(encode).pipe(decode);
+
+decode.on('data', data => console.log('stream', data));
+decode.on('error', console.error);
+```
+
 ## Supported Types
 
 | Constructor ID | Byte Size          |
@@ -79,33 +113,10 @@ console.log(reader.readObject());
 | Repeat         | 5                  |
 | GZIP           | 5 + sizeof(object) |
 
-## Stream Example (NodeJs Only)
-
-```javascript
-import { Readable } from 'node:stream';
-import { TLEncode, TLDecode } from '@andrew_l/tl-pack/stream';
-
-const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-
-const dataStream = new Readable({ objectMode: true });
-
-dataStream._read = () => {
-  const chunk = values.shift();
-
-  dataStream.push(chunk || null);
-};
-
-const encode = new TLEncode();
-const decode = new TLDecode();
-
-dataStream.pipe(encode).pipe(decode);
-
-decode.on('data', (data) => console.log('stream', data));
-decode.on('error', console.error);
-```
-
 ## Custom Types
 
+You can extend tl-pack to handle custom types. For example, handling ObjectId from Mongoose:
+
 ```javascript
 import mongoose from 'mongoose';
 import { BinaryWriter, BinaryReader, createExtension } from '@andrew_l/tl-pack';
@@ -170,15 +181,12 @@ function hex(arrayBuffer: Uint8Array) {
 }
 ```
 
-## Dictionary
-
-A dictionary is used to replace strings with numeric indexes, which saves the resulting buffer size. In stream mode, the dictionary is grown while the stream is alive.
+## Dictionary Support
 
-**Static**
-Dictionary with you initialize a BinaryWriter/BinaryReader.
+The dictionary helps optimize serialization by replacing strings with numeric indexes, saving buffer space.
 
-**Dynamic**
-Dictionary which appends while encoding and decoding keys of an object (Map).
+- **Static Dictionary:** Pre-defined dictionary initialized when creating the BinaryWriter/BinaryReader.
+- **Dynamic Dictionary:** Grows dynamically during encoding and decoding, especially useful for objects (Maps).
 
 ## Production
 

package/dist/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const BinaryWriter = require('./shared/tl-pack.DfL54MjP.cjs');
+const toolkit = require('@andrew_l/toolkit');
+require('pako');
+
+function createExtension(token, { encode, decode }) {
+  toolkit.assert.ok(Math.trunc(token) === token, " Token must be integer value.");
+  toolkit.assert.ok(
+    token >= 0 && token <= 255,
+    "Token must be a 8 bit number. (0 - 255)"
+  );
+  toolkit.assert.ok(token >= 35, "Tokens from 0 to 34 reserved.");
+  return {
+    token,
+    encode,
+    decode
+  };
+}
+
+function tlEncode(value, opts) {
+  return new BinaryWriter.BinaryWriter(opts).writeObject(value).getBuffer();
+}
+function tlDecode(buffer, opts) {
+  return new BinaryWriter.BinaryReader(buffer, opts).readObject();
+}
+
+exports.BinaryReader = BinaryWriter.BinaryReader;
+exports.BinaryWriter = BinaryWriter.BinaryWriter;
+exports.CORE_TYPES = BinaryWriter.CORE_TYPES;
+exports.MAX_BUFFER_SIZE = BinaryWriter.MAX_BUFFER_SIZE;
+exports.createDictionary = BinaryWriter.createDictionary;
+exports.createExtension = createExtension;
+exports.tlDecode = tlDecode;
+exports.tlEncode = tlEncode;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/extension.ts","../src/index.ts"],"sourcesContent":["import { assert } from '@andrew_l/toolkit';\nimport type { BinaryReader } from './BinaryReader';\nimport type { BinaryWriter } from './BinaryWriter';\n\nexport type EncodeHandler = (this: BinaryWriter, value: any) => void;\n\nexport type DecodeHandler = (this: BinaryReader) => any;\n\nexport interface TLExtension {\n  token: number;\n  encode: EncodeHandler;\n  decode: DecodeHandler;\n}\n\nexport function createExtension(\n  token: number,\n  { encode, decode }: { encode: EncodeHandler; decode: DecodeHandler },\n): TLExtension {\n  assert.ok(Math.trunc(token) === token, ' Token must be integer value.');\n\n  assert.ok(\n    token >= 0 && token <= 255,\n    'Token must be a 8 bit number. (0 - 255)',\n  );\n\n  assert.ok(token >= 35, 'Tokens from 0 to 34 reserved.');\n\n  return {\n    token,\n    encode,\n    decode,\n  };\n}\n","import { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nimport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\n\nexport { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nexport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\nexport * from './constants';\nexport { createDictionary } from './dictionary';\nexport {\n  createExtension,\n  type DecodeHandler,\n  type EncodeHandler,\n  type TLExtension,\n} from './extension';\n\n/**\n * Encode any value into `Uint8Array`\n *\n * @example\n * const buffer = tlEncode(new Date(0));\n *\n * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])\n *\n * @group Main\n */\nexport function tlEncode(\n  value: unknown,\n  opts?: BinaryWriterOptions,\n): Uint8Array {\n  return new BinaryWriter(opts).writeObject(value).getBuffer();\n}\n\n/**\n * Decode value from `Uint8Array`\n *\n * @example\n * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);\n * const value = tlDecode(buffer);\n *\n * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)\n *\n * @group Main\n */\nexport function tlDecode<T = any>(\n  buffer: Uint8Array,\n  opts?: BinaryReaderOptions,\n): T {\n  return new BinaryReader(buffer, opts).readObject();\n}\n"],"names":["assert","BinaryWriter","BinaryReader"],"mappings":";;;;;;AAcO,SAAS,eACd,CAAA,KAAA,EACA,EAAE,MAAA,EAAQ,QACG,EAAA;AACb,EAAAA,cAAA,CAAO,GAAG,IAAK,CAAA,KAAA,CAAM,KAAK,CAAA,KAAM,OAAO,+BAA+B,CAAA,CAAA;AAEtE,EAAOA,cAAA,CAAA,EAAA;AAAA,IACL,KAAA,IAAS,KAAK,KAAS,IAAA,GAAA;AAAA,IACvB,yCAAA;AAAA,GACF,CAAA;AAEA,EAAOA,cAAA,CAAA,EAAA,CAAG,KAAS,IAAA,EAAA,EAAI,+BAA+B,CAAA,CAAA;AAEtD,EAAO,OAAA;AAAA,IACL,KAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,GACF,CAAA;AACF;;ACRgB,SAAA,QAAA,CACd,OACA,IACY,EAAA;AACZ,EAAA,OAAO,IAAIC,yBAAa,CAAA,IAAI,EAAE,WAAY,CAAA,KAAK,EAAE,SAAU,EAAA,CAAA;AAC7D,CAAA;AAagB,SAAA,QAAA,CACd,QACA,IACG,EAAA;AACH,EAAA,OAAO,IAAIC,yBAAA,CAAa,MAAQ,EAAA,IAAI,EAAE,UAAW,EAAA,CAAA;AACnD;;;;;;;;;;;"}

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import { B as BinaryWriterOptions, a as BinaryReaderOptions } from './shared/tl-pack.C2PEqnNg.cjs';
+export { b as BinaryReader, c as BinaryWriter, C as CORE_TYPES, D as DecodeHandler, E as EncodeHandler, M as MAX_BUFFER_SIZE, T as TLExtension, d as createDictionary, e as createExtension } from './shared/tl-pack.C2PEqnNg.cjs';
+
+/**
+ * Encode any value into `Uint8Array`
+ *
+ * @example
+ * const buffer = tlEncode(new Date(0));
+ *
+ * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])
+ *
+ * @group Main
+ */
+declare function tlEncode(value: unknown, opts?: BinaryWriterOptions): Uint8Array;
+/**
+ * Decode value from `Uint8Array`
+ *
+ * @example
+ * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);
+ * const value = tlDecode(buffer);
+ *
+ * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)
+ *
+ * @group Main
+ */
+declare function tlDecode<T = any>(buffer: Uint8Array, opts?: BinaryReaderOptions): T;
+
+export { BinaryReaderOptions, BinaryWriterOptions, tlDecode, tlEncode };

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { B as BinaryWriterOptions, a as BinaryReaderOptions } from './shared/tl-pack.C2PEqnNg.mjs';
+export { b as BinaryReader, c as BinaryWriter, C as CORE_TYPES, D as DecodeHandler, E as EncodeHandler, M as MAX_BUFFER_SIZE, T as TLExtension, d as createDictionary, e as createExtension } from './shared/tl-pack.C2PEqnNg.mjs';
+
+/**
+ * Encode any value into `Uint8Array`
+ *
+ * @example
+ * const buffer = tlEncode(new Date(0));
+ *
+ * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])
+ *
+ * @group Main
+ */
+declare function tlEncode(value: unknown, opts?: BinaryWriterOptions): Uint8Array;
+/**
+ * Decode value from `Uint8Array`
+ *
+ * @example
+ * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);
+ * const value = tlDecode(buffer);
+ *
+ * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)
+ *
+ * @group Main
+ */
+declare function tlDecode<T = any>(buffer: Uint8Array, opts?: BinaryReaderOptions): T;
+
+export { BinaryReaderOptions, BinaryWriterOptions, tlDecode, tlEncode };

package/dist/index.d.ts

@@ -1,5 +1,28 @@
-export * from './BinaryWriter.js';
-export * from './BinaryReader.js';
-export * from './constants.js';
-export * from './extension.js';
-export * from './dictionary.js';
+import { B as BinaryWriterOptions, a as BinaryReaderOptions } from './shared/tl-pack.C2PEqnNg.js';
+export { b as BinaryReader, c as BinaryWriter, C as CORE_TYPES, D as DecodeHandler, E as EncodeHandler, M as MAX_BUFFER_SIZE, T as TLExtension, d as createDictionary, e as createExtension } from './shared/tl-pack.C2PEqnNg.js';
+
+/**
+ * Encode any value into `Uint8Array`
+ *
+ * @example
+ * const buffer = tlEncode(new Date(0));
+ *
+ * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])
+ *
+ * @group Main
+ */
+declare function tlEncode(value: unknown, opts?: BinaryWriterOptions): Uint8Array;
+/**
+ * Decode value from `Uint8Array`
+ *
+ * @example
+ * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);
+ * const value = tlDecode(buffer);
+ *
+ * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)
+ *
+ * @group Main
+ */
+declare function tlDecode<T = any>(buffer: Uint8Array, opts?: BinaryReaderOptions): T;
+
+export { BinaryReaderOptions, BinaryWriterOptions, tlDecode, tlEncode };

package/dist/index.mjs

@@ -0,0 +1,28 @@
+import { B as BinaryWriter, a as BinaryReader } from './shared/tl-pack.CkwM-fIb.mjs';
+export { C as CORE_TYPES, M as MAX_BUFFER_SIZE, c as createDictionary } from './shared/tl-pack.CkwM-fIb.mjs';
+import { assert } from '@andrew_l/toolkit';
+import 'pako';
+
+function createExtension(token, { encode, decode }) {
+  assert.ok(Math.trunc(token) === token, " Token must be integer value.");
+  assert.ok(
+    token >= 0 && token <= 255,
+    "Token must be a 8 bit number. (0 - 255)"
+  );
+  assert.ok(token >= 35, "Tokens from 0 to 34 reserved.");
+  return {
+    token,
+    encode,
+    decode
+  };
+}
+
+function tlEncode(value, opts) {
+  return new BinaryWriter(opts).writeObject(value).getBuffer();
+}
+function tlDecode(buffer, opts) {
+  return new BinaryReader(buffer, opts).readObject();
+}
+
+export { BinaryReader, BinaryWriter, createExtension, tlDecode, tlEncode };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/extension.ts","../src/index.ts"],"sourcesContent":["import { assert } from '@andrew_l/toolkit';\nimport type { BinaryReader } from './BinaryReader';\nimport type { BinaryWriter } from './BinaryWriter';\n\nexport type EncodeHandler = (this: BinaryWriter, value: any) => void;\n\nexport type DecodeHandler = (this: BinaryReader) => any;\n\nexport interface TLExtension {\n  token: number;\n  encode: EncodeHandler;\n  decode: DecodeHandler;\n}\n\nexport function createExtension(\n  token: number,\n  { encode, decode }: { encode: EncodeHandler; decode: DecodeHandler },\n): TLExtension {\n  assert.ok(Math.trunc(token) === token, ' Token must be integer value.');\n\n  assert.ok(\n    token >= 0 && token <= 255,\n    'Token must be a 8 bit number. (0 - 255)',\n  );\n\n  assert.ok(token >= 35, 'Tokens from 0 to 34 reserved.');\n\n  return {\n    token,\n    encode,\n    decode,\n  };\n}\n","import { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nimport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\n\nexport { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nexport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\nexport * from './constants';\nexport { createDictionary } from './dictionary';\nexport {\n  createExtension,\n  type DecodeHandler,\n  type EncodeHandler,\n  type TLExtension,\n} from './extension';\n\n/**\n * Encode any value into `Uint8Array`\n *\n * @example\n * const buffer = tlEncode(new Date(0));\n *\n * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])\n *\n * @group Main\n */\nexport function tlEncode(\n  value: unknown,\n  opts?: BinaryWriterOptions,\n): Uint8Array {\n  return new BinaryWriter(opts).writeObject(value).getBuffer();\n}\n\n/**\n * Decode value from `Uint8Array`\n *\n * @example\n * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);\n * const value = tlDecode(buffer);\n *\n * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)\n *\n * @group Main\n */\nexport function tlDecode<T = any>(\n  buffer: Uint8Array,\n  opts?: BinaryReaderOptions,\n): T {\n  return new BinaryReader(buffer, opts).readObject();\n}\n"],"names":[],"mappings":";;;;;AAcO,SAAS,eACd,CAAA,KAAA,EACA,EAAE,MAAA,EAAQ,QACG,EAAA;AACb,EAAA,MAAA,CAAO,GAAG,IAAK,CAAA,KAAA,CAAM,KAAK,CAAA,KAAM,OAAO,+BAA+B,CAAA,CAAA;AAEtE,EAAO,MAAA,CAAA,EAAA;AAAA,IACL,KAAA,IAAS,KAAK,KAAS,IAAA,GAAA;AAAA,IACvB,yCAAA;AAAA,GACF,CAAA;AAEA,EAAO,MAAA,CAAA,EAAA,CAAG,KAAS,IAAA,EAAA,EAAI,+BAA+B,CAAA,CAAA;AAEtD,EAAO,OAAA;AAAA,IACL,KAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,GACF,CAAA;AACF;;ACRgB,SAAA,QAAA,CACd,OACA,IACY,EAAA;AACZ,EAAA,OAAO,IAAI,YAAa,CAAA,IAAI,EAAE,WAAY,CAAA,KAAK,EAAE,SAAU,EAAA,CAAA;AAC7D,CAAA;AAagB,SAAA,QAAA,CACd,QACA,IACG,EAAA;AACH,EAAA,OAAO,IAAI,YAAA,CAAa,MAAQ,EAAA,IAAI,EAAE,UAAW,EAAA,CAAA;AACnD;;;;"}

package/dist/shared/tl-pack.C2PEqnNg.d.cts

@@ -0,0 +1,200 @@
+declare enum CORE_TYPES {
+    None = 0,
+    Binary = 1,
+    BoolFalse = 2,
+    BoolTrue = 3,
+    Null = 4,
+    Date = 5,
+    Vector = 6,
+    VectorDynamic = 7,
+    Int32 = 8,
+    Int16 = 9,
+    Int8 = 10,
+    UInt32 = 11,
+    UInt16 = 12,
+    UInt8 = 13,
+    Float = 14,
+    Double = 15,
+    Map = 16,
+    DictValue = 17,
+    DictIndex = 18,
+    String = 19,
+    Repeat = 20,
+    Checksum = 21,
+    GZIP = 25
+}
+declare const MAX_BUFFER_SIZE = 2144337920;
+
+declare function createDictionary(values?: string[]): Dictionary;
+declare class Dictionary {
+    private _count;
+    private _wordToIndex;
+    private _words;
+    private _offset;
+    constructor(values?: string[], offset?: number);
+    get size(): number;
+    /**
+     * Returns inserted index or nothing
+     */
+    maybeInsert(word: string): number | null;
+    getValue(index: number): string | null;
+    getIndex(value: string): number | null;
+    hasValue(value: string): boolean;
+    hasIndex(index: number): boolean;
+}
+
+interface BinaryWriterOptions {
+    gzip?: boolean;
+    dictionary?: string[] | Dictionary;
+    extensions?: TLExtension[];
+}
+declare class BinaryWriter {
+    private withGzip;
+    private target;
+    private dictionary?;
+    private dictionaryExtended;
+    private extensions;
+    private _last;
+    private _checksumOffset;
+    private _repeat?;
+    offset: number;
+    constructor(options?: BinaryWriterOptions);
+    allocate(size: number): this;
+    private makeRoom;
+    get safeEnd(): number;
+    getBuffer(): Uint8Array;
+    writeByte(value: number): this;
+    writeBool(value: boolean): this;
+    writeNull(): this;
+    writeInt32(value: number, signed?: boolean): this;
+    writeInt16(value: number, signed?: boolean): this;
+    writeInt8(value: number, signed?: boolean): this;
+    writeFloat(value: number): this;
+    writeDouble(value: number): this;
+    writeDate(value: number | Date): this;
+    writeString(value: string): this;
+    writeChecksum(withConstructor?: boolean): this;
+    writeBytes(value: Uint8Array): this;
+    writeLength(value: number): this;
+    writeVector(value: Array<any>): this;
+    writeMap(object: Record<string, any>): this;
+    wireDictionary(value: string): this;
+    writeGzip(value: Uint8Array | ArrayBuffer): this;
+    encode(value: any): Uint8Array;
+    startDynamicVector(): this;
+    endDynamicVector(): this;
+    private _writeCustom;
+    writeObject(value: any): this;
+    writeObjectGzip(value: any): this;
+    private writeCore;
+    private writeRepeat;
+}
+
+type EncodeHandler = (this: BinaryWriter, value: any) => void;
+type DecodeHandler = (this: BinaryReader) => any;
+interface TLExtension {
+    token: number;
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}
+declare function createExtension(token: number, { encode, decode }: {
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}): TLExtension;
+
+interface BinaryReaderOptions {
+    dictionary?: string[] | Dictionary;
+    extensions?: TLExtension[];
+}
+declare class BinaryReader {
+    private target;
+    private _last?;
+    private _lastObject?;
+    private dictionary?;
+    private dictionaryExtended;
+    private extensions;
+    private _repeat?;
+    private _checksumOffset;
+    offset: number;
+    length: number;
+    /**
+     * Small utility class to read binary data.
+     */
+    constructor(data: Uint8Array, options?: BinaryReaderOptions);
+    readByte(): number;
+    readInt32(signed?: boolean): number;
+    readInt16(signed?: boolean): number;
+    readInt8(signed?: boolean): number;
+    /**
+     * Reads a real floating point (4 bytes) value.
+     * @returns {number}
+     */
+    readFloat(): number;
+    /**
+     * Reads a real floating point (8 bytes) value.
+     * @returns {BigInteger}
+     */
+    readDouble(): number;
+    /**
+     * Read the given amount of bytes, or -1 to read all remaining.
+     * @param length {number}
+     */
+    assertRead(length: number): void;
+    assertConstructor(constructorId: CORE_TYPES): void;
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     */
+    getBuffer(): Uint8Array;
+    readNull(): null;
+    readLength(): number;
+    readAll(): any[];
+    readBytes(): Uint8Array;
+    /**
+     * Reads encoded string.
+     */
+    readString(): string;
+    /**
+     * Reads a boolean value.
+     */
+    readBool(): boolean;
+    /**
+     * Reads and converts Unix time
+     * into a Javascript {Date} object.
+     */
+    readDate(): Date;
+    /**
+     * Reads a object.
+     */
+    readObject(): any;
+    readObjectGzip(): any;
+    readGzip(): any;
+    private readCore;
+    getDictionaryValue(index: number): string | null;
+    readDictionary(): null | string;
+    readMap(checkConstructor?: boolean): Record<string, any>;
+    decode<T = any>(value: Uint8Array): T;
+    /**
+     * Reads a vector (a list) of objects.
+     */
+    readVector<T = any>(checkConstructor?: boolean): T[];
+    /**
+     * Reads a vector (a list) of objects.
+     */
+    readVectorDynamic<T>(checkConstructor?: boolean): T[];
+    readChecksum(checkConstructor?: boolean): void;
+    /**
+     * Tells the current position on the stream.
+     */
+    tellPosition(): number;
+    /**
+     * Sets the current position on the stream.
+     */
+    setPosition(position: number): void;
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     */
+    seek(offset: number): void;
+}
+
+export { type BinaryWriterOptions as B, CORE_TYPES as C, type DecodeHandler as D, type EncodeHandler as E, MAX_BUFFER_SIZE as M, type TLExtension as T, type BinaryReaderOptions as a, BinaryReader as b, BinaryWriter as c, createDictionary as d, createExtension as e };