@armatofik/tgsnake-core 1.0.0

package/lib/src/raw/core/BytesIO.d.ts

@@ -0,0 +1,33 @@
+import { Buffer } from '../../platform.node.js';
+export declare class BytesIO {
+    private _buffer;
+    private _post;
+    constructor(buffer?: Buffer);
+    seek(offset: number, whence?: number): number;
+    slice(...args: Array<any>): BytesIO;
+    toJSON(): {
+        type: "Buffer";
+        data: number[];
+    };
+    toString(...args: Array<any>): string;
+    read(length?: number): Buffer;
+    readInt32LE(size?: number): number;
+    readInt32BE(size?: number): number;
+    readUInt32LE(size?: number): number;
+    readUInt32BE(size?: number): number;
+    readBigInt64LE(size?: number): bigint;
+    readBigInt64BE(size?: number): bigint;
+    readBigUInt64LE(size?: number): bigint;
+    readBigUInt64BE(size?: number): bigint;
+    readDoubleLE(size?: number): number;
+    readDoubleBE(size?: number): number;
+    readFloatLE(size?: number): number;
+    readFloatBE(size?: number): number;
+    write(data: Buffer): BytesIO;
+    static alloc(size: number): BytesIO;
+    static from(input: any, encode?: any): BytesIO;
+    static concat(data: Array<Buffer>): BytesIO;
+    get length(): number;
+    get buffer(): Buffer;
+    get post(): number;
+}

