@tgsnake/skema 1.13.0 → 2.0.0-browser.0

package/dist/src/raw/UpdateSecretChat.d.ts

@@ -0,0 +1,186 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { Raw } from './Raw.js';
+import { TLObject } from './core/TLObject.js';
+/**
+ * Interface representing an E2E decryption generator context.
+ *
+ * @remarks
+ * Any secret chat management instance passed into `UpdateSecretChatMessage.generate` must implement
+ * this interface to decrypt incoming encrypted raw Telegram message updates.
+ *
+ * @interface TypeTGenerate
+ */
+export interface TypeTGenerate {
+    /**
+     * Decrypts a raw encrypted secret chat message.
+     *
+     * @param message - The raw encrypted message object received from Telegram.
+     * @returns A promise resolving to the decrypted raw message structure.
+     */
+    decrypt: (message: Raw.TypeEncryptedMessage) => Promise<Raw.TypeDecryptedMessage>;
+}
+/**
+ * Represents a decrypted secret chat message update wrapper.
+ *
+ * @remarks
+ * This modified update structure wraps raw incoming Telegram encrypted updates (`UpdateNewEncryptedMessage`)
+ * and replaces the encrypted message payload with its fully-decrypted message or service structure.
+ * This simplifies message handling by eliminating manual decrypt stages.
+ *
+ * @extends TLObject
+ */
+export declare class UpdateSecretChatMessage extends TLObject {
+    /**
+     * The decrypted message or service message payload.
+     */
+    message: SecretChatMessage | SecretChatMessageService;
+    /**
+     * The queue timestamp (QTS) parameter indicating the sequence order of the update.
+     */
+    qts: number;
+    /**
+     * The original raw Telegram encrypted update instance.
+     *
+     * @internal
+     */
+    _original: Raw.UpdateNewEncryptedMessage;
+    /**
+     * Constructs a new UpdateSecretChatMessage wrapper.
+     *
+     * @param params - Initial parameter values.
+     */
+    constructor(params: {
+        message: SecretChatMessage | SecretChatMessageService;
+        qts: number;
+        original: Raw.UpdateNewEncryptedMessage;
+    });
+    /**
+     * Decrypts a raw encrypted update and generates a fully decrypted `UpdateSecretChatMessage` wrapper.
+     *
+     * @remarks
+     * This static factory determines whether the encrypted message is a standard user message or
+     * a service message (e.g. key exchange requests), calls `secretChat.decrypt()` to decrypt the body,
+     * constructs the appropriate wrapper class (`SecretChatMessage` or `SecretChatMessageService`),
+     * and returns the finalized update object.
+     *
+     * @typeParam T - The secret chat context class implementing {@link TypeTGenerate}.
+     * @param update - The raw `UpdateNewEncryptedMessage` containing the encrypted payload.
+     * @param secretChat - The secret chat session manager used to decrypt the message bytes.
+     * @returns A promise resolving to the decrypted `UpdateSecretChatMessage` instance.
+     */
+    static generate<T>(update: Raw.UpdateNewEncryptedMessage, secretChat: T): Promise<UpdateSecretChatMessage>;
+    /**
+     * The original raw encrypted message container received from Telegram.
+     *
+     * @returns The raw original encrypted update object.
+     */
+    get original(): Raw.UpdateNewEncryptedMessage;
+}
+/**
+ * Represents a decrypted standard text or media message within a secret chat.
+ *
+ * @remarks
+ * Wraps the decrypted end-to-end encrypted payload together with its local random ID, chat context,
+ * timestamp, and optional media file attachments.
+ *
+ * @extends TLObject
+ * @example
+ * ```typescript
+ * const secretMessage = new SecretChatMessage({
+ *   randomId: 1234567890123456789n,
+ *   chatId: 42,
+ *   date: 1680000000,
+ *   message: decryptedMessageInstance,
+ *   file: encryptedFileInstance
+ * });
+ * ```
+ */
+export declare class SecretChatMessage extends TLObject {
+    /**
+     * A unique 64-bit identifier chosen by the client to prevent replay attacks.
+     */
+    randomId: bigint;
+    /**
+     * The unique secret chat identifier.
+     */
+    chatId: number;
+    /**
+     * The Unix timestamp indicating when the message was sent.
+     */
+    date: number;
+    /**
+     * The decrypted inner message payload mapping to a standard version-specific schema.
+     */
+    message: Raw.DecryptedMessage8 | Raw.DecryptedMessage17 | Raw.DecryptedMessage45 | Raw.DecryptedMessage73;
+    /**
+     * The encrypted file attachment description associated with this message, if any.
+     */
+    file: Raw.TypeEncryptedFile;
+    /**
+     * Constructs a new SecretChatMessage instance.
+     *
+     * @param params - Initial parameter values.
+     */
+    constructor(params: {
+        randomId: bigint;
+        chatId: number;
+        date: number;
+        message: Raw.DecryptedMessage8 | Raw.DecryptedMessage17 | Raw.DecryptedMessage45 | Raw.DecryptedMessage73;
+        file: Raw.TypeEncryptedFile;
+    });
+}
+/**
+ * Represents a decrypted service command message within a secret chat.
+ *
+ * @remarks
+ * Used for background negotiation signals such as typing notifications, read receipt confirmations,
+ * self-destruct changes, or encryption key exchanges.
+ *
+ * @extends TLObject
+ * @example
+ * ```typescript
+ * const serviceMessage = new SecretChatMessageService({
+ *   randomId: 1234567890123456789n,
+ *   chatId: 42,
+ *   date: 1680000000,
+ *   message: decryptedMessageService8Instance
+ * });
+ * ```
+ */
+export declare class SecretChatMessageService extends TLObject {
+    /**
+     * A unique 64-bit identifier chosen by the client to prevent replay attacks.
+     */
+    randomId: bigint;
+    /**
+     * The unique secret chat identifier.
+     */
+    chatId: number;
+    /**
+     * The Unix timestamp indicating when the message was sent.
+     */
+    date: number;
+    /**
+     * The decrypted inner service message payload.
+     */
+    message: Raw.DecryptedMessageService8 | Raw.DecryptedMessageService17;
+    /**
+     * Constructs a new SecretChatMessageService instance.
+     *
+     * @param params - Initial parameter values.
+     */
+    constructor(params: {
+        randomId: bigint;
+        chatId: number;
+        date: number;
+        message: Raw.DecryptedMessageService8 | Raw.DecryptedMessageService17;
+    });
+}

