teleproto 1.214.0

package/network/connection/TCPAbridged.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPAbridged = exports.AbridgedPacketCodec = void 0;
+const Helpers_1 = require("../../Helpers");
+const Connection_1 = require("./Connection");
+const big_integer_1 = __importDefault(require("big-integer"));
+class AbridgedPacketCodec extends Connection_1.PacketCodec {
+    constructor(props) {
+        super(props);
+        this.tag = AbridgedPacketCodec.tag;
+        this.obfuscateTag = AbridgedPacketCodec.obfuscateTag;
+    }
+    encodePacket(data) {
+        let length = data.length >> 2;
+        let temp;
+        if (length < 127) {
+            const b = Buffer.alloc(1);
+            b.writeUInt8(length, 0);
+            temp = b;
+        }
+        else {
+            temp = Buffer.concat([
+                Buffer.from("7f", "hex"),
+                (0, Helpers_1.readBufferFromBigInt)((0, big_integer_1.default)(length), 3),
+            ]);
+        }
+        return Buffer.concat([temp, data]);
+    }
+    async readPacket(reader) {
+        const readData = await reader.read(1);
+        let length = readData[0];
+        if (length >= 127) {
+            length = Buffer.concat([
+                await reader.read(3),
+                Buffer.alloc(1),
+            ]).readInt32LE(0);
+        }
+        return reader.read(length << 2);
+    }
+}
+exports.AbridgedPacketCodec = AbridgedPacketCodec;
+AbridgedPacketCodec.tag = Buffer.from("ef", "hex");
+AbridgedPacketCodec.obfuscateTag = Buffer.from("efefefef", "hex");
+/**
+ * This is the mode with the lowest overhead, as it will
+ * only require 1 byte if the packet length is less than
+ * 508 bytes (127 << 2, which is very common).
+ */
+class ConnectionTCPAbridged extends Connection_1.Connection {
+    constructor() {
+        super(...arguments);
+        this.PacketCodecClass = AbridgedPacketCodec;
+    }
+}
+exports.ConnectionTCPAbridged = ConnectionTCPAbridged;

package/network/connection/TCPFull.d.ts

