@mtcute/core 0.5.0 → 0.7.0

package/cjs/base-client.types.d.ts

@@ -1,153 +0,0 @@
-import { tl } from '@mtcute/tl';
-import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
-import { NetworkManagerExtraParams, ReconnectionStrategy, TransportFactory } from './network/index.js';
-import { PersistentConnectionParams } from './network/persistent-connection.js';
-import { ITelegramStorage } from './storage/abstract.js';
-import { CryptoProviderFactory } from './utils/index.js';
-/** Options for {@link BaseTelegramClient} */
-export interface BaseTelegramClientOptions {
-    /**
-     * API ID from my.telegram.org
-     */
-    apiId: number;
-    /**
-     * API hash from my.telegram.org
-     */
-    apiHash: string;
-    /**
-     * Storage to use for this client.
-     */
-    storage: ITelegramStorage;
-    /**
-     * Cryptography provider factory to allow delegating
-     * crypto to native addon, worker, etc.
-     */
-    crypto?: CryptoProviderFactory;
-    /**
-     * Whether to use IPv6 datacenters
-     * (IPv6 will be preferred when choosing a DC by id)
-     * (default: false)
-     */
-    useIpv6?: boolean;
-    /**
-     * Primary DC to use for initial connection.
-     * This does not mean this will be the only DC used,
-     * nor that this DC will actually be primary, this only
-     * determines the first DC the library will try to connect to.
-     * Can be used to connect to other networks (like test DCs).
-     *
-     * When session already contains primary DC, this parameter is ignored.
-     *
-     * @default  Production DC 2.
-     */
-    defaultDcs?: ITelegramStorage.DcOptions;
-    /**
-     * Whether to connect to test servers.
-     *
-     * If passed, {@link defaultDc} defaults to Test DC 2.
-     *
-     * **Must** be passed if using test servers, even if
-     * you passed custom {@link defaultDc}
-     */
-    testMode?: boolean;
-    /**
-     * Additional options for initConnection call.
-     * `apiId` and `query` are not available and will be ignored.
-     * Omitted values will be filled with defaults
-     */
-    initConnectionOptions?: Partial<Omit<tl.RawInitConnectionRequest, 'apiId' | 'query'>>;
-    /**
-     * Transport factory to use in the client.
-     *
-     * @default  platform-specific transport: WebSocket on the web, TCP in node
-     */
-    transport?: TransportFactory;
-    /**
-     * Reconnection strategy.
-     *
-     * @default  simple reconnection strategy: first 0ms, then up to 5s (increasing by 1s)
-     */
-    reconnectionStrategy?: ReconnectionStrategy<PersistentConnectionParams>;
-    /**
-     * Maximum duration of a flood_wait that will be waited automatically.
-     * Flood waits above this threshold will throw a FloodWaitError.
-     * Set to 0 to disable. Can be overridden with `throwFlood` parameter in call() params
-     *
-     * @default 10000
-     */
-    floodSleepThreshold?: number;
-    /**
-     * Maximum number of retries when calling RPC methods.
-     * Call is retried when InternalError or FloodWaitError is encountered.
-     * Can be set to Infinity.
-     *
-     * @default 5
-     */
-    maxRetryCount?: number;
-    /**
-     * If true, every single API call will be wrapped with `tl.invokeWithoutUpdates`,
-     * effectively disabling the server-sent events for the clients.
-     * May be useful in some cases.
-     *
-     * Note that this only wraps calls made with `.call()` within the primary
-     * connection. Additional connections and direct `.sendForResult()` calls
-     * must be wrapped manually.
-     *
-     * @default false
-     */
-    disableUpdates?: boolean;
-    /**
-     * mtcute can send all unknown RPC errors to [danog](https://github.com/danog)'s
-     * [error reporting service](https://rpc.pwrtelegram.xyz/).
-     *
-     * This is fully anonymous (except maybe IP) and is only used to improve the library
-     * and developer experience for everyone working with MTProto. This is fully opt-in,
-     * and if you're too paranoid, you can disable it by manually passing `enableErrorReporting: false` to the client.
-     *
-     * @default false
-     */
-    enableErrorReporting?: boolean;
-    /**
-     * If true, RPC errors will have a stack trace of the initial `.call()`
-     * or `.sendForResult()` call position, which drastically improves
-     * debugging experience.<br>
-     * If false, they will have a stack trace of mtcute internals.
-     *
-     * Internally this creates a stack capture before every RPC call
-     * and stores it until the result is received. This might
-     * use a lot more memory than normal, thus can be disabled here.
-     *
-     * @default true
-     */
-    niceStacks?: boolean;
-    /**
-     * Extra parameters for {@link NetworkManager}
-     */
-    network?: NetworkManagerExtraParams;
-    /**
-     * Set logging level for the client.
-     *
-     * See static members of {@link LogManager} for possible values.
-     */
-    logLevel?: number;
-    /**
-     * **EXPERT USE ONLY!**
-     *
-     * Override TL layer used for the connection.
-     *
-     * **Does not** change the schema used.
-     */
-    overrideLayer?: number;
-    /**
-     * **EXPERT USE ONLY**
-     *
-     * Override reader map used for the connection.
-     */
-    readerMap?: TlReaderMap;
-    /**
-     * **EXPERT USE ONLY**
-     *
-     * Override writer map used for the connection.
-     */
-    writerMap?: TlWriterMap;
-}

