teleproto 1.214.0

package/tl/custom/messageButton.d.ts

@@ -0,0 +1,54 @@
+import type { TelegramClient } from "../../client/TelegramClient";
+import type { ButtonLike, EntityLike, MessageIDLike } from "../../define";
+import { Api } from "../api";
+import { inspect } from "../../inspect";
+export declare class MessageButton {
+    private readonly _client;
+    private readonly _chat;
+    readonly button: ButtonLike;
+    private readonly _bot?;
+    private readonly _msgId;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(client: TelegramClient, original: ButtonLike, chat: EntityLike, bot: EntityLike | undefined, msgId: MessageIDLike);
+    get client(): TelegramClient;
+    get text(): string;
+    get data(): Api.bytes | undefined;
+    get inlineQuery(): string | undefined;
+    get url(): string | undefined;
+    /**
+     * Emulates the behaviour of clicking this button.
+
+     If it's a normal `KeyboardButton` with text, a message will be
+     sent, and the sent `Message <Message>` returned.
+
+     If it's an inline `KeyboardButtonCallback` with text and data,
+     it will be "clicked" and the `BotCallbackAnswer` returned.
+
+     If it's an inline `KeyboardButtonSwitchInline` button, the
+     `StartBot` will be invoked and the resulting updates
+     returned.
+
+     If it's a `KeyboardButtonUrl`, the URL of the button will
+     be returned.
+
+     If it's a `KeyboardButtonRequestPhone`, you must indicate that you
+     want to ``sharePhone=True`` in order to share it. Sharing it is not a
+     default because it is a privacy concern and could happen accidentally.
+
+     You may also use ``sharePhone=phone`` to share a specific number, in
+     which case either `str` or `InputMediaContact` should be used.
+
+     If it's a `KeyboardButtonRequestGeoLocation`, you must pass a
+     tuple in ``shareGeo=[longitude, latitude]``. Note that Telegram seems
+     to have some heuristics to determine impossible locations, so changing
+     this value a lot quickly may not work as expected. You may also pass a
+     `InputGeoPoint` if you find the order confusing.
+     */
+    click({ sharePhone, shareGeo, password, }: {
+        sharePhone?: boolean | string | Api.InputMediaContact;
+        shareGeo?: [number, number] | Api.InputMediaGeoPoint;
+        password?: string;
+    }): Promise<string | Api.Message | Api.messages.BotCallbackAnswer | Api.TypeUpdates | null | undefined>;
+}

