sroosh 1.0.0

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 @@
+/// <reference types="node" />
+import { ObfuscatedConnection } from "./Connection";
+import { AbridgedPacketCodec } from "./TCPAbridged";
+export declare class ObfuscatedIO {
+    header?: Buffer;
+    private connection;
+    private _encrypt?;
+    private _decrypt?;
+    private _packetClass;
+    constructor(connection: ConnectionTCPObfuscated);
+    initHeader(): Promise<void>;
+    read(n: number): Promise<Buffer>;
+    write(data: Buffer): void;
+}
+export declare class ConnectionTCPObfuscated extends ObfuscatedConnection {
+    ObfuscatedIO: typeof ObfuscatedIO;
+    PacketCodecClass: typeof AbridgedPacketCodec;
+}

package/network/connection/TCPObfuscated.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPObfuscated = exports.ObfuscatedIO = 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));
+    }
+}
+exports.ObfuscatedIO = ObfuscatedIO;
+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,5 @@
+export { Connection } from "./Connection";
+export { ConnectionTCPFull } from "./TCPFull";
+export { ConnectionTCPAbridged } from "./TCPAbridged";
+export { ConnectionTCPObfuscated } from "./TCPObfuscated";
+export { ConnectionWebSocket } from "./ConnectionWebSocket";

package/network/connection/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionWebSocket = 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; } });
+var ConnectionWebSocket_1 = require("./ConnectionWebSocket");
+Object.defineProperty(exports, "ConnectionWebSocket", { enumerable: true, get: function () { return ConnectionWebSocket_1.ConnectionWebSocket; } });

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, ConnectionWebSocket } from "./connection";

package/network/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionWebSocket = 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; } });
+Object.defineProperty(exports, "ConnectionWebSocket", { enumerable: true, get: function () { return connection_1.ConnectionWebSocket; } });

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "sroosh",
+  "version": "1.0.0",
+  "description": "NodeJS/Browser MTProto API Sroosh client library,",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gram-js/gramjs.git"
+  },
+  "browser": {
+    "fs": false
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gram-js/gramjs/issues"
+  },
+  "keywords": [
+    "telegram",
+    "mtproto",
+    "userbot",
+    "api"
+  ],
+  "homepage": "https://github.com/gram-js/gramjs#readme",
+  "optionalDependencies": {
+    "bufferutil": "^4.0.3",
+    "utf-8-validate": "^5.0.5"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.13",
+    "@babel/plugin-proposal-class-properties": "^7.12.13",
+    "@babel/preset-env": "^7.12.16",
+    "@types/jest": "^29.5.1",
+    "@types/mime": "^2.0.3",
+    "@types/node": "^15.12.0",
+    "@types/node-localstorage": "^1.3.0",
+    "@types/pako": "^1.0.1",
+    "@types/websocket": "^1.0.4",
+    "babel-loader": "^8.2.2",
+    "jest": "^29.5.0",
+    "os-browserify": "^0.3.0",
+    "prettier": "2.3.1",
+    "process": "^0.11.10",
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^8.0.16",
+    "ts-node": "^9.1.1",
+    "typedoc": "^0.22.18",
+    "typedoc-plugin-missing-exports": "^0.22.6",
+    "typescript": "^4.2.4",
+    "util": "^0.12.4",
+    "webpack": "^5.69.0",
+    "webpack-cli": "^4.9.2"
+  },
+  "dependencies": {
+    "@cryptography/aes": "^0.1.1",
+    "async-mutex": "^0.3.0",
+    "big-integer": "^1.6.48",
+    "buffer": "^6.0.3",
+    "htmlparser2": "^6.1.0",
+    "mime": "^3.0.0",
+    "pako": "^2.0.3",
+    "path-browserify": "^1.0.1",
+    "real-cancellable-promise": "^1.1.1",
+    "store2": "^2.13.0",
+    "ts-custom-error": "^3.2.0",
+    "websocket": "^1.0.34",
+    "node-localstorage": "^2.2.1",
+    "socks": "^2.6.2"
+  }
+}

package/platform.d.ts

@@ -0,0 +1,3 @@
+export declare const isDeno: boolean;
+export declare const isBrowser: boolean;
+export declare const isNode: boolean;

package/platform.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNode = exports.isBrowser = exports.isDeno = void 0;
+exports.isDeno = "Deno" in globalThis;
+exports.isBrowser = !exports.isDeno && typeof window !== "undefined";
+exports.isNode = !exports.isBrowser;

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,107 @@
+"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 e_1, _a;
+        const result = new _1.helpers.TotalList();
+        try {
+            for (var _b = __asyncValues(this), _c; _c = await _b.next(), !_c.done;) {
+                const message = _c.value;
+                result.push(message);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        result.total = this.total;
+        return result;
+    }
+    async _loadNextChunk() {
+        throw new Error("Not Implemented");
+    }
+}
+exports.RequestIter = RequestIter;