package/cjs/base-client.types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=base-client.types.js.map

package/cjs/base-client.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-client.types.js","sourceRoot":"","sources":["../../src/base-client.types.ts"],"names":[],"mappings":"","sourcesContent":["import { tl } from '@mtcute/tl'\nimport { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime'\n\nimport { NetworkManagerExtraParams, ReconnectionStrategy, TransportFactory } from './network/index.js'\nimport { PersistentConnectionParams } from './network/persistent-connection.js'\nimport { ITelegramStorage } from './storage/abstract.js'\nimport { CryptoProviderFactory } from './utils/index.js'\n\n/** Options for {@link BaseTelegramClient} */\nexport interface BaseTelegramClientOptions {\n    /**\n     * API ID from my.telegram.org\n     */\n    apiId: number\n    /**\n     * API hash from my.telegram.org\n     */\n    apiHash: string\n\n    /**\n     * Storage to use for this client.\n     */\n    storage: ITelegramStorage\n\n    /**\n     * Cryptography provider factory to allow delegating\n     * crypto to native addon, worker, etc.\n     */\n    crypto?: CryptoProviderFactory\n\n    /**\n     * Whether to use IPv6 datacenters\n     * (IPv6 will be preferred when choosing a DC by id)\n     * (default: false)\n     */\n    useIpv6?: boolean\n\n    /**\n     * Primary DC to use for initial connection.\n     * This does not mean this will be the only DC used,\n     * nor that this DC will actually be primary, this only\n     * determines the first DC the library will try to connect to.\n     * Can be used to connect to other networks (like test DCs).\n     *\n     * When session already contains primary DC, this parameter is ignored.\n     *\n     * @default  Production DC 2.\n     */\n    defaultDcs?: ITelegramStorage.DcOptions\n\n    /**\n     * Whether to connect to test servers.\n     *\n     * If passed, {@link defaultDc} defaults to Test DC 2.\n     *\n     * **Must** be passed if using test servers, even if\n     * you passed custom {@link defaultDc}\n     */\n    testMode?: boolean\n\n    /**\n     * Additional options for initConnection call.\n     * `apiId` and `query` are not available and will be ignored.\n     * Omitted values will be filled with defaults\n     */\n    initConnectionOptions?: Partial<Omit<tl.RawInitConnectionRequest, 'apiId' | 'query'>>\n\n    /**\n     * Transport factory to use in the client.\n     *\n     * @default  platform-specific transport: WebSocket on the web, TCP in node\n     */\n    transport?: TransportFactory\n\n    /**\n     * Reconnection strategy.\n     *\n     * @default  simple reconnection strategy: first 0ms, then up to 5s (increasing by 1s)\n     */\n    reconnectionStrategy?: ReconnectionStrategy<PersistentConnectionParams>\n\n    /**\n     * Maximum duration of a flood_wait that will be waited automatically.\n     * Flood waits above this threshold will throw a FloodWaitError.\n     * Set to 0 to disable. Can be overridden with `throwFlood` parameter in call() params\n     *\n     * @default 10000\n     */\n    floodSleepThreshold?: number\n\n    /**\n     * Maximum number of retries when calling RPC methods.\n     * Call is retried when InternalError or FloodWaitError is encountered.\n     * Can be set to Infinity.\n     *\n     * @default 5\n     */\n    maxRetryCount?: number\n\n    /**\n     * If true, every single API call will be wrapped with `tl.invokeWithoutUpdates`,\n     * effectively disabling the server-sent events for the clients.\n     * May be useful in some cases.\n     *\n     * Note that this only wraps calls made with `.call()` within the primary\n     * connection. Additional connections and direct `.sendForResult()` calls\n     * must be wrapped manually.\n     *\n     * @default false\n     */\n    disableUpdates?: boolean\n\n    /**\n     * mtcute can send all unknown RPC errors to [danog](https://github.com/danog)'s\n     * [error reporting service](https://rpc.pwrtelegram.xyz/).\n     *\n     * This is fully anonymous (except maybe IP) and is only used to improve the library\n     * and developer experience for everyone working with MTProto. This is fully opt-in,\n     * and if you're too paranoid, you can disable it by manually passing `enableErrorReporting: false` to the client.\n     *\n     * @default false\n     */\n    enableErrorReporting?: boolean\n\n    /**\n     * If true, RPC errors will have a stack trace of the initial `.call()`\n     * or `.sendForResult()` call position, which drastically improves\n     * debugging experience.<br>\n     * If false, they will have a stack trace of mtcute internals.\n     *\n     * Internally this creates a stack capture before every RPC call\n     * and stores it until the result is received. This might\n     * use a lot more memory than normal, thus can be disabled here.\n     *\n     * @default true\n     */\n    niceStacks?: boolean\n\n    /**\n     * Extra parameters for {@link NetworkManager}\n     */\n    network?: NetworkManagerExtraParams\n\n    /**\n     * Set logging level for the client.\n     *\n     * See static members of {@link LogManager} for possible values.\n     */\n    logLevel?: number\n\n    /**\n     * **EXPERT USE ONLY!**\n     *\n     * Override TL layer used for the connection.\n     *\n     * **Does not** change the schema used.\n     */\n    overrideLayer?: number\n\n    /**\n     * **EXPERT USE ONLY**\n     *\n     * Override reader map used for the connection.\n     */\n    readerMap?: TlReaderMap\n\n    /**\n     * **EXPERT USE ONLY**\n     *\n     * Override writer map used for the connection.\n     */\n    writerMap?: TlWriterMap\n}\n"]}

package/cjs/storage/abstract.d.ts

@@ -1,224 +0,0 @@
-import { mtp, tl } from '@mtcute/tl';
-import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
-import { BasicPeerType, MaybeAsync } from '../types/index.js';
-import { Logger } from '../utils/index.js';
-export declare namespace ITelegramStorage {
-    /** Information about a cached peer */
-    interface PeerInfo {
-        /** Peer marked ID */
-        id: number;
-        /** Peer access hash */
-        accessHash: tl.Long;
-        /** Peer type */
-        type: BasicPeerType;
-        /** Peer username, if any */
-        username?: string;
-        /** Peer phone number, if available */
-        phone?: string;
-        /** Full TL object with the cached entity */
-        full: tl.TypeUser | tl.TypeChat;
-    }
-    /** Information about currently logged in user */
-    interface SelfInfo {
-        /** Whether this is a bot */
-        isBot: boolean;
-        /** Current user's ID */
-        userId: number;
-    }
-    /** Information about preferred DC-s for the user */
-    interface DcOptions {
-        /** Main DC */
-        main: tl.RawDcOption;
-        /** Media DC. Can be the same as main */
-        media: tl.RawDcOption;
-    }
-}
-/**
- * Abstract interface for persistent storage.
- *
- * In some cases you may want to extend existing MemorySession
- * and override save()/load()/destroy() methods, but you are also free
- * to implement your own session (be sure to refer to MemorySession
- * source code to avoid shooting your leg though)
- *
- * Note that even though set methods *can* be async, you should only
- * write updates to the disk when `save()` is called.
- */
-export interface ITelegramStorage {
-    /**
-     * This method is called before any other.
-     * For storages that use logging, logger instance.
-     * For storages that use binary storage, binary maps
-     */
-    setup?(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void;
-    /**
-     * Load session from some external storage.
-     * Should be used either to load session content from file/network/etc
-     * to memory, or to open required connections to fetch session content later
-     */
-    load?(): MaybeAsync<void>;
-    /**
-     * Save session to some external storage.
-     * Should be used to commit pending changes in the session.
-     * For example, saving session content to file/network/etc,
-     * or committing a database transaction
-     */
-    save?(): MaybeAsync<void>;
-    /**
-     * Cleanup session and release all used resources.
-     */
-    destroy?(): MaybeAsync<void>;
-    /**
-     * Reset session to its default state, optionally resetting auth keys
-     *
-     * @param [withAuthKeys=false]  Whether to also reset auth keys
-     */
-    reset(withAuthKeys?: boolean): MaybeAsync<void>;
-    /**
-     * Set default datacenter to use with this session.
-     */
-    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): MaybeAsync<void>;
-    /**
-     * Get default datacenter for this session
-     * (by default should return null)
-     */
-    getDefaultDcs(): MaybeAsync<ITelegramStorage.DcOptions | null>;
-    /**
-     * Store information about future salts for a given DC
-     */
-    setFutureSalts(dcId: number, salts: mtp.RawMt_future_salt[]): MaybeAsync<void>;
-    /**
-     * Get information about future salts for a given DC (if available)
-     *
-     * You don't need to implement any checks, they will be done by the library.
-     * It is enough to just return the same array that was passed to `setFutureSalts`.
-     */
-    getFutureSalts(dcId: number): MaybeAsync<mtp.RawMt_future_salt[] | null>;
-    /**
-     * Get auth_key for a given DC
-     * (returning null will start authorization)
-     * For temp keys: should also return null if the key has expired
-     *
-     * @param dcId DC ID
-     * @param tempIndex  Index of the temporary key (usually 0, used for multi-connections)
-     */
-    getAuthKeyFor(dcId: number, tempIndex?: number): MaybeAsync<Uint8Array | null>;
-    /**
-     * Set auth_key for a given DC
-     */
-    setAuthKeyFor(dcId: number, key: Uint8Array | null): MaybeAsync<void>;
-    /**
-     * Set temp_auth_key for a given DC
-     * expiresAt is unix time in ms
-     */
-    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): MaybeAsync<void>;
-    /**
-     * Remove all saved auth keys (both temp and perm)
-     * for the given DC. Used when perm_key becomes invalid,
-     * meaning all temp_keys also become invalid
-     */
-    dropAuthKeysFor(dcId: number): MaybeAsync<void>;
-    /**
-     * Get information about currently logged in user (if available)
-     */
-    getSelf(): MaybeAsync<ITelegramStorage.SelfInfo | null>;
-    /**
-     * Save information about currently logged in user
-     */
-    setSelf(self: ITelegramStorage.SelfInfo | null): MaybeAsync<void>;
-    /**
-     * Update local database of input peers from the peer info list
-     *
-     * Client will call `.save()` after all updates-related methods
-     * are called, so you can safely batch these updates
-     */
-    updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>;
-    /**
-     * Find a peer in local database by its marked ID
-     *
-     * If no peer was found, the storage should try searching its
-     * reference messages database. If a reference message is found,
-     * a `inputPeer*FromMessage` constructor should be returned
-     */
-    getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>;
-    /**
-     * Find a peer in local database by its username
-     */
-    getPeerByUsername(username: string): MaybeAsync<tl.TypeInputPeer | null>;
-    /**
-     * Find a peer in local database by its phone number
-     */
-    getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>;
-    /**
-     * For `*FromMessage` constructors: store a reference to a `peerId` -
-     * it was seen in message `messageId` in chat `chatId`.
-     *
-     * `peerId` and `chatId` are marked peer IDs.
-     *
-     * Learn more: https://core.telegram.org/api/min
-     */
-    saveReferenceMessage(peerId: number, chatId: number, messageId: number): MaybeAsync<void>;
-    /**
-     * For `*FromMessage` constructors: messages `messageIds` in chat `chatId` were deleted,
-     * so remove any stored peer references to them.
-     */
-    deleteReferenceMessages(chatId: number, messageIds: number[]): MaybeAsync<void>;
-    /**
-     * Get updates state (if available), represented as a tuple
-     * containing: `pts, qts, date, seq`
-     */
-    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>;
-    /**
-     * Set common `pts` value
-     *
-     * Client will call `.save()` after all updates-related methods
-     * are called, so you can safely batch these updates
-     */
-    setUpdatesPts(val: number): MaybeAsync<void>;
-    /**
-     * Set common `qts` value
-     *
-     * Client will call `.save()` after all updates-related methods
-     * are called, so you can safely batch these updates
-     */
-    setUpdatesQts(val: number): MaybeAsync<void>;
-    /**
-     * Set updates `date` value
-     *
-     * Client will call `.save()` after all updates-related methods
-     * are called, so you can safely batch these updates
-     */
-    setUpdatesDate(val: number): MaybeAsync<void>;
-    /**
-     * Set updates `seq` value
-     *
-     * Client will call `.save()` after all updates-related methods
-     * are called, so you can safely batch these updates
-     */
-    setUpdatesSeq(val: number): MaybeAsync<void>;
-    /**
-     * Get channel `pts` value
-     */
-    getChannelPts(entityId: number): MaybeAsync<number | null>;
-    /**
-     * Set channels `pts` values in batch.
-     *
-     * Storage is supposed to replace stored channel `pts` values
-     * with given in the object (key is unmarked peer id, value is the `pts`)
-     *
-     * Client will call `.save()` after all updates-related methods
-     * are called, so you can safely batch these updates
-     */
-    setManyChannelPts(values: Map<number, number>): MaybeAsync<void>;
-    /**
-     * Get cached peer information by their marked ID.
-     * Return `null` if caching is not supported, or the entity
-     * is not cached (yet).
-     *
-     * This is primarily used when a `min` entity is encountered
-     * in an update, or when a *short* update is encountered.
-     * Returning `null` will require re-fetching that
-     * update with the peers added, which might not be very efficient.
-     */
-    getFullPeerById(id: number): MaybeAsync<tl.TypeUser | tl.TypeChat | null>;
-}

package/cjs/storage/abstract.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=abstract.js.map

package/cjs/storage/abstract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../src/storage/abstract.ts"],"names":[],"mappings":"","sourcesContent":["import { mtp, tl } from '@mtcute/tl'\nimport { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime'\n\nimport { BasicPeerType, MaybeAsync } from '../types/index.js'\nimport { Logger } from '../utils/index.js'\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace ITelegramStorage {\n    /** Information about a cached peer */\n    export interface PeerInfo {\n        /** Peer marked ID */\n        id: number\n        /** Peer access hash */\n        accessHash: tl.Long\n        /** Peer type */\n        type: BasicPeerType\n        /** Peer username, if any */\n        username?: string\n        /** Peer phone number, if available */\n        phone?: string\n\n        /** Full TL object with the cached entity */\n        full: tl.TypeUser | tl.TypeChat\n    }\n\n    /** Information about currently logged in user */\n    export interface SelfInfo {\n        /** Whether this is a bot */\n        isBot: boolean\n        /** Current user's ID */\n        userId: number\n    }\n\n    /** Information about preferred DC-s for the user */\n    export interface DcOptions {\n        /** Main DC */\n        main: tl.RawDcOption\n        /** Media DC. Can be the same as main */\n        media: tl.RawDcOption\n    }\n}\n\n/**\n * Abstract interface for persistent storage.\n *\n * In some cases you may want to extend existing MemorySession\n * and override save()/load()/destroy() methods, but you are also free\n * to implement your own session (be sure to refer to MemorySession\n * source code to avoid shooting your leg though)\n *\n * Note that even though set methods *can* be async, you should only\n * write updates to the disk when `save()` is called.\n */\nexport interface ITelegramStorage {\n    /**\n     * This method is called before any other.\n     * For storages that use logging, logger instance.\n     * For storages that use binary storage, binary maps\n     */\n    setup?(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void\n\n    /**\n     * Load session from some external storage.\n     * Should be used either to load session content from file/network/etc\n     * to memory, or to open required connections to fetch session content later\n     */\n    load?(): MaybeAsync<void>\n    /**\n     * Save session to some external storage.\n     * Should be used to commit pending changes in the session.\n     * For example, saving session content to file/network/etc,\n     * or committing a database transaction\n     */\n    save?(): MaybeAsync<void>\n    /**\n     * Cleanup session and release all used resources.\n     */\n    destroy?(): MaybeAsync<void>\n\n    /**\n     * Reset session to its default state, optionally resetting auth keys\n     *\n     * @param [withAuthKeys=false]  Whether to also reset auth keys\n     */\n    reset(withAuthKeys?: boolean): MaybeAsync<void>\n\n    /**\n     * Set default datacenter to use with this session.\n     */\n    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): MaybeAsync<void>\n    /**\n     * Get default datacenter for this session\n     * (by default should return null)\n     */\n    getDefaultDcs(): MaybeAsync<ITelegramStorage.DcOptions | null>\n\n    /**\n     * Store information about future salts for a given DC\n     */\n    setFutureSalts(dcId: number, salts: mtp.RawMt_future_salt[]): MaybeAsync<void>\n    /**\n     * Get information about future salts for a given DC (if available)\n     *\n     * You don't need to implement any checks, they will be done by the library.\n     * It is enough to just return the same array that was passed to `setFutureSalts`.\n     */\n    getFutureSalts(dcId: number): MaybeAsync<mtp.RawMt_future_salt[] | null>\n\n    /**\n     * Get auth_key for a given DC\n     * (returning null will start authorization)\n     * For temp keys: should also return null if the key has expired\n     *\n     * @param dcId DC ID\n     * @param tempIndex  Index of the temporary key (usually 0, used for multi-connections)\n     */\n    getAuthKeyFor(dcId: number, tempIndex?: number): MaybeAsync<Uint8Array | null>\n    /**\n     * Set auth_key for a given DC\n     */\n    setAuthKeyFor(dcId: number, key: Uint8Array | null): MaybeAsync<void>\n    /**\n     * Set temp_auth_key for a given DC\n     * expiresAt is unix time in ms\n     */\n    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): MaybeAsync<void>\n    /**\n     * Remove all saved auth keys (both temp and perm)\n     * for the given DC. Used when perm_key becomes invalid,\n     * meaning all temp_keys also become invalid\n     */\n    dropAuthKeysFor(dcId: number): MaybeAsync<void>\n\n    /**\n     * Get information about currently logged in user (if available)\n     */\n    getSelf(): MaybeAsync<ITelegramStorage.SelfInfo | null>\n    /**\n     * Save information about currently logged in user\n     */\n    setSelf(self: ITelegramStorage.SelfInfo | null): MaybeAsync<void>\n\n    /**\n     * Update local database of input peers from the peer info list\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>\n\n    /**\n     * Find a peer in local database by its marked ID\n     *\n     * If no peer was found, the storage should try searching its\n     * reference messages database. If a reference message is found,\n     * a `inputPeer*FromMessage` constructor should be returned\n     */\n    getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * Find a peer in local database by its username\n     */\n    getPeerByUsername(username: string): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * Find a peer in local database by its phone number\n     */\n    getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * For `*FromMessage` constructors: store a reference to a `peerId` -\n     * it was seen in message `messageId` in chat `chatId`.\n     *\n     * `peerId` and `chatId` are marked peer IDs.\n     *\n     * Learn more: https://core.telegram.org/api/min\n     */\n    saveReferenceMessage(peerId: number, chatId: number, messageId: number): MaybeAsync<void>\n\n    /**\n     * For `*FromMessage` constructors: messages `messageIds` in chat `chatId` were deleted,\n     * so remove any stored peer references to them.\n     */\n    deleteReferenceMessages(chatId: number, messageIds: number[]): MaybeAsync<void>\n\n    /**\n     * Get updates state (if available), represented as a tuple\n     * containing: `pts, qts, date, seq`\n     */\n    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>\n\n    /**\n     * Set common `pts` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesPts(val: number): MaybeAsync<void>\n    /**\n     * Set common `qts` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesQts(val: number): MaybeAsync<void>\n    /**\n     * Set updates `date` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesDate(val: number): MaybeAsync<void>\n    /**\n     * Set updates `seq` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesSeq(val: number): MaybeAsync<void>\n\n    /**\n     * Get channel `pts` value\n     */\n    getChannelPts(entityId: number): MaybeAsync<number | null>\n    /**\n     * Set channels `pts` values in batch.\n     *\n     * Storage is supposed to replace stored channel `pts` values\n     * with given in the object (key is unmarked peer id, value is the `pts`)\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setManyChannelPts(values: Map<number, number>): MaybeAsync<void>\n\n    /**\n     * Get cached peer information by their marked ID.\n     * Return `null` if caching is not supported, or the entity\n     * is not cached (yet).\n     *\n     * This is primarily used when a `min` entity is encountered\n     * in an update, or when a *short* update is encountered.\n     * Returning `null` will require re-fetching that\n     * update with the peers added, which might not be very efficient.\n     */\n    getFullPeerById(id: number): MaybeAsync<tl.TypeUser | tl.TypeChat | null>\n}\n"]}