package/tl/custom/messageButton.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageButton = void 0;
+const api_1 = require("../api");
+const button_1 = require("./button");
+const Helpers_1 = require("../../Helpers");
+const Password_1 = require("../../Password");
+const inspect_1 = require("../../inspect");
+class MessageButton {
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    constructor(client, original, chat, bot, msgId) {
+        this.button = original;
+        this._bot = bot;
+        this._chat = chat;
+        this._msgId = msgId;
+        this._client = client;
+    }
+    get client() {
+        return this._client;
+    }
+    get text() {
+        return !(this.button instanceof button_1.Button) ? this.button.text : "";
+    }
+    get data() {
+        if (this.button instanceof api_1.Api.KeyboardButtonCallback) {
+            return this.button.data;
+        }
+    }
+    get inlineQuery() {
+        if (this.button instanceof api_1.Api.KeyboardButtonSwitchInline) {
+            return this.button.query;
+        }
+    }
+    get url() {
+        if (this.button instanceof api_1.Api.KeyboardButtonUrl) {
+            return this.button.url;
+        }
+    }
+    /**
+     * Emulates the behaviour of clicking this button.
+
+     If it's a normal `KeyboardButton` with text, a message will be
+     sent, and the sent `Message <Message>` returned.
+
+     If it's an inline `KeyboardButtonCallback` with text and data,
+     it will be "clicked" and the `BotCallbackAnswer` returned.
+
+     If it's an inline `KeyboardButtonSwitchInline` button, the
+     `StartBot` will be invoked and the resulting updates
+     returned.
+
+     If it's a `KeyboardButtonUrl`, the URL of the button will
+     be returned.
+
+     If it's a `KeyboardButtonRequestPhone`, you must indicate that you
+     want to ``sharePhone=True`` in order to share it. Sharing it is not a
+     default because it is a privacy concern and could happen accidentally.
+
+     You may also use ``sharePhone=phone`` to share a specific number, in
+     which case either `str` or `InputMediaContact` should be used.
+
+     If it's a `KeyboardButtonRequestGeoLocation`, you must pass a
+     tuple in ``shareGeo=[longitude, latitude]``. Note that Telegram seems
+     to have some heuristics to determine impossible locations, so changing
+     this value a lot quickly may not work as expected. You may also pass a
+     `InputGeoPoint` if you find the order confusing.
+     */
+    async click({ sharePhone = false, shareGeo = [0, 0], password, }) {
+        if (this.button instanceof api_1.Api.KeyboardButton) {
+            return this._client.sendMessage(this._chat, {
+                message: this.button.text,
+                parseMode: undefined,
+            });
+        }
+        else if (this.button instanceof api_1.Api.KeyboardButtonCallback) {
+            let encryptedPassword;
+            if (password != undefined) {
+                const pwd = await this.client.invoke(new api_1.Api.account.GetPassword());
+                encryptedPassword = await (0, Password_1.computeCheck)(pwd, password);
+            }
+            const request = new api_1.Api.messages.GetBotCallbackAnswer({
+                peer: this._chat,
+                msgId: this._msgId,
+                data: this.button.data,
+                password: encryptedPassword,
+            });
+            try {
+                return await this._client.invoke(request);
+            }
+            catch (e) {
+                if (e.errorMessage == "BOT_RESPONSE_TIMEOUT") {
+                    return null;
+                }
+                throw e;
+            }
+        }
+        else if (this.button instanceof api_1.Api.KeyboardButtonSwitchInline) {
+            return this._client.invoke(new api_1.Api.messages.StartBot({
+                bot: this._bot,
+                peer: this._chat,
+                startParam: this.button.query,
+            }));
+        }
+        else if (this.button instanceof api_1.Api.KeyboardButtonUrl) {
+            return this.button.url;
+        }
+        else if (this.button instanceof api_1.Api.KeyboardButtonGame) {
+            const request = new api_1.Api.messages.GetBotCallbackAnswer({
+                peer: this._chat,
+                msgId: this._msgId,
+                game: true,
+            });
+            try {
+                return await this._client.invoke(request);
+            }
+            catch (e) {
+                if (e.errorMessage == "BOT_RESPONSE_TIMEOUT") {
+                    return null;
+                }
+                throw e;
+            }
+        }
+        else if (this.button instanceof api_1.Api.KeyboardButtonRequestPhone) {
+            if (!sharePhone) {
+                throw new Error("cannot click on phone buttons unless sharePhone=true");
+            }
+            if (sharePhone == true || typeof sharePhone == "string") {
+                const me = await this._client.getMe();
+                sharePhone = new api_1.Api.InputMediaContact({
+                    phoneNumber: (sharePhone == true ? me.phone : sharePhone) || "",
+                    firstName: me.firstName || "",
+                    lastName: me.lastName || "",
+                    vcard: "",
+                });
+            }
+            throw new Error("Not supported for now");
+            // TODO
+            //return this._client.sendFile(this._chat, phoneMedia);
+        }
+        else if (this.button instanceof api_1.Api.InputWebFileGeoPointLocation) {
+            if (!shareGeo) {
+                throw new Error("cannot click on geo buttons unless shareGeo=[longitude, latitude]");
+            }
+            throw new Error("Not supported for now");
+            // TODO
+            //return this._client.sendFile(this._chat, geoMedia);
+        }
+    }
+}
+exports.MessageButton = MessageButton;

package/tl/custom/senderGetter.d.ts