package/dist/src/raw/UpdateSecretChat.js

@@ -0,0 +1,215 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { Raw } from './Raw.js';
+import { TLObject } from './core/TLObject.js';
+/**
+ * Represents a decrypted secret chat message update wrapper.
+ *
+ * @remarks
+ * This modified update structure wraps raw incoming Telegram encrypted updates (`UpdateNewEncryptedMessage`)
+ * and replaces the encrypted message payload with its fully-decrypted message or service structure.
+ * This simplifies message handling by eliminating manual decrypt stages.
+ *
+ * @extends TLObject
+ */
+export class UpdateSecretChatMessage extends TLObject {
+    /**
+     * The decrypted message or service message payload.
+     */
+    message;
+    /**
+     * The queue timestamp (QTS) parameter indicating the sequence order of the update.
+     */
+    qts;
+    /**
+     * The original raw Telegram encrypted update instance.
+     *
+     * @internal
+     */
+    _original;
+    /**
+     * Constructs a new UpdateSecretChatMessage wrapper.
+     *
+     * @param params - Initial parameter values.
+     */
+    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;
+    }
+    /**
+     * Decrypts a raw encrypted update and generates a fully decrypted `UpdateSecretChatMessage` wrapper.
+     *
+     * @remarks
+     * This static factory determines whether the encrypted message is a standard user message or
+     * a service message (e.g. key exchange requests), calls `secretChat.decrypt()` to decrypt the body,
+     * constructs the appropriate wrapper class (`SecretChatMessage` or `SecretChatMessageService`),
+     * and returns the finalized update object.
+     *
+     * @typeParam T - The secret chat context class implementing {@link TypeTGenerate}.
+     * @param update - The raw `UpdateNewEncryptedMessage` containing the encrypted payload.
+     * @param secretChat - The secret chat session manager used to decrypt the message bytes.
+     * @returns A promise resolving to the decrypted `UpdateSecretChatMessage` instance.
+     */
+    static async generate(update, secretChat) {
+        const decrypted = await secretChat.decrypt(update.message);
+        if (update.message instanceof Raw.EncryptedMessageService) {
+            return new UpdateSecretChatMessage({
+                message: new SecretChatMessageService({
+                    randomId: update.message.randomId,
+                    chatId: update.message.chatId,
+                    date: update.message.date,
+                    // @ts-ignore: TS doesn't know that decrypted is a DecryptedMessageService
+                    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,
+                // @ts-ignore: TS doesn't know that decrypted is a DecryptedMessage
+                message: decrypted,
+            }),
+            qts: update.qts,
+            original: update,
+        });
+    }
+    /**
+     * The original raw encrypted message container received from Telegram.
+     *
+     * @returns The raw original encrypted update object.
+     */
+    get original() {
+        return this._original;
+    }
+}
+/**
+ * Represents a decrypted standard text or media message within a secret chat.
+ *
+ * @remarks
+ * Wraps the decrypted end-to-end encrypted payload together with its local random ID, chat context,
+ * timestamp, and optional media file attachments.
+ *
+ * @extends TLObject
+ * @example
+ * ```typescript
+ * const secretMessage = new SecretChatMessage({
+ *   randomId: 1234567890123456789n,
+ *   chatId: 42,
+ *   date: 1680000000,
+ *   message: decryptedMessageInstance,
+ *   file: encryptedFileInstance
+ * });
+ * ```
+ */
+export class SecretChatMessage extends TLObject {
+    /**
+     * A unique 64-bit identifier chosen by the client to prevent replay attacks.
+     */
+    randomId;
+    /**
+     * The unique secret chat identifier.
+     */
+    chatId;
+    /**
+     * The Unix timestamp indicating when the message was sent.
+     */
+    date;
+    /**
+     * The decrypted inner message payload mapping to a standard version-specific schema.
+     */
+    message;
+    /**
+     * The encrypted file attachment description associated with this message, if any.
+     */
+    file;
+    /**
+     * Constructs a new SecretChatMessage instance.
+     *
+     * @param params - Initial parameter values.
+     */
+    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;
+    }
+}
+/**
+ * Represents a decrypted service command message within a secret chat.
+ *
+ * @remarks
+ * Used for background negotiation signals such as typing notifications, read receipt confirmations,
+ * self-destruct changes, or encryption key exchanges.
+ *
+ * @extends TLObject
+ * @example
+ * ```typescript
+ * const serviceMessage = new SecretChatMessageService({
+ *   randomId: 1234567890123456789n,
+ *   chatId: 42,
+ *   date: 1680000000,
+ *   message: decryptedMessageService8Instance
+ * });
+ * ```
+ */
+export class SecretChatMessageService extends TLObject {
+    /**
+     * A unique 64-bit identifier chosen by the client to prevent replay attacks.
+     */
+    randomId;
+    /**
+     * The unique secret chat identifier.
+     */
+    chatId;
+    /**
+     * The Unix timestamp indicating when the message was sent.
+     */
+    date;
+    /**
+     * The decrypted inner service message payload.
+     */
+    message;
+    /**
+     * Constructs a new SecretChatMessageService instance.
+     *
+     * @param params - Initial parameter values.
+     */
+    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;
+    }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { BytesIO, Buffer } from '../../deps.js';
+import { TLObject } from './TLObject.js';
+/**
+ * Represents a Gzip-compressed wrapper around another serialized TLObject payload.
+ *
+ * @remarks
+ * Telegram MTProto automatically packages certain large responses or bulk payloads
+ * within a `gzip_packed` constructor to optimize bandwidth and network performance.
+ * This class handles the transparent zlib-based compression and decompression of these payloads.
+ *
+ * @extends TLObject
+ */
+export declare class GzipPacked extends TLObject {
+    /**
+     * The unique class ID identifier representing `GzipPacked` (0x3072cfa1).
+     */
+    static ID: number;
+    /**
+     * The underlying inner deserialized TLObject that was compressed.
+     */
+    packedData: TLObject;
+    /**
+     * Constructs a new GzipPacked instance.
+     *
+     * @param packedData - The inner uncompressed TLObject to package.
+     */
+    constructor(packedData: TLObject);
+    /**
+     * Reads, decompresses, and deserializes a Gzip-packed payload from a binary stream.
+     *
+     * @remarks
+     * This method:
+     * 1. Reads the length-prefixed compressed bytes from the input stream.
+     * 2. Runs native zlib gunzip (`gunzipSync`) on the compressed data.
+     * 3. Wraps the raw uncompressed bytes inside a new `BytesIO` stream.
+     * 4. Recursively parses the decompressed buffer as a valid `TLObject`.
+     *
+     * @param data - The `BytesIO` stream containing the compressed `gzip_packed` data structure.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the decompressed `GzipPacked` instance wrapping the deserialized object.
+     */
+    static read(data: BytesIO, ..._args: Array<any>): Promise<GzipPacked>;
+    /**
+     * Serializes and zlib-compresses the inner TLObject into a raw binary buffer.
+     *
+     * @remarks
+     * Serializes the payload by first writing the 32-bit `GzipPacked.ID` identifier, followed by
+     * the length-prefixed zlib-compressed buffer containing the inner TLObject's binary output.
+     *
+     * @override
+     * @returns A Buffer representing the compressed MTProto binary structure.
+     */
+    write(): Buffer;
+}

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