@@ -0,0 +1,16 @@
+import { Connection, PacketCodec } from "./Connection";
+import type { PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+export declare class FullPacketCodec extends PacketCodec {
+    private _sendCounter;
+    constructor(connection: any);
+    encodePacket(data: Buffer): Buffer<ArrayBuffer>;
+    /**
+     *
+     * @param reader {PromisedWebSockets}
+     * @returns {Promise<*>}
+     */
+    readPacket(reader: PromisedNetSockets | PromisedWebSockets): Promise<Buffer>;
+}
+export declare class ConnectionTCPFull extends Connection {
+    PacketCodecClass: typeof FullPacketCodec;
+}

package/network/connection/TCPFull.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPFull = exports.FullPacketCodec = void 0;
+const Connection_1 = require("./Connection");
+const Helpers_1 = require("../../Helpers");
+const errors_1 = require("../../errors");
+class FullPacketCodec extends Connection_1.PacketCodec {
+    constructor(connection) {
+        super(connection);
+        this._sendCounter = 0; // Telegram will ignore us otherwise
+    }
+    encodePacket(data) {
+        // https://core.telegram.org/mtproto#tcp-transport
+        // total length, sequence number, packet and checksum (CRC32)
+        const length = data.length + 12;
+        const e = Buffer.alloc(8);
+        e.writeInt32LE(length, 0);
+        e.writeInt32LE(this._sendCounter, 4);
+        data = Buffer.concat([e, data]);
+        const crc = Buffer.alloc(4);
+        crc.writeUInt32LE((0, Helpers_1.crc32)(data), 0);
+        this._sendCounter += 1;
+        return Buffer.concat([data, crc]);
+    }
+    /**
+     *
+     * @param reader {PromisedWebSockets}
+     * @returns {Promise<*>}
+     */
+    async readPacket(reader) {
+        const packetLenSeq = await reader.readExactly(8); // 4 and 4
+        if (packetLenSeq === undefined) {
+            // Return empty buffer in case of issue
+            return Buffer.alloc(0);
+        }
+        const packetLen = packetLenSeq.readInt32LE(0);
+        if (packetLen < 0) {
+            // # It has been observed that the length and seq can be -429,
+            // # followed by the body of 4 bytes also being -429.
+            // # See https://github.com/LonamiWebs/Telethon/issues/4042.
+            const body = await reader.readExactly(4);
+            throw new errors_1.InvalidBufferError(body);
+        }
+        let body = await reader.readExactly(packetLen - 8);
+        const checksum = body.slice(-4).readUInt32LE(0);
+        body = body.slice(0, -4);
+        const validChecksum = (0, Helpers_1.crc32)(Buffer.concat([packetLenSeq, body]));
+        if (!(validChecksum === checksum)) {
+            throw new errors_1.InvalidChecksumError(checksum, validChecksum);
+        }
+        return body;
+    }
+}
+exports.FullPacketCodec = FullPacketCodec;
+class ConnectionTCPFull extends Connection_1.Connection {
+    constructor() {
+        super(...arguments);
+        this.PacketCodecClass = FullPacketCodec;
+    }
+}
+exports.ConnectionTCPFull = ConnectionTCPFull;

package/network/connection/TCPMTProxy.d.ts

@@ -0,0 +1,49 @@
+import { ObfuscatedConnection } from "./Connection";
+import { AbridgedPacketCodec } from "./TCPAbridged";
+import { Logger, PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+interface BasicProxyInterface {
+    ip: string;
+    port: number;
+    timeout?: number;
+    username?: string;
+    password?: string;
+}
+export type MTProxyType = BasicProxyInterface & {
+    secret: string;
+    MTProxy: true;
+};
+export type SocksProxyType = BasicProxyInterface & {
+    socksType: 4 | 5;
+};
+export type ProxyInterface = MTProxyType | SocksProxyType;
+declare class MTProxyIO {
+    header?: Buffer;
+    private connection;
+    private _encrypt?;
+    private _decrypt?;
+    private _packetClass;
+    private _secret;
+    private _dcId;
+    constructor(connection: TCPMTProxy);
+    initHeader(): Promise<void>;
+    read(n: number): Promise<Buffer<any>>;
+    write(data: Buffer): void;
+}
+interface TCPMTProxyInterfaceParams {
+    ip: string;
+    port: number;
+    dcId: number;
+    loggers: Logger;
+    proxy: ProxyInterface;
+    socket: typeof PromisedNetSockets | typeof PromisedWebSockets;
+    testServers: boolean;
+}
+export declare class TCPMTProxy extends ObfuscatedConnection {
+    ObfuscatedIO: typeof MTProxyIO;
+    _secret: Buffer;
+    constructor({ ip, port, dcId, loggers, proxy, socket, testServers, }: TCPMTProxyInterfaceParams);
+}
+export declare class ConnectionTCPMTProxyAbridged extends TCPMTProxy {
+    PacketCodecClass: typeof AbridgedPacketCodec;
+}
+export {};

package/network/connection/TCPMTProxy.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPMTProxyAbridged = exports.TCPMTProxy = void 0;
+const Connection_1 = require("./Connection");
+const TCPAbridged_1 = require("./TCPAbridged");
+const Helpers_1 = require("../../Helpers");
+const CTR_1 = require("../../crypto/CTR");
+class MTProxyIO {
+    constructor(connection) {
+        this.header = undefined;
+        this.connection = connection.socket;
+        this._packetClass =
+            connection.PacketCodecClass;
+        this._secret = connection._secret;
+        this._dcId = connection._dcId;
+    }
+    async initHeader() {
+        let secret = this._secret;
+        const isDD = secret.length == 17 && secret[0] == 0xdd;
+        secret = isDD ? secret.slice(1) : secret;
+        if (secret.length != 16) {
+            throw new Error("MTProxy secret must be a hex-string representing 16 bytes");
+        }
+        const keywords = [
+            Buffer.from("50567247", "hex"),
+            Buffer.from("474554", "hex"),
+            Buffer.from("504f5354", "hex"),
+            Buffer.from("eeeeeeee", "hex"),
+        ];
+        let random;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            random = (0, Helpers_1.generateRandomBytes)(64);
+            if (random[0] !== 0xef &&
+                !random.slice(4, 8).equals(Buffer.alloc(4))) {
+                let ok = true;
+                for (const key of keywords) {
+                    if (key.equals(random.slice(0, 4))) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok) {
+                    break;
+                }
+            }
+        }
+        random = random.toJSON().data;
+        const randomReversed = Buffer.from(random.slice(8, 56)).reverse();
+        // Encryption has "continuous buffer" enabled
+        const encryptKey = await (0, Helpers_1.sha256)(Buffer.concat([Buffer.from(random.slice(8, 40)), secret]));
+        const encryptIv = Buffer.from(random.slice(40, 56));
+        const decryptKey = await (0, Helpers_1.sha256)(Buffer.concat([Buffer.from(randomReversed.slice(0, 32)), secret]));
+        const decryptIv = Buffer.from(randomReversed.slice(32, 48));
+        const encryptor = new CTR_1.CTR(encryptKey, encryptIv);
+        const decryptor = new CTR_1.CTR(decryptKey, decryptIv);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 56)),
+            this._packetClass.obfuscateTag,
+            Buffer.from(random.slice(60)),
+        ]);
+        const dcIdBytes = Buffer.alloc(2);
+        dcIdBytes.writeInt8(this._dcId, 0);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 60)),
+            dcIdBytes,
+            Buffer.from(random.slice(62)),
+        ]);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 56)),
+            Buffer.from(encryptor.encrypt(random).slice(56, 64)),
+            Buffer.from(random.slice(64)),
+        ]);
+        this.header = random;
+        this._encrypt = encryptor;
+        this._decrypt = decryptor;
+    }
+    async read(n) {
+        const data = await this.connection.readExactly(n);
+        return this._decrypt.encrypt(data);
+    }
+    write(data) {
+        this.connection.write(this._encrypt.encrypt(data));
+    }
+}
+class TCPMTProxy extends Connection_1.ObfuscatedConnection {
+    constructor({ ip, port, dcId, loggers, proxy, socket, testServers, }) {
+        super({
+            ip: proxy.ip,
+            port: proxy.port,
+            dcId: dcId,
+            loggers: loggers,
+            socket: socket,
+            proxy: proxy,
+            testServers: testServers,
+        });
+        this.ObfuscatedIO = MTProxyIO;
+        if (!("MTProxy" in proxy)) {
+            throw new Error("This connection only supports MPTProxies");
+        }
+        if (!proxy.secret) {
+            throw new Error("You need to provide the secret for the MTProxy");
+        }
+        if (proxy.secret && proxy.secret.match(/^[0-9a-f]+$/i)) {
+            // probably hex
+            this._secret = Buffer.from(proxy.secret, "hex");
+        }
+        else {
+            // probably b64
+            this._secret = Buffer.from(proxy.secret, "base64");
+        }
+    }
+}
+exports.TCPMTProxy = TCPMTProxy;
+class ConnectionTCPMTProxyAbridged extends TCPMTProxy {
+    constructor() {
+        super(...arguments);
+        this.PacketCodecClass = TCPAbridged_1.AbridgedPacketCodec;
+    }
+}
+exports.ConnectionTCPMTProxyAbridged = ConnectionTCPMTProxyAbridged;