package/cjs/storage/idb.d.ts

@@ -1,103 +0,0 @@
-import { mtp, tl } from '@mtcute/tl';
-import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
-import { Logger } from '../utils/logger.js';
-import { ITelegramStorage } from './abstract.js';
-/**
- * mtcute storage that uses IndexedDB as a backend.
- *
- * This storage is the default one for browsers, and is generally
- * recommended over local storage based one.
- */
-export declare class IdbStorage implements ITelegramStorage {
-    readonly _dbName: string;
-    private _cache?;
-    private _vacuumTimeout?;
-    private _vacuumInterval;
-    constructor(_dbName: string, params?: {
-        /**
-         * Entities cache size, in number of entities.
-         *
-         * Recently encountered entities are cached in memory,
-         * to avoid redundant database calls. Set to 0 to
-         * disable caching (not recommended)
-         *
-         * Note that by design in-memory cached is only
-         * used when finding peer by ID, since other
-         * kinds of lookups (phone, username) may get stale quickly
-         *
-         * @default  `100`
-         */
-        cacheSize?: number;
-        /**
-         * Updates to already cached in-memory entities are only
-         * applied in DB once in a while, to avoid redundant
-         * DB calls.
-         *
-         * If you are having issues with this, you can set this to `0`
-         *
-         * @default  `30000` (30 sec)
-         */
-        unimportantSavesDelay?: number;
-        /**
-         * Interval in milliseconds for vacuuming the storage.
-         *
-         * When vacuuming, the storage will remove expired FSM
-         * states to reduce disk and memory usage.
-         *
-         * @default  `300_000` (5 minutes)
-         */
-        vacuumInterval?: number;
-    });
-    db: IDBDatabase;
-    private _upgradeDb;
-    private log;
-    private readerMap;
-    private writerMap;
-    private _reader;
-    setup(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void;
-    private _pendingWrites;
-    private _pendingWritesOses;
-    private _writeLater;
-    private _readFullPeer;
-    load(): Promise<void>;
-    save(): Promise<void>;
-    private _vacuum;
-    destroy(): void;
-    reset(withAuthKeys?: boolean | undefined): Promise<void>;
-    private _getFromKv;
-    private _setToKv;
-    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): Promise<void>;
-    getDefaultDcs(): Promise<ITelegramStorage.DcOptions | null>;
-    getFutureSalts(dcId: number): Promise<mtp.RawMt_future_salt[] | null>;
-    setFutureSalts(dcId: number, salts: mtp.RawMt_future_salt[]): Promise<void>;
-    getAuthKeyFor(dcId: number, tempIndex?: number | undefined): Promise<Uint8Array | null>;
-    setAuthKeyFor(dcId: number, key: Uint8Array | null): Promise<void>;
-    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): Promise<void>;
-    dropAuthKeysFor(dcId: number): Promise<void>;
-    private _cachedSelf?;
-    getSelf(): Promise<ITelegramStorage.SelfInfo | null>;
-    setSelf(self: ITelegramStorage.SelfInfo | null): Promise<void>;
-    getUpdatesState(): Promise<[number, number, number, number] | null>;
-    setUpdatesPts(val: number): Promise<void>;
-    setUpdatesQts(val: number): Promise<void>;
-    setUpdatesDate(val: number): Promise<void>;
-    setUpdatesSeq(val: number): Promise<void>;
-    getChannelPts(entityId: number): Promise<number | null>;
-    setManyChannelPts(values: Map<number, number>): Promise<void>;
-    updatePeers(peers: ITelegramStorage.PeerInfo[]): void;
-    private _findPeerByReference;
-    getPeerById(peerId: number, allowRefs?: boolean): Promise<tl.TypeInputPeer | null>;
-    getPeerByUsername(username: string): Promise<tl.TypeInputPeer | null>;
-    getPeerByPhone(phone: string): Promise<tl.TypeInputPeer | null>;
-    getFullPeerById(peerId: number): Promise<tl.TypeUser | tl.TypeChat | null>;
-    saveReferenceMessage(peerId: number, chatId: number, messageId: number): Promise<void>;
-    deleteReferenceMessages(chatId: number, messageIds: number[]): Promise<void>;
-    getState(key: string): Promise<unknown>;
-    setState(key: string, state: unknown, ttl?: number): Promise<void>;
-    deleteState(key: string): Promise<void>;
-    getCurrentScene(key: string): Promise<string | null>;
-    setCurrentScene(key: string, scene: string, ttl?: number): Promise<void>;
-    deleteCurrentScene(key: string): Promise<void>;
-    getRateLimit(key: string, limit: number, window: number): Promise<[number, number]>;
-    resetRateLimit(key: string): Promise<void>;
-}