@@ -0,0 +1,76 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { BytesIO, gzipSync, gunzipSync, Buffer } from '../../deps.js';
+import { TLObject } from './TLObject.js';
+import * as Primitive from './primitive/index.js';
+/**
+ * Represents a Gzip-compressed wrapper around another serialized TLObject payload.
+ *
+ * @remarks
+ * Telegram MTProto automatically packages certain large responses or bulk payloads
+ * within a `gzip_packed` constructor to optimize bandwidth and network performance.
+ * This class handles the transparent zlib-based compression and decompression of these payloads.
+ *
+ * @extends TLObject
+ */
+export class GzipPacked extends TLObject {
+    /**
+     * The unique class ID identifier representing `GzipPacked` (0x3072cfa1).
+     */
+    static ID = 0x3072cfa1;
+    /**
+     * The underlying inner deserialized TLObject that was compressed.
+     */
+    packedData;
+    /**
+     * Constructs a new GzipPacked instance.
+     *
+     * @param packedData - The inner uncompressed TLObject to package.
+     */
+    constructor(packedData) {
+        super();
+        this.className = 'GzipPacked';
+        this._slots = ['packedData'];
+        this.packedData = packedData;
+    }
+    /**
+     * Reads, decompresses, and deserializes a Gzip-packed payload from a binary stream.
+     *
+     * @remarks
+     * This method:
+     * 1. Reads the length-prefixed compressed bytes from the input stream.
+     * 2. Runs native zlib gunzip (`gunzipSync`) on the compressed data.
+     * 3. Wraps the raw uncompressed bytes inside a new `BytesIO` stream.
+     * 4. Recursively parses the decompressed buffer as a valid `TLObject`.
+     *
+     * @param data - The `BytesIO` stream containing the compressed `gzip_packed` data structure.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the decompressed `GzipPacked` instance wrapping the deserialized object.
+     */
+    static async read(data, ..._args) {
+        return (await TLObject.read(new BytesIO(gunzipSync(await Primitive.Bytes.read(data)))));
+    }
+    /**
+     * Serializes and zlib-compresses the inner TLObject into a raw binary buffer.
+     *
+     * @remarks
+     * Serializes the payload by first writing the 32-bit `GzipPacked.ID` identifier, followed by
+     * the length-prefixed zlib-compressed buffer containing the inner TLObject's binary output.
+     *
+     * @override
+     * @returns A Buffer representing the compressed MTProto binary structure.
+     */
+    write() {
+        const bytes = new BytesIO();
+        bytes.write(Primitive.Int.write(GzipPacked.ID, false));
+        bytes.write(Primitive.Bytes.write(gzipSync(this.packedData.write())));
+        return Buffer.from(bytes.buffer);
+    }
+}

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