package/sessions/Abstract.d.ts

@@ -0,0 +1,103 @@
+import type { AuthKey } from "../crypto/AuthKey";
+import type { EntityLike } from "../define";
+import { Api } from "../tl";
+export declare abstract class Session {
+    /**
+     * Creates a clone of this session file
+     * @param toInstance {Session|null}
+     * @returns {Session}
+     */
+    /**
+     * Sets the information of the data center address and port that
+     * the library should connect to, as well as the data center ID,
+     * which is currently unused.
+     * @param dcId {number}
+     * @param serverAddress {string}
+     * @param port {number}
+     */
+    abstract setDC(dcId: number, serverAddress: string, port: number): void;
+    /**
+     * Returns the currently-used data center ID.
+     */
+    abstract get dcId(): number;
+    /**
+     * Returns the server address where the library should connect to.
+     */
+    abstract get serverAddress(): string;
+    /**
+     * Returns the port to which the library should connect to.
+     */
+    abstract get port(): number;
+    /**
+     * Returns an ``AuthKey`` instance associated with the saved
+     * data center, or `undefined` if a new one should be generated.
+     */
+    abstract get authKey(): AuthKey | undefined;
+    /**
+     * Sets the ``AuthKey`` to be used for the saved data center.
+     * @param value
+     */
+    abstract set authKey(value: AuthKey | undefined);
+    /**
+     * Called before using the session
+     */
+    abstract load(): Promise<void>;
+    /**
+     *  sets auth key for a dc
+     */
+    abstract setAuthKey(authKey?: AuthKey, dcId?: number): void;
+    /**
+     *  gets auth key for a dc
+     */
+    abstract getAuthKey(dcId?: number): AuthKey | undefined;
+    /**
+     * Turns the given key into an ``InputPeer`` (e.g. ``InputPeerUser``).
+     * The library uses this method whenever an ``InputPeer`` is needed
+     * to suit several purposes (e.g. user only provided its ID or wishes
+     * to use a cached username to avoid extra RPC).
+     */
+    abstract getInputEntity(key: EntityLike): Api.TypeInputPeer;
+    /**
+     * Returns an ID of the takeout process initialized for this session,
+     * or `None` if there's no were any unfinished takeout requests.
+     */
+    /**
+     * Sets the ID of the unfinished takeout process for this session.
+     * @param value
+     */
+    /**
+     * Returns the ``UpdateState`` associated with the given `entity_id`.
+     * If the `entity_id` is 0, it should return the ``UpdateState`` for
+     * no specific channel (the "general" state). If no state is known
+     * it should ``return None``.
+     * @param entityId
+     */
+    /**
+     * Sets the given ``UpdateState`` for the specified `entity_id`, which
+     * should be 0 if the ``UpdateState`` is the "general" state (and not
+     * for any specific channel).
+     * @param entityId
+     * @param state
+     */
+    /**
+     * Called on client disconnection. Should be used to
+     * free any used resources. Can be left empty if none.
+     */
+    abstract close(): void;
+    /**
+     * called whenever important properties change. It should
+     * make persist the relevant session information to disk.
+     */
+    abstract save(): void;
+    /**
+     * Called upon client.log_out(). Should delete the stored
+     * information from disk since it's not valid anymore.
+     */
+    abstract delete(): void;
+    /**
+     * Processes the input ``TLObject`` or ``list`` and saves
+     * whatever information is relevant (e.g., ID or access hash).
+     * @param tlo
+     */
+    abstract processEntities(tlo: any): void;
+}

package/sessions/Abstract.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+class Session {
+}
+exports.Session = Session;

package/sessions/CacheApiSession.d.ts

@@ -0,0 +1,18 @@
+export = CacheApi;
+declare class CacheApi {
+    constructor(sessionId: any);
+    _storageKey: any;
+    _authKeys: {};
+    load(): Promise<void>;
+    setDC(dcId: any, serverAddress: any, port: any, skipUpdateStorage?: boolean): void;
+    _dcId: any;
+    _serverAddress: any;
+    _port: any;
+    save(): Promise<any>;
+    set authKey(arg: void);
+    get authKey(): void;
+    getAuthKey(dcId?: any): any;
+    setAuthKey(authKey: any, dcId?: any): void;
+    _updateStorage(): Promise<void>;
+    delete(): Promise<void>;
+}