@@ -0,0 +1,28 @@
+import type { Entity } from "../../define";
+import type { TelegramClient } from "../..";
+import { Api } from "../api";
+import { ChatGetter } from "./chatGetter";
+import bigInt from "big-integer";
+import { inspect } from "../../inspect";
+interface SenderGetterConstructorInterface {
+    senderId?: bigInt.BigInteger;
+    sender?: Entity;
+    inputSender?: Api.TypeInputPeer;
+}
+export declare class SenderGetter extends ChatGetter {
+    _senderId?: bigInt.BigInteger;
+    _sender?: Entity;
+    _inputSender?: Api.TypeInputPeer;
+    _client?: TelegramClient;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    static initSenderClass(c: any, { senderId, sender, inputSender }: SenderGetterConstructorInterface): void;
+    get sender(): Entity | undefined;
+    getSender(): Promise<Entity | undefined>;
+    get inputSender(): Api.TypeInputPeer | undefined;
+    getInputSender(): Promise<Api.TypeInputPeer | undefined>;
+    get senderId(): bigInt.BigInteger | undefined;
+    _refetchSender(): Promise<void>;
+}
+export {};

package/tl/custom/senderGetter.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderGetter = void 0;
+const api_1 = require("../api");
+const Helpers_1 = require("../../Helpers");
+const chatGetter_1 = require("./chatGetter");
+const inspect_1 = require("../../inspect");
+class SenderGetter extends chatGetter_1.ChatGetter {
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    static initSenderClass(c, { senderId, sender, inputSender }) {
+        c._senderId = senderId;
+        c._sender = sender;
+        c._inputSender = inputSender;
+        c._client = undefined;
+    }
+    get sender() {
+        return this._sender;
+    }
+    async getSender() {
+        if (this._client &&
+            (!this._sender ||
+                (this._sender instanceof api_1.Api.Channel && this._sender.min)) &&
+            (await this.getInputSender())) {
+            try {
+                this._sender = await this._client.getEntity(this._inputSender);
+            }
+            catch (e) {
+                await this._refetchSender();
+            }
+        }
+        return this._sender;
+    }
+    get inputSender() {
+        if (!this._inputSender && this._senderId && this._client) {
+            try {
+                this._inputSender = this._client._entityCache.get(this._senderId);
+            }
+            catch (e) { }
+        }
+        return this._inputSender;
+    }
+    async getInputSender() {
+        if (!this.inputSender && this._senderId && this._client) {
+            await this._refetchSender();
+        }
+        return this._inputSender;
+    }
+    get senderId() {
+        return this._senderId;
+    }
+    async _refetchSender() { }
+}
+exports.SenderGetter = SenderGetter;

package/tl/generateModule.d.ts

@@ -0,0 +1 @@
+export {};

package/tl/generateModule.js

@@ -0,0 +1,17 @@
+"use strict";
+const fs = require("fs");
+const path = require("path");
+require("./types-generator/generate");
+function main() {
+    const apiTl = fs.readFileSync(path.resolve(__dirname, `./static/api.tl`), "utf-8");
+    fs.writeFileSync(path.resolve(__dirname, "./apiTl.js"), `module.exports = \`${stripTl(apiTl)}\`;`);
+    const schemaTl = fs.readFileSync(path.resolve(__dirname, `./static/schema.tl`), "utf-8");
+    fs.writeFileSync(path.resolve(__dirname, "./schemaTl.js"), `module.exports = \`${stripTl(schemaTl)}\`;`);
+}
+function stripTl(tl) {
+    return tl
+        .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "")
+        .replace(/\n\s*\n/g, "\n")
+        .replace(/`/g, "\\`");
+}
+main();

package/tl/generationHelpers.d.ts

@@ -0,0 +1,11 @@
+import type { DateLike } from "../define";
+declare const snakeToCamelCase: (name: string) => string;
+declare const variableSnakeToCamelCase: (str: string) => string;
+declare const CORE_TYPES: Set<number>;
+declare const fromLine: (line: string, isFunction: boolean) => any;
+declare function buildArgConfig(name: string, argType: string): any;
+declare const parseTl: (content: string, layer: string, methods?: any[], ignoreIds?: Set<number>) => Generator<any, void, unknown>;
+declare const findAll: (regex: RegExp, str: string, matches?: any) => any;
+export declare function serializeBytes(data: Buffer | string | any): Buffer<ArrayBuffer>;
+export declare function serializeDate(dt: DateLike | Date): Buffer<ArrayBuffer>;
+export { findAll, parseTl, buildArgConfig, fromLine, CORE_TYPES, snakeToCamelCase, variableSnakeToCamelCase, };

