@mtkruto/node 0.1.119 → 0.1.121

package/esm/4_constants.d.ts

@@ -4,8 +4,8 @@ export type PublicKeys = readonly [bigint, [bigint, bigint]][];
 export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
-export declare const LAYER = 166;
-export declare const APP_VERSION = "MTKruto 0.1.119";
+export declare const LAYER = 167;
+export declare const APP_VERSION = "MTKruto 0.1.121";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -53,8 +53,8 @@ export const PUBLIC_KEYS = Object.freeze([
 ]);
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const INITIAL_DC = "2";
-export const LAYER = 166;
-export const APP_VERSION = "MTKruto 0.1.119";
+export const LAYER = 167;
+export const APP_VERSION = "MTKruto 0.1.121";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/4_errors.d.ts

@@ -1,17 +1,17 @@
 import { types } from "./2_tl.js";
 export * from "./3_errors.js";
-export declare class FloodWait extends types.RPCError {
+export declare class FloodWait extends types.Rpc_error {
     seconds: number;
     constructor(params: {
-        errorCode: number;
-        errorMessage: string;
+        error_code: number;
+        error_message: string;
     });
 }
-export declare class Migrate extends types.RPCError {
+export declare class Migrate extends types.Rpc_error {
     dc: number;
     constructor(params: {
-        errorCode: number;
-        errorMessage: string;
+        error_code: number;
+        error_message: string;
     });
 }
 export declare class UserMigrate extends Migrate {
@@ -22,4 +22,4 @@ export declare class FileMigrate extends Migrate {
 }
 export declare class StatsMigrate extends Migrate {
 }
-export declare function upgradeInstance(error: types.RPCError): types.RPCError;
+export declare function upgradeInstance(error: types.Rpc_error): import("./tl/2_types.js").Rpc_error_;

package/esm/4_errors.js

@@ -2,7 +2,7 @@ import { UNREACHABLE } from "./1_utilities.js";
 import { map } from "./3_errors.js";
 import { types } from "./2_tl.js";
 export * from "./3_errors.js";
-export class FloodWait extends types.RPCError {
+export class FloodWait extends types.Rpc_error {
     constructor(params) {
         super(params);
         Object.defineProperty(this, "seconds", {
@@ -11,14 +11,14 @@ export class FloodWait extends types.RPCError {
             writable: true,
             value: void 0
         });
-        const p = params.errorMessage.split("_");
+        const p = params.error_message.split("_");
         this.seconds = Number(p[p.length - 1]);
         if (isNaN(this.seconds)) {
             UNREACHABLE();
         }
     }
 }
-export class Migrate extends types.RPCError {
+export class Migrate extends types.Rpc_error {
     constructor(params) {
         super(params);
         Object.defineProperty(this, "dc", {
@@ -27,7 +27,7 @@ export class Migrate extends types.RPCError {
             writable: true,
             value: void 0
         });
-        const p = params.errorMessage.split("_");
+        const p = params.error_message.split("_");
         this.dc = Number(p[p.length - 1]);
         if (isNaN(this.dc)) {
             UNREACHABLE();
@@ -51,12 +51,12 @@ const prefixMap = {
 };
 export function upgradeInstance(error) {
     for (const [k, v] of Object.entries(prefixMap)) {
-        if (error.errorMessage.startsWith(k)) {
+        if (error.error_message.startsWith(k)) {
             return new v(error);
         }
     }
     for (const [k, v] of Object.entries(map)) {
-        if (error.errorMessage == k) {
+        if (error.error_message == k) {
             return new v(error);
         }
     }

package/esm/_dnt.shims.js

@@ -10,7 +10,6 @@ const dntGlobals = {
     WebSocket,
 };
 export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-// deno-lint-ignore ban-types
 function createMergeProxy(baseObj, extObj) {
     return new Proxy(baseObj, {
         get(_target, prop, _receiver) {

package/esm/client/0_password.d.ts

@@ -1,5 +1,5 @@
 import { sha256 } from "../1_utilities.js";
-import { types } from "../2_tl.js";
+import { enums } from "../2_tl.js";
 export declare function isSafePrime(primeBytes: Uint8Array, g: number): boolean;
 export declare const h: typeof sha256;
 export declare const sh: (data: Uint8Array, salt: Uint8Array) => Promise<Uint8Array>;
@@ -8,4 +8,4 @@ export declare function pbkdf2(password: Uint8Array, salt: Uint8Array, iteration
 export declare const ph2: (password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array) => Promise<Uint8Array>;
 export declare function isGoodModExpFirst(modexp: bigint, prime: bigint): boolean;
 export declare function pad(bigint: number | bigint | Uint8Array): Uint8Array;
-export declare function checkPassword(password_: string, ap: types.AccountPassword): Promise<types.InputCheckPasswordSRP>;
+export declare function checkPassword(password_: string, ap: enums.account.Password): Promise<import("../tl/2_types.js").InputCheckPasswordSRP_>;

package/esm/client/0_password.js

@@ -69,7 +69,7 @@ export function pad(bigint) {
 }
 export async function checkPassword(password_, ap) {
     const password = new TextEncoder().encode(password_);
-    const algo = ap.currentAlgo;
+    const algo = ap.current_algo;
     if (!(algo instanceof
         types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow)) {
         throw new Error("Unexpected algorithm");
@@ -81,8 +81,8 @@ export async function checkPassword(password_, ap) {
     if (!isSafePrime(algo.p, g)) {
         throw new Error("Got unsafe prime");
     }
-    const srpB = ap.srpB;
-    const srpId = ap.srpId;
+    const srpB = ap.srp_B;
+    const srpId = ap.srp_id;
     {
         if (!srpB) {
             throw new Error("srbB is not set");
@@ -132,7 +132,7 @@ export async function checkPassword(password_, ap) {
     const hG = await h(pad(g));
     const m1 = await h(concat((await h(pad(p))).map((v, i) => v ^ hG[i]), await h(salt1), await h(salt2), pad(gA), pad(gB), kA));
     return new types.InputCheckPasswordSRP({
-        srpId: srpId,
+        srp_id: srpId,
         A: pad(gA),
         M1: m1,
     });

package/esm/client/0_utilities.d.ts

@@ -1,8 +1,8 @@
-import { types } from "../2_tl.js";
+import { enums, types } from "../2_tl.js";
 export declare const resolve: () => Promise<void>;
 export type With<T, K extends keyof T> = T & Required<Pick<T, K>>;
-export declare function isPtsUpdate(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateShortMessage | types.UpdateShortChatMessage | types.UpdateShortSentMessage | types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
-export declare function isChannelPtsUpdate(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateNewChannelMessage | types.UpdateEditChannelMessage | types.UpdateDeleteChannelMessages;
+export declare function isPtsUpdate(v: enums.Update | enums.Updates): v is types.UpdateShortMessage | types.UpdateShortChatMessage | types.UpdateShortSentMessage | types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
+export declare function isChannelPtsUpdate(v: enums.Update | enums.Updates): v is types.UpdateNewChannelMessage | types.UpdateEditChannelMessage | types.UpdateDeleteChannelMessages;
 /**
  * Source to a file. Can be a file ID, file path, URL, or `Uint8Array`.
  */

package/esm/client/0_utilities.js

@@ -2,7 +2,6 @@ import * as dntShim from "../_dnt.shims.js";
 import { path } from "../0_deps.js";
 import { UNREACHABLE } from "../1_utilities.js";
 import { types } from "../2_tl.js";
-import { Username } from "../tl/2_types.js";
 export const resolve = () => Promise.resolve();
 export function isPtsUpdate(v) {
     return v instanceof types.UpdateShortMessage ||
@@ -100,7 +99,7 @@ function validateUsername(string, ignoreAt = false) {
             throw errInvalidUsername(string);
         }
     }
-    if (string[Username.length - 1] == "_") {
+    if (string[string.length - 1] == "_") {
         throw errInvalidUsername(string);
     }
     for (let i = 1; i < string.length; ++i) {

package/esm/client/2_client_plain.js

@@ -48,7 +48,7 @@ export class ClientPlain extends ClientAbstract {
         for (let i = 0; i < 10; i++) {
             try {
                 d("req_pq_multi [%d]", i + 1);
-                resPq = await this.invoke(new functions.ReqPQMulti({ nonce }));
+                resPq = await this.invoke(new functions.req_pq_multi({ nonce }));
                 assertInstanceOf(resPq, types.ResPQ);
                 assertEquals(resPq.nonce, nonce);
                 d("got res_pq");
@@ -70,7 +70,7 @@ export class ClientPlain extends ClientAbstract {
         const q = bufferFromBigInt(q_, 4, false, false);
         let publicKeyFingerprint;
         let publicKey;
-        for (const fingerprint of resPq.serverPublicKeyFingerprints) {
+        for (const fingerprint of resPq.server_public_key_fingerprints) {
             const maybePublicKey = __classPrivateFieldGet(this, _ClientPlain_publicKeys, "f").find(([k]) => (k == fingerprint));
             if (maybePublicKey) {
                 publicKeyFingerprint = fingerprint;
@@ -83,52 +83,52 @@ export class ClientPlain extends ClientAbstract {
         }
         const dc = this.dcId;
         const pq = resPq.pq;
-        const serverNonce = resPq.serverNonce;
+        const serverNonce = resPq.server_nonce;
         const newNonce = getRandomBigInt(32, false, true);
-        let encryptedData = await rsaPad(new types.PQInnerDataDC({
+        let encryptedData = await rsaPad(new types.P_q_inner_data_dc({
             pq,
             p,
             q,
             dc,
-            newNonce,
+            new_nonce: newNonce,
             nonce,
-            serverNonce,
+            server_nonce: serverNonce,
         })[serialize](), publicKey);
-        const dhParams = await this.invoke(new functions.ReqDHParams({
+        const dhParams = await this.invoke(new functions.req_DH_params({
             nonce,
-            serverNonce,
+            server_nonce: serverNonce,
             p,
             q,
-            publicKeyFingerprint,
-            encryptedData,
+            public_key_fingerprint: publicKeyFingerprint,
+            encrypted_data: encryptedData,
         }));
-        assertInstanceOf(dhParams, types.ServerDHParamsOK);
+        assertInstanceOf(dhParams, types.Server_DH_params_ok);
         d("got server_DH_params_ok");
         const newNonce_ = bufferFromBigInt(newNonce, 32, true, true);
         const serverNonce_ = bufferFromBigInt(serverNonce, 16, true, true);
         const tmpAesKey = concat(await sha1(concat(newNonce_, serverNonce_)), (await sha1(concat(serverNonce_, newNonce_))).slice(0, 0 + 12));
         const tmpAesIv = concat((await sha1(concat(serverNonce_, newNonce_))).slice(12, 12 + 8), await sha1(concat(newNonce_, newNonce_)), newNonce_.slice(0, 0 + 4));
-        const answerWithHash = ige256Decrypt(dhParams.encryptedAnswer, tmpAesKey, tmpAesIv);
+        const answerWithHash = ige256Decrypt(dhParams.encrypted_answer, tmpAesKey, tmpAesIv);
         const dhInnerData = new TLReader(answerWithHash.slice(20)).readObject();
-        assertInstanceOf(dhInnerData, types.ServerDHInnerData);
-        const { g, gA: gA_, dhPrime: dhPrime_ } = dhInnerData;
+        assertInstanceOf(dhInnerData, types.Server_DH_inner_data);
+        const { g, g_a: gA_, dh_prime: dhPrime_ } = dhInnerData;
         const gA = bigIntFromBuffer(gA_, false, false);
         const dhPrime = bigIntFromBuffer(dhPrime_, false, false);
         const b = getRandomBigInt(256, false, false);
         const gB = modExp(BigInt(g), b, dhPrime);
-        const data = new types.ClientDHInnerData({
+        const data = new types.Client_DH_inner_data({
             nonce,
-            serverNonce,
-            retryId: 0n,
-            gB: bufferFromBigInt(gB, 256, false, false),
+            server_nonce: serverNonce,
+            retry_id: 0n,
+            g_b: bufferFromBigInt(gB, 256, false, false),
         })[serialize]();
         let dataWithHash = concat(await sha1(data), data);
         while (dataWithHash.length % 16 != 0) {
             dataWithHash = concat(dataWithHash, new Uint8Array(1));
         }
         encryptedData = ige256Encrypt(dataWithHash, tmpAesKey, tmpAesIv);
-        const dhGenOk = await this.invoke(new functions.SetClientDHParams({ nonce, serverNonce, encryptedData }));
-        assertInstanceOf(dhGenOk, types.DHGenOK);
+        const dhGenOk = await this.invoke(new functions.set_client_DH_params({ nonce, server_nonce: serverNonce, encrypted_data: encryptedData }));
+        assertInstanceOf(dhGenOk, types.Dh_gen_ok);
         d("got dh_gen_ok");
         const serverNonceSlice = serverNonce_.slice(0, 8);
         const salt = newNonce_.slice(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);

package/esm/client/5_client.d.ts

@@ -12,6 +12,19 @@ declare const getEntity: unique symbol;
 declare const getStickerSetName: unique symbol;
 export declare const handleMigrationError: unique symbol;
 declare const getMessageWithReply: unique symbol;
+type Functions = typeof functions;
+type Keys = keyof Functions;
+type AnyFunc = (...args: any) => any;
+type Promisify<T extends AnyFunc> = (...args: Parameters<T>) => Promise<ReturnType<T>>;
+export type Api = {
+    [K in Keys]: Functions[K] extends {
+        __F: AnyFunc;
+    } ? Promisify<Functions[K]["__F"]> : {
+        [K_ in keyof Functions[K]]: Functions[K][K_] extends {
+            __F: AnyFunc;
+        } ? Promisify<Functions[K][K_]["__F"]> : Functions[K][K_];
+    };
+};
 export interface Context extends Update {
     /** The client that received the update. */
     client: Client;
@@ -82,6 +95,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
      */
     constructor(storage: Storage | null, apiId?: number | null, apiHash?: string | null, params?: ClientParams);
+    api: Api;
     protected stateChangeHandler: (connected: boolean) => void;
     /**
      * Sets the DC and resets the auth key stored in the session provider
@@ -115,11 +129,11 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * [1]: https://core.telegram.org/method/initConnection
      * [2]: https://core.telegram.org/method/updates.getState
      */
-    authorize(params?: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
+    authorize(params?: string | types.auth.ExportedAuthorization | AuthorizeUserParams): Promise<void>;
     /**
      * Same as calling `.connect()` followed by `.authorize(params)` if the session didn't have an auth key.
      */
-    start(params?: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
+    start(params?: string | types.auth.ExportedAuthorization | AuthorizeUserParams): Promise<void>;
     /**
      * Invokes a function waiting and returning its reply if the second parameter is not `true`. Requires the client
      * to be connected.
@@ -127,8 +141,8 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * @param function_ The function to invoke.
      */
     invoke: {
-        <T extends types.Type | functions.Function<unknown> = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
-        <T_1 extends types.Type | functions.Function<unknown> = functions.Function<unknown>>(function_: T_1, noWait: true): Promise<void>;
+        <T extends import("../tl/2_types.js").Type_ | functions.Function<unknown> = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+        <T_1 extends import("../tl/2_types.js").Type_ | functions.Function<unknown> = functions.Function<unknown>>(function_: T_1, noWait: true): Promise<void>;
     } & {
         use: (handler: InvokeErrorHandler<Client<C>>) => void;
     };
@@ -138,7 +152,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
     checkGap(pts: number, ptsCount: number): Promise<void>;
     getUserAccessHash(userId: bigint): Promise<bigint>;
-    getInputPeer(id: ChatID): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
+    getInputPeer(id: ChatID): Promise<import("../tl/2_types.js").InputPeerChat_ | import("../tl/2_types.js").InputPeerUser_ | import("../tl/2_types.js").InputPeerChannel_>;
     private [getEntity];
     private [getEntity];
     private [getEntity];
@@ -261,7 +275,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * @method
      * @param contents The contents of the file.
      */
-    upload(contents: Uint8Array, params?: UploadParams): Promise<types.InputFile | types.InputFileBig>;
+    upload(contents: Uint8Array, params?: UploadParams): Promise<import("../tl/2_types.js").InputFile_ | import("../tl/2_types.js").InputFileBig_>;
     /**
      * Set the bot's commands in the given scope and/or language. Bot-only.
      *