package/lib/src/raw/core/BytesIO.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytesIO = void 0;
+const platform_node_js_1 = require("../../platform.node.js");
+class BytesIO {
+    _buffer;
+    _post;
+    constructor(buffer = platform_node_js_1.Buffer.alloc(0)) {
+        this._post = 0;
+        this._buffer = buffer;
+        return this;
+    }
+    seek(offset, whence = 0) {
+        if (whence === 0) {
+            if (offset < 0) {
+                throw new Error(`offset of BytesIO.seek must be zero or positive value when whence is 0`);
+            }
+            this._post = whence;
+        }
+        else if (whence === 1) {
+            this._post += offset;
+        }
+        else if (whence === 2) {
+            if (offset >= 0) {
+                throw new Error(`offset of BytesIO.seek must be less than zero or negative value when whence is 2`);
+            }
+            if (platform_node_js_1.Buffer.byteLength(this._buffer) + offset < 0) {
+                throw new Error(`offset out of range, offset ${offset} is less than the available buffer length.`);
+            }
+            this._post = platform_node_js_1.Buffer.byteLength(this._buffer) + offset;
+        }
+        else {
+            throw new Error(`whence must be 0 or 1 or 2, but receive ${whence}`);
+        }
+        return this._post;
+    }
+    slice(...args) {
+        return new BytesIO(this._buffer.subarray(...args));
+    }
+    toJSON() {
+        return this._buffer.toJSON();
+    }
+    toString(...args) {
+        return this._buffer.toString(...args);
+    }
+    read(length) {
+        if (length === undefined) {
+            const results = this._buffer.subarray(this._post);
+            this.seek(platform_node_js_1.Buffer.byteLength(results), 1);
+            return results;
+        }
+        if (length >= 1 && this._post <= platform_node_js_1.Buffer.byteLength(this._buffer)) {
+            const results = this._buffer.subarray(this._post, this._post + length);
+            this.seek(length, 1);
+            return results;
+        }
+        return platform_node_js_1.Buffer.alloc(0);
+    }
+    readInt32LE(size = 4) {
+        const results = this._buffer.readInt32LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readInt32BE(size = 4) {
+        const results = this._buffer.readInt32BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readUInt32LE(size = 4) {
+        const results = this._buffer.readUInt32LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readUInt32BE(size = 4) {
+        const results = this._buffer.readInt32BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigInt64LE(size = 8) {
+        const results = this._buffer.readBigInt64LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigInt64BE(size = 8) {
+        const results = this._buffer.readBigInt64BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigUInt64LE(size = 8) {
+        const results = this._buffer.readBigUInt64LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigUInt64BE(size = 8) {
+        const results = this._buffer.readBigUInt64BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readDoubleLE(size = 8) {
+        const results = this._buffer.readDoubleLE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readDoubleBE(size = 8) {
+        const results = this._buffer.readDoubleBE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readFloatLE(size = 4) {
+        const results = this._buffer.readFloatLE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readFloatBE(size = 4) {
+        const results = this._buffer.readFloatBE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    write(data) {
+        this._buffer = platform_node_js_1.Buffer.concat([
+            this._buffer,
+            data,
+        ]);
+        return this;
+    }
+    static alloc(size) {
+        return new BytesIO(platform_node_js_1.Buffer.alloc(size));
+    }
+    static from(input, encode) {
+        return new BytesIO(platform_node_js_1.Buffer.from(input, encode));
+    }
+    static concat(data) {
+        return new BytesIO(platform_node_js_1.Buffer.concat(data));
+    }
+    get length() {
+        return platform_node_js_1.Buffer.byteLength(this._buffer);
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    get post() {
+        return this._post;
+    }
+}
+exports.BytesIO = BytesIO;

package/lib/src/raw/core/GzipPacked.d.ts

@@ -0,0 +1,10 @@
+import { BytesIO } from './BytesIO.js';
+import { TLObject } from './TLObject.js';
+import { Buffer } from '../../platform.node.js';
+export declare class GzipPacked extends TLObject {
+    static ID: number;
+    packedData: TLObject;
+    constructor(packedData: TLObject);
+    static read(data: BytesIO, ..._args: Array<any>): Promise<GzipPacked>;
+    write(): Buffer;
+}

package/lib/src/raw/core/GzipPacked.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GzipPacked = void 0;
+const BytesIO_js_1 = require("./BytesIO.js");
+const TLObject_js_1 = require("./TLObject.js");
+const Primitive = __importStar(require("./primitive/index.js"));
+const platform_node_js_1 = require("../../platform.node.js");
+class GzipPacked extends TLObject_js_1.TLObject {
+    static ID = 0x3072cfa1;
+    packedData;
+    constructor(packedData) {
+        super();
+        this.className = 'GzipPacked';
+        this._slots = ['packedData'];
+        this.packedData = packedData;
+    }
+    static async read(data, ..._args) {
+        return (await TLObject_js_1.TLObject.read(new BytesIO_js_1.BytesIO((0, platform_node_js_1.gunzipSync)(await Primitive.Bytes.read(data)))));
+    }
+    write() {
+        const bytes = new BytesIO_js_1.BytesIO();
+        bytes.write(Primitive.Int.write(GzipPacked.ID, false));
+        bytes.write(Primitive.Bytes.write((0, platform_node_js_1.gzipSync)(this.packedData.write())));
+        return platform_node_js_1.Buffer.from(bytes.buffer);
+    }
+}
+exports.GzipPacked = GzipPacked;

package/lib/src/raw/core/Message.d.ts

@@ -0,0 +1,13 @@
+import { BytesIO } from './BytesIO.js';
+import { TLObject } from './TLObject.js';
+import { Buffer } from '../../platform.node.js';
+export declare class Message extends TLObject {
+    static ID: number;
+    msgId: bigint;
+    seqNo: number;
+    length: number;
+    body: TLObject;
+    constructor(body: TLObject, msgId: bigint, seqNo: number, length: number);
+    static read(data: BytesIO, ..._args: Array<any>): Promise<Message>;
+    write(): Buffer;
+}

package/lib/src/raw/core/Message.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const BytesIO_js_1 = require("./BytesIO.js");
+const TLObject_js_1 = require("./TLObject.js");
+const Primitive = __importStar(require("./primitive/index.js"));
+const platform_node_js_1 = require("../../platform.node.js");
+function toBytes(value) {
+    const bytesArray = [];
+    for (let i = 0; i < 8; i++) {
+        let shift = value >> BigInt(8 * i);
+        shift &= BigInt(255);
+        bytesArray[i] = Number(String(shift));
+    }
+    return platform_node_js_1.Buffer.from(bytesArray);
+}
+class Message extends TLObject_js_1.TLObject {
+    static ID = 0x5bb8e511;
+    msgId;
+    seqNo;
+    length;
+    body;
+    constructor(body, msgId, seqNo, length) {
+        super();
+        this.className = 'Message';
+        this._slots = ['body', 'msgId', 'seqNo', 'length'];
+        this.msgId = msgId;
+        this.seqNo = seqNo;
+        this.length = length;
+        this.body = body;
+    }
+    static async read(data, ..._args) {
+        const msgId = await Primitive.Long.read(data);
+        const seqNo = await Primitive.Int.read(data);
+        const length = await Primitive.Int.read(data);
+        const body = data.read(length);
+        return new Message(await TLObject_js_1.TLObject.read(new BytesIO_js_1.BytesIO(body)), msgId, seqNo, length);
+    }
+    write() {
+        const bytes = new BytesIO_js_1.BytesIO();
+        bytes.write(toBytes(this.msgId));
+        bytes.write(Primitive.Int.write(this.seqNo));
+        bytes.write(Primitive.Int.write(this.length));
+        bytes.write(this.body.write());
+        return platform_node_js_1.Buffer.from(bytes.buffer);
+    }
+}
+exports.Message = Message;

package/lib/src/raw/core/MsgContainer.d.ts

@@ -0,0 +1,11 @@
+import { BytesIO } from './BytesIO.js';
+import { TLObject } from './TLObject.js';
+import { Message } from './Message.js';
+import { Buffer } from '../../platform.node.js';
+export declare class MsgContainer extends TLObject {
+    static ID: number;
+    messages: Array<Message>;
+    constructor(messages: Array<Message>);
+    static read(data: BytesIO, ..._args: Array<any>): Promise<MsgContainer>;
+    write(): Buffer;
+}

package/lib/src/raw/core/MsgContainer.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgContainer = void 0;
+const BytesIO_js_1 = require("./BytesIO.js");
+const TLObject_js_1 = require("./TLObject.js");
+const Primitive = __importStar(require("./primitive/index.js"));
+const Message_js_1 = require("./Message.js");
+const platform_node_js_1 = require("../../platform.node.js");
+class MsgContainer extends TLObject_js_1.TLObject {
+    static ID = 0x73f1f8dc;
+    messages;
+    constructor(messages) {
+        super();
+        this._slots = ['messages'];
+        this.className = 'MsgContainer';
+        this.messages = messages;
+    }
+    static async read(data, ..._args) {
+        const count = await Primitive.Int.read(data);
+        const messages = [];
+        for (let i = 0; i < count; i++) {
+            messages.push(await Message_js_1.Message.read(data));
+        }
+        return new MsgContainer(messages);
+    }
+    write() {
+        const bytes = new BytesIO_js_1.BytesIO();
+        bytes.write(Primitive.Int.write(MsgContainer.ID, false));
+        bytes.write(Primitive.Int.write(this.messages.length));
+        for (const message of this.messages) {
+            bytes.write(message.write());
+        }
+        return platform_node_js_1.Buffer.from(bytes.buffer);
+    }
+}
+exports.MsgContainer = MsgContainer;

package/lib/src/raw/core/TLObject.d.ts

@@ -0,0 +1,19 @@
+import { BytesIO } from './BytesIO.js';
+import { Buffer } from '../../platform.node.js';
+export declare class TLObject {
+    _slots: Array<string>;
+    cls: any;
+    constructorId: number;
+    subclassOfId: number;
+    className: string;
+    classType: string;
+    constructor();
+    static read(data: BytesIO, ...args: Array<any>): Promise<any>;
+    static write(..._args: Array<any>): Buffer;
+    read(data: BytesIO, ...args: Array<any>): Promise<any>;
+    write(...args: Array<any>): Buffer;
+    toJSON(): {
+        [key: string]: any;
+    };
+    toString(): string;
+}

package/lib/src/raw/core/TLObject.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLObject = void 0;
+const All_js_1 = require("../All.js");
+const Logger_js_1 = require("../../Logger.js");
+const platform_node_js_1 = require("../../platform.node.js");
+const index_js_1 = require("../index.js");
+function getModule(name) {
+    if (!name) {
+        throw new Error("name of module can't be undefined");
+    }
+    if (name === 'Message') {
+        return index_js_1.Message;
+    }
+    else if (name === 'GzipPacked') {
+        return index_js_1.GzipPacked;
+    }
+    else if (name === 'MsgContainer') {
+        return index_js_1.MsgContainer;
+    }
+    else if (name.startsWith('Primitive')) {
+        return index_js_1.Primitive[name.split('.')[1]];
+    }
+    else {
+        const split = name.split('.');
+        if (split.length == 3) {
+            return index_js_1.Raw[split[1]][split[2]];
+        }
+        return index_js_1.Raw[split[1]];
+    }
+}
+class TLObject {
+    _slots;
+    cls = this.constructor;
+    constructorId;
+    subclassOfId;
+    className;
+    classType;
+    constructor() {
+        this._slots = [];
+        this.constructorId = this.cls.ID ?? 0;
+        this.className = 'TLObject';
+    }
+    static async read(data, ...args) {
+        const id = data.readUInt32LE(4);
+        Logger_js_1.Logger.debug(`[10] Reading TLObject with id: ${id.toString(16)} (${All_js_1.AllTLObject[id]})`);
+        const _class = getModule(All_js_1.AllTLObject[id]);
+        return await _class.read(data, ...args);
+    }
+    static write(..._args) {
+        return platform_node_js_1.Buffer.alloc(0);
+    }
+    read(data, ...args) {
+        return this.cls.read(data, ...args);
+    }
+    write(...args) {
+        return this.cls.write(...args);
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const toPrint = {
+            _: this.className,
+        };
+        const ignore = ['slots', 'className', 'constructorId', 'subclassOfId', 'classType', 'cls'];
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (ignore.includes(key))
+                    continue;
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    [Symbol.for('Deno.customInspect')]() {
+        return String((0, platform_node_js_1.inspect)(this[Symbol.for('nodejs.util.inspect.custom')](), { colors: true }));
+    }
+    toJSON() {
+        const toPrint = {
+            _: this.className,
+        };
+        const ignore = ['slots', 'className', 'constructorId', 'subclassOfId', 'classType', 'cls'];
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (ignore.includes(key))
+                    continue;
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    if (typeof value === 'bigint') {
+                        toPrint[key] = String(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        toPrint[key] = value.map((v) => (typeof v === 'bigint' ? String(v) : v));
+                    }
+                    else {
+                        toPrint[key] = value;
+                    }
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.className}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.TLObject = TLObject;

package/lib/src/raw/core/UpdateSecretChat.d.ts

@@ -0,0 +1,40 @@
+import { Raw } from '../Raw.js';
+import type { SecretChat } from '../../session/secretChats/SecretChat.js';
+import { TLObject } from './TLObject.js';
+export declare class UpdateSecretChatMessage extends TLObject {
+    message: SecretChatMessage | SecretChatMessageService;
+    qts: number;
+    _original: Raw.UpdateNewEncryptedMessage;
+    constructor(params: {
+        message: SecretChatMessage | SecretChatMessageService;
+        qts: number;
+        original: Raw.UpdateNewEncryptedMessage;
+    });
+    static generate(update: Raw.UpdateNewEncryptedMessage, secretChat: SecretChat): Promise<UpdateSecretChatMessage>;
+}
+export declare class SecretChatMessage extends TLObject {
+    randomId: bigint;
+    chatId: number;
+    date: number;
+    message: Raw.DecryptedMessage8 | Raw.DecryptedMessage17 | Raw.DecryptedMessage45 | Raw.DecryptedMessage73;
+    file: Raw.TypeEncryptedFile;
+    constructor(params: {
+        randomId: bigint;
+        chatId: number;
+        date: number;
+        message: Raw.DecryptedMessage8 | Raw.DecryptedMessage17 | Raw.DecryptedMessage45 | Raw.DecryptedMessage73;
+        file: Raw.TypeEncryptedFile;
+    });
+}
+export declare class SecretChatMessageService extends TLObject {
+    randomId: bigint;
+    chatId: number;
+    date: number;
+    message: Raw.DecryptedMessageService8 | Raw.DecryptedMessageService17;
+    constructor(params: {
+        randomId: bigint;
+        chatId: number;
+        date: number;
+        message: Raw.DecryptedMessageService8 | Raw.DecryptedMessageService17;
+    });
+}

package/lib/src/raw/core/UpdateSecretChat.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretChatMessageService = exports.SecretChatMessage = exports.UpdateSecretChatMessage = void 0;
+const Raw_js_1 = require("../Raw.js");
+const TLObject_js_1 = require("./TLObject.js");
+class UpdateSecretChatMessage extends TLObject_js_1.TLObject {
+    message;
+    qts;
+    _original;
+    constructor(params) {
+        super();
+        this.classType = 'modified_types_UpdateNewEncryptedMessage';
+        this.className = 'UpdateSecretChatMessage';
+        this.constructorId = 1;
+        this.subclassOfId = 0x9f89304e;
+        this._slots = ['message', 'qts'];
+        this.message = params.message;
+        this.qts = params.qts;
+        this._original = params.original;
+    }
+    static async generate(update, secretChat) {
+        const decrypted = await secretChat.decrypt(update.message);
+        if (update.message instanceof Raw_js_1.Raw.EncryptedMessageService) {
+            return new UpdateSecretChatMessage({
+                message: new SecretChatMessageService({
+                    randomId: update.message.randomId,
+                    chatId: update.message.chatId,
+                    date: update.message.date,
+                    message: decrypted,
+                }),
+                qts: update.qts,
+                original: update,
+            });
+        }
+        return new UpdateSecretChatMessage({
+            message: new SecretChatMessage({
+                randomId: update.message.randomId,
+                chatId: update.message.chatId,
+                date: update.message.date,
+                file: update.message.file,
+                message: decrypted,
+            }),
+            qts: update.qts,
+            original: update,
+        });
+    }
+}
+exports.UpdateSecretChatMessage = UpdateSecretChatMessage;
+class SecretChatMessage extends TLObject_js_1.TLObject {
+    randomId;
+    chatId;
+    date;
+    message;
+    file;
+    constructor(params) {
+        super();
+        this.classType = 'modified_types_EncryptedMessage';
+        this.className = 'SecretChatMessage';
+        this.constructorId = 2;
+        this.subclassOfId = 0x239f2e51;
+        this._slots = ['randomId', 'chatId', 'date', 'message', 'file'];
+        this.randomId = params.randomId;
+        this.chatId = params.chatId;
+        this.date = params.date;
+        this.message = params.message;
+        this.file = params.file;
+    }
+}
+exports.SecretChatMessage = SecretChatMessage;
+class SecretChatMessageService extends TLObject_js_1.TLObject {
+    randomId;
+    chatId;
+    date;
+    message;
+    constructor(params) {
+        super();
+        this.classType = 'modified_types_EncryptedMessageService';
+        this.className = 'SecretChatMessageService';
+        this.constructorId = 3;
+        this.subclassOfId = 0x239f2e51;
+        this._slots = ['randomId', 'chatId', 'date', 'message'];
+        this.randomId = params.randomId;
+        this.chatId = params.chatId;
+        this.date = params.date;
+        this.message = params.message;
+    }
+}
+exports.SecretChatMessageService = SecretChatMessageService;