package/tl/generationHelpers.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableSnakeToCamelCase = exports.snakeToCamelCase = exports.CORE_TYPES = exports.fromLine = exports.parseTl = exports.findAll = void 0;
+exports.serializeBytes = serializeBytes;
+exports.serializeDate = serializeDate;
+exports.buildArgConfig = buildArgConfig;
+const Helpers_1 = require("../Helpers");
+const snakeToCamelCase = (name) => {
+    const result = name.replace(/(?:^|_)([a-z])/g, (_, g) => g.toUpperCase());
+    return result.replace(/_/g, "");
+};
+exports.snakeToCamelCase = snakeToCamelCase;
+const variableSnakeToCamelCase = (str) => str.replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace("-", "").replace("_", ""));
+exports.variableSnakeToCamelCase = variableSnakeToCamelCase;
+const CORE_TYPES = new Set([
+    0xbc799737, // boolFalse#bc799737 = Bool;
+    0x997275b5, // boolTrue#997275b5 = Bool;
+    0x3fedd339, // true#3fedd339 = True;
+    0xc4b9f9bb, // error#c4b9f9bb code:int text:string = Error;
+    0x56730bcc, // null#56730bcc = Null;
+]);
+exports.CORE_TYPES = CORE_TYPES;
+const AUTH_KEY_TYPES = new Set([
+    0x05162463, // resPQ,
+    0x83c95aec, // p_q_inner_data
+    0xa9f55f95, // p_q_inner_data_dc
+    0x3c6a84d4, // p_q_inner_data_temp
+    0x56fddf88, // p_q_inner_data_temp_dc
+    0xd0e8075c, // server_DH_params_ok
+    0xb5890dba, // server_DH_inner_data
+    0x6643b654, // client_DH_inner_data
+    0xd712e4be, // req_DH_params
+    0xf5045f1f, // set_client_DH_params
+    0x3072cfa1, // gzip_packed
+]);
+const fromLine = (line, isFunction) => {
+    const match = line.match(/([\w.]+)(?:#([0-9a-fA-F]+))?(?:\s{?\w+:[\w\d<>#.?!]+}?)*\s=\s([\w\d<>#.?]+);$/);
+    if (!match) {
+        // Probably "vector#1cb5c415 {t:Type} # [ t ] = Vector t;"
+        throw new Error(`Cannot parse TLObject ${line}`);
+    }
+    const argsMatch = findAll(/({)?(\w+):([\w\d<>#.?!]+)}?/, line);
+    const currentConfig = {
+        name: match[1],
+        constructorId: parseInt(match[2], 16),
+        argsConfig: {},
+        subclassOfId: (0, Helpers_1.crc32)(match[3]),
+        result: match[3],
+        isFunction: isFunction,
+        namespace: undefined,
+    };
+    if (!currentConfig.constructorId) {
+        const hexId = "";
+        let args;
+        if (Object.values(currentConfig.argsConfig).length) {
+            args = ` ${Object.keys(currentConfig.argsConfig)
+                .map((arg) => arg.toString())
+                .join(" ")}`;
+        }
+        else {
+            args = "";
+        }
+        const representation = `${currentConfig.name}${hexId}${args} = ${currentConfig.result}`
+            .replace(/(:|\?)bytes /g, "$1string ")
+            .replace(/</g, " ")
+            .replace(/>|{|}/g, "")
+            .replace(/ \w+:flags(\d+)?\.\d+\?true/g, "");
+        if (currentConfig.name === "inputMediaInvoice") {
+            // eslint-disable-next-line no-empty
+            if (currentConfig.name === "inputMediaInvoice") {
+            }
+        }
+        currentConfig.constructorId = (0, Helpers_1.crc32)(Buffer.from(representation, "utf8"));
+    }
+    for (const [brace, name, argType] of argsMatch) {
+        if (brace === undefined) {
+            // @ts-ignore
+            currentConfig.argsConfig[variableSnakeToCamelCase(name)] =
+                buildArgConfig(name, argType);
+        }
+    }
+    if (currentConfig.name.includes(".")) {
+        [currentConfig.namespace, currentConfig.name] =
+            currentConfig.name.split(/\.(.+)/);
+    }
+    currentConfig.name = snakeToCamelCase(currentConfig.name);
+    /*
+    for (const arg in currentConfig.argsConfig){
+      if (currentConfig.argsConfig.hasOwnProperty(arg)){
+        if (currentConfig.argsConfig[arg].flagIndicator){
+          delete  currentConfig.argsConfig[arg]
+        }
+      }
+    }*/
+    return currentConfig;
+};
+exports.fromLine = fromLine;
+function buildArgConfig(name, argType) {
+    name = name === "self" ? "is_self" : name;
+    // Default values
+    const currentConfig = {
+        isVector: false,
+        isFlag: false,
+        skipConstructorId: false,
+        flagName: null,
+        flagIndex: -1,
+        flagIndicator: true,
+        type: null,
+        useVectorId: null,
+    };
+    // Special case: some types can be inferred, which makes it
+    // less annoying to type. Currently the only type that can
+    // be inferred is if the name is 'random_id', to which a
+    // random ID will be assigned if left as None (the default)
+    const canBeInferred = name === "random_id";
+    // The type can be an indicator that other arguments will be flags
+    if (argType !== "#") {
+        currentConfig.flagIndicator = false;
+        // Strip the exclamation mark always to have only the name
+        currentConfig.type = argType.replace(/^!+/, "");
+        // The type may be a flag (flags.IDX?REAL_TYPE)
+        // Note that 'flags' is NOT the flags name; this
+        // is determined by a previous argument
+        // However, we assume that the argument will always be starts with 'flags'
+        // @ts-ignore
+        const flagMatch = currentConfig.type.match(/(flags(?:\d+)?).(\d+)\?([\w<>.]+)/);
+        if (flagMatch) {
+            currentConfig.isFlag = true;
+            // As of layer 140, flagName can be "flags" or "flags2"
+            currentConfig.flagName = flagMatch[1];
+            currentConfig.flagIndex = Number(flagMatch[2]);
+            // Update the type to match the exact type, not the "flagged" one
+            currentConfig.type = flagMatch[3];
+        }
+        // Then check if the type is a Vector<REAL_TYPE>
+        // @ts-ignore
+        const vectorMatch = currentConfig.type.match(/[Vv]ector<([\w\d.]+)>/);
+        if (vectorMatch) {
+            currentConfig.isVector = true;
+            // If the type's first letter is not uppercase, then
+            // it is a constructor and we use (read/write) its ID.
+            // @ts-ignore
+            currentConfig.useVectorId = currentConfig.type.charAt(0) === "V";
+            // Update the type to match the one inside the vector
+            [, currentConfig.type] = vectorMatch;
+        }
+        // See use_vector_id. An example of such case is ipPort in
+        // help.configSpecial
+        // @ts-ignore
+        if (/^[a-z]$/.test(currentConfig.type.split(".").pop().charAt(0))) {
+            currentConfig.skipConstructorId = true;
+        }
+        // The name may contain "date" in it, if this is the case and
+        // the type is "int", we can safely assume that this should be
+        // treated as a "date" object. Note that this is not a valid
+        // Telegram object, but it's easier to work with
+        // if (
+        //     this.type === 'int' &&
+        //     (/(\b|_)([dr]ate|until|since)(\b|_)/.test(name) ||
+        //         ['expires', 'expires_at', 'was_online'].includes(name))
+        // ) {
+        //     this.type = 'date';
+        // }
+    }
+    // workaround
+    if (currentConfig.type == "future_salt") {
+        currentConfig.type = "FutureSalt";
+    }
+    return currentConfig;
+}
+const parseTl = function* (content, layer, methods = [], ignoreIds = CORE_TYPES) {
+    const methodInfo = (methods || []).reduce((o, m) => (Object.assign(Object.assign({}, o), { [m.name]: m })), {});
+    const objAll = [];
+    const objByName = {};
+    const objByType = {};
+    const file = content;
+    let isFunction = false;
+    for (let line of file.split("\n")) {
+        const commentIndex = line.indexOf("//");
+        if (commentIndex !== -1) {
+            line = line.slice(0, commentIndex);
+        }
+        line = line.trim();
+        if (!line) {
+            continue;
+        }
+        const match = line.match(/---(\w+)---/);
+        if (match) {
+            const [, followingTypes] = match;
+            isFunction = followingTypes === "functions";
+            continue;
+        }
+        try {
+            const result = fromLine(line, isFunction);
+            if (ignoreIds.has(result.constructorId)) {
+                continue;
+            }
+            objAll.push(result);
+            if (!result.isFunction) {
+                if (!objByType[result.result]) {
+                    objByType[result.result] = [];
+                }
+                objByName[result.name] = result;
+                objByType[result.result].push(result);
+            }
+        }
+        catch (e) {
+            if (!e.toString().includes("vector#1cb5c415")) {
+                throw e;
+            }
+        }
+    }
+    // Once all objects have been parsed, replace the
+    // string type from the arguments with references
+    for (const obj of objAll) {
+        if (AUTH_KEY_TYPES.has(obj.constructorId)) {
+            for (const arg in obj.argsConfig) {
+                if (obj.argsConfig[arg].type === "string") {
+                    obj.argsConfig[arg].type = "bytes";
+                }
+            }
+        }
+    }
+    for (const obj of objAll) {
+        yield obj;
+    }
+};
+exports.parseTl = parseTl;
+const findAll = (regex, str, matches = []) => {
+    if (!regex.flags.includes("g")) {
+        regex = new RegExp(regex.source, "g");
+    }
+    const res = regex.exec(str);
+    if (res) {
+        matches.push(res.slice(1));
+        findAll(regex, str, matches);
+    }
+    return matches;
+};
+exports.findAll = findAll;
+function serializeBytes(data) {
+    if (!(data instanceof Buffer)) {
+        if (typeof data == "string") {
+            data = Buffer.from(data);
+        }
+        else {
+            throw Error(`Bytes or str expected, not ${data.constructor.name}`);
+        }
+    }
+    const r = [];
+    let padding;
+    if (data.length < 254) {
+        padding = (data.length + 1) % 4;
+        if (padding !== 0) {
+            padding = 4 - padding;
+        }
+        r.push(Buffer.from([data.length]));
+        r.push(data);
+    }
+    else {
+        padding = data.length % 4;
+        if (padding !== 0) {
+            padding = 4 - padding;
+        }
+        r.push(Buffer.from([
+            254,
+            data.length % 256,
+            (data.length >> 8) % 256,
+            (data.length >> 16) % 256,
+        ]));
+        r.push(data);
+    }
+    r.push(Buffer.alloc(padding).fill(0));
+    return Buffer.concat(r);
+}
+function serializeDate(dt) {
+    if (!dt) {
+        return Buffer.alloc(4).fill(0);
+    }
+    if (dt instanceof Date) {
+        dt = Math.floor((Date.now() - dt.getTime()) / 1000);
+    }
+    if (typeof dt == "number") {
+        const t = Buffer.alloc(4);
+        t.writeInt32LE(dt, 0);
+        return t;
+    }
+    throw Error(`Cannot interpret "${dt}" as a date`);
+}

package/tl/index.d.ts

@@ -0,0 +1,3 @@
+import { Api } from "./api";
+export { Api };
+export { serializeBytes, serializeDate } from "./generationHelpers";

package/tl/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeDate = exports.serializeBytes = exports.Api = void 0;
+const api_1 = require("./api");
+Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return api_1.Api; } });
+const patched_1 = require("./patched");
+(0, patched_1.patchAll)();
+var generationHelpers_1 = require("./generationHelpers");
+Object.defineProperty(exports, "serializeBytes", { enumerable: true, get: function () { return generationHelpers_1.serializeBytes; } });
+Object.defineProperty(exports, "serializeDate", { enumerable: true, get: function () { return generationHelpers_1.serializeDate; } });

package/tl/patched/index.d.ts

@@ -0,0 +1,2 @@
+declare function patchAll(): void;
+export { patchAll };