package/network/connection/TCPObfuscated.d.ts

@@ -0,0 +1,18 @@
+import { ObfuscatedConnection } from "./Connection";
+import { AbridgedPacketCodec } from "./TCPAbridged";
+declare class ObfuscatedIO {
+    header?: Buffer;
+    private connection;
+    private _encrypt?;
+    private _decrypt?;
+    private _packetClass;
+    constructor(connection: ConnectionTCPObfuscated);
+    initHeader(): Promise<void>;
+    read(n: number): Promise<Buffer<any>>;
+    write(data: Buffer): void;
+}
+export declare class ConnectionTCPObfuscated extends ObfuscatedConnection {
+    ObfuscatedIO: typeof ObfuscatedIO;
+    PacketCodecClass: typeof AbridgedPacketCodec;
+}
+export {};

package/network/connection/TCPObfuscated.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPObfuscated = void 0;
+const Helpers_1 = require("../../Helpers");
+const Connection_1 = require("./Connection");
+const TCPAbridged_1 = require("./TCPAbridged");
+const CTR_1 = require("../../crypto/CTR");
+class ObfuscatedIO {
+    constructor(connection) {
+        this.header = undefined;
+        this.connection = connection.socket;
+        this._packetClass = connection.PacketCodecClass;
+    }
+    async initHeader() {
+        // Obfuscated messages secrets cannot start with any of these
+        const keywords = [
+            Buffer.from("50567247", "hex"),
+            Buffer.from("474554", "hex"),
+            Buffer.from("504f5354", "hex"),
+            Buffer.from("eeeeeeee", "hex"),
+        ];
+        let random;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            random = (0, Helpers_1.generateRandomBytes)(64);
+            if (random[0] !== 0xef &&
+                !random.slice(4, 8).equals(Buffer.alloc(4))) {
+                let ok = true;
+                for (const key of keywords) {
+                    if (key.equals(random.slice(0, 4))) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok) {
+                    break;
+                }
+            }
+        }
+        random = random.toJSON().data;
+        const randomReversed = Buffer.from(random.slice(8, 56)).reverse();
+        // Encryption has "continuous buffer" enabled
+        const encryptKey = Buffer.from(random.slice(8, 40));
+        const encryptIv = Buffer.from(random.slice(40, 56));
+        const decryptKey = Buffer.from(randomReversed.slice(0, 32));
+        const decryptIv = Buffer.from(randomReversed.slice(32, 48));
+        const encryptor = new CTR_1.CTR(encryptKey, encryptIv);
+        const decryptor = new CTR_1.CTR(decryptKey, decryptIv);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 56)),
+            this._packetClass.obfuscateTag,
+            Buffer.from(random.slice(60)),
+        ]);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 56)),
+            Buffer.from(encryptor.encrypt(random).slice(56, 64)),
+            Buffer.from(random.slice(64)),
+        ]);
+        this.header = random;
+        this._encrypt = encryptor;
+        this._decrypt = decryptor;
+    }
+    async read(n) {
+        const data = await this.connection.readExactly(n);
+        return this._decrypt.encrypt(data);
+    }
+    write(data) {
+        this.connection.write(this._encrypt.encrypt(data));
+    }
+}
+class ConnectionTCPObfuscated extends Connection_1.ObfuscatedConnection {
+    constructor() {
+        super(...arguments);
+        this.ObfuscatedIO = ObfuscatedIO;
+        this.PacketCodecClass = TCPAbridged_1.AbridgedPacketCodec;
+    }
+}
+exports.ConnectionTCPObfuscated = ConnectionTCPObfuscated;