@@ -0,0 +1,68 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from './TLObject.js';
+import { BytesIO, Buffer } from '../../deps.js';
+/**
+ * Represents a standard MTProto transport container message.
+ *
+ * @remarks
+ * Every message transmitted or received over the MTProto protocol is wrapped in a `Message` envelope.
+ * The envelope includes metadata crucial for routing and ordering: the message ID (which indicates
+ * client/server time synchronization), the message sequence number, the body byte length, and the actual
+ * serialized payload/body TLObject.
+ *
+ * @extends TLObject
+ */
+export declare class Message extends TLObject {
+    /**
+     * The unique class ID identifier representing `Message` (0x5bb8e511).
+     */
+    static ID: number;
+    /**
+     * The unique 64-bit message identifier, representing the creation time of the message in seconds multiplied by 2^32.
+     */
+    msgId: bigint;
+    /**
+     * The message sequence number, indicating the order of the message in the session.
+     */
+    seqNo: number;
+    /**
+     * The length of the serialized message body in bytes.
+     */
+    length: number;
+    /**
+     * The inner body deserialized as a `TLObject`.
+     */
+    body: TLObject;
+    /**
+     * Constructs a new Message envelope.
+     *
+     * @param body - The inner body payload of the message.
+     * @param msgId - The 64-bit message identifier.
+     * @param seqNo - The session message sequence number.
+     * @param length - The byte length of the body.
+     */
+    constructor(body: TLObject, msgId: bigint, seqNo: number, length: number);
+    /**
+     * Reads and deserializes a `Message` envelope from a binary stream.
+     *
+     * @param data - The `BytesIO` stream containing the serialized message envelope.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the deserialized `Message` instance.
+     */
+    static read(data: BytesIO, ..._args: Array<any>): Promise<Message>;
+    /**
+     * Serializes the message envelope and its body into a raw binary buffer.
+     *
+     * @override
+     * @returns A Buffer representing the complete message envelope structure.
+     */
+    write(): Buffer;
+}