package/network/connection/index.d.ts

@@ -0,0 +1,4 @@
+export { Connection } from "./Connection";
+export { ConnectionTCPFull } from "./TCPFull";
+export { ConnectionTCPAbridged } from "./TCPAbridged";
+export { ConnectionTCPObfuscated } from "./TCPObfuscated";

package/network/connection/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPObfuscated = exports.ConnectionTCPAbridged = exports.ConnectionTCPFull = exports.Connection = void 0;
+var Connection_1 = require("./Connection");
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return Connection_1.Connection; } });
+var TCPFull_1 = require("./TCPFull");
+Object.defineProperty(exports, "ConnectionTCPFull", { enumerable: true, get: function () { return TCPFull_1.ConnectionTCPFull; } });
+var TCPAbridged_1 = require("./TCPAbridged");
+Object.defineProperty(exports, "ConnectionTCPAbridged", { enumerable: true, get: function () { return TCPAbridged_1.ConnectionTCPAbridged; } });
+var TCPObfuscated_1 = require("./TCPObfuscated");
+Object.defineProperty(exports, "ConnectionTCPObfuscated", { enumerable: true, get: function () { return TCPObfuscated_1.ConnectionTCPObfuscated; } });

package/network/index.d.ts

@@ -0,0 +1,11 @@
+export { MTProtoPlainSender } from "./MTProtoPlainSender";
+export { doAuthentication } from "./Authenticator";
+export { MTProtoSender } from "./MTProtoSender";
+export declare class UpdateConnectionState {
+    static disconnected: number;
+    static connected: number;
+    static broken: number;
+    state: number;
+    constructor(state: number);
+}
+export { Connection, ConnectionTCPFull, ConnectionTCPAbridged, ConnectionTCPObfuscated, } from "./connection";

package/network/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPObfuscated = exports.ConnectionTCPAbridged = exports.ConnectionTCPFull = exports.Connection = exports.UpdateConnectionState = exports.MTProtoSender = exports.doAuthentication = exports.MTProtoPlainSender = void 0;
+var MTProtoPlainSender_1 = require("./MTProtoPlainSender");
+Object.defineProperty(exports, "MTProtoPlainSender", { enumerable: true, get: function () { return MTProtoPlainSender_1.MTProtoPlainSender; } });
+var Authenticator_1 = require("./Authenticator");
+Object.defineProperty(exports, "doAuthentication", { enumerable: true, get: function () { return Authenticator_1.doAuthentication; } });
+var MTProtoSender_1 = require("./MTProtoSender");
+Object.defineProperty(exports, "MTProtoSender", { enumerable: true, get: function () { return MTProtoSender_1.MTProtoSender; } });
+class UpdateConnectionState {
+    constructor(state) {
+        this.state = state;
+    }
+}
+exports.UpdateConnectionState = UpdateConnectionState;
+UpdateConnectionState.disconnected = -1;
+UpdateConnectionState.connected = 1;
+UpdateConnectionState.broken = 0;
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return connection_1.Connection; } });
+Object.defineProperty(exports, "ConnectionTCPFull", { enumerable: true, get: function () { return connection_1.ConnectionTCPFull; } });
+Object.defineProperty(exports, "ConnectionTCPAbridged", { enumerable: true, get: function () { return connection_1.ConnectionTCPAbridged; } });
+Object.defineProperty(exports, "ConnectionTCPObfuscated", { enumerable: true, get: function () { return connection_1.ConnectionTCPObfuscated; } });

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "teleproto",
+  "version": "1.214.0",
+  "description": "NodeJS MTProto API Telegram client library,",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sanyok12345/teleproto.git"
+  },
+  "scripts": {
+    "docs": "typedoc"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/sanyok12345/teleproto/issues"
+  },
+  "keywords": [
+    "telegram",
+    "mtproto",
+    "teleproto",
+    "client",
+    "nodejs",
+    "typescript",
+    "api"
+  ],
+  "homepage": "https://github.com/sanyok12345/teleproto#readme",
+  "devDependencies": {
+    "@types/mime": "^2.0.3",
+    "@types/node": "^22.15.18",
+    "@types/node-localstorage": "^1.3.0",
+    "@types/pako": "^1.0.1",
+    "@types/websocket": "^1.0.4",
+    "ts-node": "^9.1.1",
+    "typedoc": "^0.28.7",
+    "typescript": "^5.8.3",
+    "util": "^0.12.4"
+  },
+  "dependencies": {
+    "async-mutex": "^0.3.0",
+    "big-integer": "^1.6.48",
+    "mime": "^3.0.0",
+    "node-localstorage": "^2.2.1",
+    "pako": "^2.0.3",
+    "socks": "^2.6.2",
+    "store2": "^2.13.0",
+    "ts-custom-error": "^3.2.0",
+    "websocket": "^1.0.34"
+  }
+}

package/requestIter.d.ts

@@ -0,0 +1,24 @@
+import type { TelegramClient } from "./client/TelegramClient";
+import { helpers } from ".";
+interface BaseRequestIterInterface {
+    reverse?: boolean;
+    waitTime?: number;
+}
+export declare class RequestIter implements AsyncIterable<any> {
+    client: TelegramClient;
+    reverse: boolean | undefined;
+    waitTime: number | undefined;
+    protected readonly limit: number;
+    protected left: number;
+    protected buffer: Array<any> | undefined;
+    private index;
+    protected total: number | undefined;
+    private lastLoad;
+    kwargs: {};
+    constructor(client: TelegramClient, limit?: number, params?: BaseRequestIterInterface, args?: {});
+    _init(kwargs: any): Promise<boolean | void>;
+    [Symbol.asyncIterator](): AsyncIterator<any, any, undefined>;
+    collect(): Promise<helpers.TotalList<unknown>>;
+    _loadNextChunk(): Promise<boolean | undefined>;
+}
+export {};

package/requestIter.js

@@ -0,0 +1,109 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestIter = void 0;
+const Helpers_1 = require("./Helpers");
+const _1 = require(".");
+class RequestIter {
+    constructor(client, limit, params = {}, args = {}) {
+        this.client = client;
+        this.reverse = params.reverse;
+        this.waitTime = params.waitTime;
+        this.limit = Math.max(!limit ? Number.MAX_SAFE_INTEGER : limit, 0);
+        this.left = this.limit;
+        this.buffer = undefined;
+        this.kwargs = args;
+        this.index = 0;
+        this.total = undefined;
+        this.lastLoad = 0;
+    }
+    async _init(kwargs) {
+        // for overload
+    }
+    [Symbol.asyncIterator]() {
+        this.buffer = undefined;
+        this.index = 0;
+        this.lastLoad = 0;
+        this.left = this.limit;
+        return {
+            next: async () => {
+                if (this.buffer == undefined) {
+                    this.buffer = [];
+                    if (await this._init(this.kwargs)) {
+                        this.left = this.buffer.length;
+                    }
+                }
+                if (this.left <= 0) {
+                    return {
+                        value: undefined,
+                        done: true,
+                    };
+                }
+                if (this.index == this.buffer.length) {
+                    if (this.waitTime) {
+                        await (0, Helpers_1.sleep)(this.waitTime -
+                            (new Date().getTime() / 1000 - this.lastLoad));
+                    }
+                    this.lastLoad = new Date().getTime() / 1000;
+                    this.index = 0;
+                    this.buffer = [];
+                    const nextChunk = await this._loadNextChunk();
+                    if (nextChunk === false) {
+                        // we exit;
+                        return {
+                            value: undefined,
+                            done: true,
+                        };
+                    }
+                    if (nextChunk) {
+                        this.left = this.buffer.length;
+                    }
+                }
+                if (!this.buffer || !this.buffer.length) {
+                    return {
+                        value: undefined,
+                        done: true,
+                    };
+                }
+                const result = this.buffer[this.index];
+                this.left -= 1;
+                this.index += 1;
+                return {
+                    value: result,
+                    done: false,
+                };
+            },
+        };
+    }
+    async collect() {
+        var _a, e_1, _b, _c;
+        const result = new _1.helpers.TotalList();
+        try {
+            for (var _d = true, _e = __asyncValues(this), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const message = _c;
+                result.push(message);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        result.total = this.total;
+        return result;
+    }
+    async _loadNextChunk() {
+        throw new Error("Not Implemented");
+    }
+}
+exports.RequestIter = RequestIter;