@mtcute/core 0.18.0-rc.5 → 0.18.0

package/storage/service/base.d.cts

@@ -0,0 +1,19 @@
+import { tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { Logger } from '../../utils/logger.js';
+import { IStorageDriver } from '../driver.js';
+export interface ServiceOptions {
+    driver: IStorageDriver;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+    log: Logger;
+}
+export declare class BaseService {
+    protected _driver: IStorageDriver;
+    protected _readerMap: TlReaderMap;
+    protected _writerMap: TlWriterMap;
+    protected _log: Logger;
+    constructor(opts: ServiceOptions);
+    protected _serializeTl(obj: tl.TlObject): Uint8Array;
+    protected _deserializeTl(data: Uint8Array): tl.TlObject | null;
+}

package/storage/service/default-dcs.d.cts

@@ -0,0 +1,10 @@
+import { DcOptions } from '../../utils/dcs.js';
+import { IKeyValueRepository } from '../repository/key-value.js';
+import { ServiceOptions, BaseService } from './base.js';
+export declare class DefaultDcsService extends BaseService {
+    readonly _kv: IKeyValueRepository;
+    constructor(_kv: IKeyValueRepository, opts: ServiceOptions);
+    private _cached?;
+    store(dcs: DcOptions): Promise<void>;
+    fetch(): Promise<DcOptions | null>;
+}

package/storage/service/future-salts.d.cts

@@ -0,0 +1,11 @@
+import { mtp } from '@mtcute/tl';
+import { IKeyValueRepository } from '../repository/key-value.js';
+import { ServiceOptions, BaseService } from './base.js';
+export declare class FutureSaltsService extends BaseService {
+    readonly _kv: IKeyValueRepository;
+    constructor(_kv: IKeyValueRepository, opts: ServiceOptions);
+    private _cached;
+    store(dcId: number, salts: mtp.RawMt_future_salt[]): Promise<void>;
+    fetch(dcId: number): Promise<mtp.RawMt_future_salt[] | null>;
+    delete(dcId: number): Promise<void>;
+}

package/storage/service/updates.test.d.cts

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

package/storage/service/utils.test-utils.d.cts

@@ -0,0 +1,2 @@
+import { ServiceOptions } from './base.js';
+export declare function testServiceOptions(): ServiceOptions;

package/storage/sqlite/driver.d.cts

@@ -0,0 +1,24 @@
+import { ISqliteDatabase, ISqliteStatement } from './types.js';
+import { BaseStorageDriver } from '../driver.js';
+type MigrationFunction = (db: ISqliteDatabase) => void;
+export declare abstract class BaseSqliteStorageDriver extends BaseStorageDriver {
+    db: ISqliteDatabase;
+    private _pending;
+    private _runMany;
+    private _cleanup?;
+    private _migrations;
+    private _maxVersion;
+    private _legacyMigrations;
+    registerLegacyMigration(repo: string, migration: MigrationFunction): void;
+    registerMigration(repo: string, version: number, migration: MigrationFunction): void;
+    private _onLoad;
+    onLoad(cb: (db: ISqliteDatabase) => void): void;
+    _writeLater(stmt: ISqliteStatement, params: unknown[]): void;
+    private _runLegacyMigrations;
+    _initialize(): void;
+    abstract _createDatabase(): ISqliteDatabase;
+    _load(): Promise<void>;
+    _save(): void;
+    _destroy(): void;
+}
+export {};

package/storage/sqlite/index.d.cts

@@ -0,0 +1,17 @@
+import { ITelegramStorageProvider } from '../../highlevel/storage/provider.js';
+import { IMtStorageProvider } from '../provider.js';
+import { BaseSqliteStorageDriver } from './driver.js';
+import { SqliteAuthKeysRepository } from './repository/auth-keys.js';
+import { SqliteKeyValueRepository } from './repository/kv.js';
+import { SqlitePeersRepository } from './repository/peers.js';
+import { SqliteRefMessagesRepository } from './repository/ref-messages.js';
+export { BaseSqliteStorageDriver };
+export * from './types.js';
+export declare class BaseSqliteStorage implements IMtStorageProvider, ITelegramStorageProvider {
+    readonly driver: BaseSqliteStorageDriver;
+    readonly authKeys: SqliteAuthKeysRepository;
+    readonly kv: SqliteKeyValueRepository;
+    readonly refMessages: SqliteRefMessagesRepository;
+    readonly peers: SqlitePeersRepository;
+    constructor(driver: BaseSqliteStorageDriver);
+}

package/storage/sqlite/repository/auth-keys.d.cts

@@ -0,0 +1,20 @@
+import { IAuthKeysRepository } from '../../repository/auth-keys.js';
+import { BaseSqliteStorageDriver } from '../driver.js';
+export declare class SqliteAuthKeysRepository implements IAuthKeysRepository {
+    readonly _driver: BaseSqliteStorageDriver;
+    constructor(_driver: BaseSqliteStorageDriver);
+    private _set;
+    private _del;
+    set(dc: number, key: Uint8Array | null): void;
+    private _get;
+    get(dc: number): Uint8Array | null;
+    private _setTemp;
+    private _delTemp;
+    setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): void;
+    private _getTemp;
+    getTemp(dc: number, idx: number, now: number): Uint8Array | null;
+    private _delTempAll;
+    deleteByDc(dc: number): void;
+    private _delAll;
+    deleteAll(): void;
+}

package/storage/sqlite/repository/kv.d.cts

@@ -0,0 +1,14 @@
+import { IKeyValueRepository } from '../../repository/key-value.js';
+import { BaseSqliteStorageDriver } from '../driver.js';
+export declare class SqliteKeyValueRepository implements IKeyValueRepository {
+    readonly _driver: BaseSqliteStorageDriver;
+    constructor(_driver: BaseSqliteStorageDriver);
+    private _set;
+    set(key: string, value: Uint8Array): void;
+    private _get;
+    get(key: string): Uint8Array | null;
+    private _del;
+    delete(key: string): void;
+    private _delAll;
+    deleteAll(): void;
+}

package/storage/sqlite/repository/peers.d.cts

@@ -0,0 +1,19 @@
+import { IPeersRepository } from '../../../highlevel/storage/repository/peers.js';
+import { BaseSqliteStorageDriver } from '../driver.js';
+export declare class SqlitePeersRepository implements IPeersRepository {
+    readonly _driver: BaseSqliteStorageDriver;
+    private _loaded;
+    constructor(_driver: BaseSqliteStorageDriver);
+    private _ensureLoaded;
+    private _store;
+    store(peer: IPeersRepository.PeerInfo): void;
+    private _getById;
+    private _getByIdAllowMin;
+    getById(id: number, allowMin: boolean): IPeersRepository.PeerInfo | null;
+    private _getByUsername;
+    getByUsername(username: string): IPeersRepository.PeerInfo | null;
+    private _getByPhone;
+    getByPhone(phone: string): IPeersRepository.PeerInfo | null;
+    private _delAll;
+    deleteAll(): void;
+}

package/storage/sqlite/repository/ref-messages.d.cts

@@ -0,0 +1,16 @@
+import { IReferenceMessagesRepository } from '../../../highlevel/storage/repository/ref-messages.js';
+import { BaseSqliteStorageDriver } from '../driver.js';
+export declare class SqliteRefMessagesRepository implements IReferenceMessagesRepository {
+    readonly _driver: BaseSqliteStorageDriver;
+    constructor(_driver: BaseSqliteStorageDriver);
+    private _store;
+    store(peerId: number, chatId: number, msgId: number): void;
+    private _getByPeer;
+    getByPeer(peerId: number): [number, number] | null;
+    private _del;
+    delete(chatId: number, msgIds: number[]): void;
+    private _delByPeer;
+    deleteByPeer(peerId: number): void;
+    private _delAll;
+    deleteAll(): void;
+}

package/storage/sqlite/types.d.cts

@@ -0,0 +1,18 @@
+/**
+ * An abstract interface for a SQLite database.
+ *
+ * Roughly based on `better-sqlite3`'s `Database` class,
+ * (which can be used as-is), but only with the methods
+ * that are used by mtcute.
+ */
+export interface ISqliteDatabase {
+    transaction: <F extends (...args: any[]) => any>(fn: F) => F;
+    prepare: <BindParameters extends unknown[]>(sql: string) => ISqliteStatement<BindParameters>;
+    exec: (sql: string) => void;
+    close: () => void;
+}
+export interface ISqliteStatement<BindParameters extends unknown[] = unknown[]> {
+    run: (...params: BindParameters) => void;
+    get: (...params: BindParameters) => unknown;
+    all: (...params: BindParameters) => unknown[];
+}

package/storage/storage.d.cts

@@ -0,0 +1,55 @@
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { ICorePlatform } from '../types/platform.js';
+import { Logger } from '../utils/logger.js';
+import { IStorageDriver } from './driver.js';
+import { IMtStorageProvider } from './provider.js';
+import { AuthKeysService } from './service/auth-keys.js';
+import { DefaultDcsService } from './service/default-dcs.js';
+import { FutureSaltsService } from './service/future-salts.js';
+interface StorageManagerOptions {
+    provider: IMtStorageProvider;
+    platform: ICorePlatform;
+    log: Logger;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+}
+/**
+ * Additional options for {@link StorageManager}, that
+ * can be customized by the user.
+ *
+ * @internal
+ */
+export interface StorageManagerExtraOptions {
+    /**
+     * Interval in milliseconds for saving the storage.
+     *
+     * When saving, the storage is expected to persist
+     * all changes to disk, so that they are not lost.
+     */
+    saveInterval?: number;
+    /**
+     * Whether to finalize database before exiting.
+     *
+     * @default  `true`
+     */
+    cleanup?: boolean;
+}
+export declare class StorageManager {
+    readonly options: StorageManagerOptions & StorageManagerExtraOptions;
+    readonly provider: IMtStorageProvider;
+    readonly driver: IStorageDriver;
+    readonly platform: ICorePlatform;
+    readonly log: Logger;
+    readonly dcs: DefaultDcsService;
+    readonly salts: FutureSaltsService;
+    readonly keys: AuthKeysService;
+    constructor(options: StorageManagerOptions & StorageManagerExtraOptions);
+    private _cleanupRestore?;
+    private _load;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    clear(withAuthKeys?: boolean): Promise<void>;
+    private _destroy;
+    destroy(): Promise<void>;
+}
+export {};

package/types/errors.d.cts

@@ -0,0 +1,53 @@
+/**
+ * Base class for all mtcute errors
+ */
+export declare class MtcuteError extends Error {
+}
+/**
+ * Method invocation was invalid because some argument
+ * passed was invalid.
+ */
+export declare class MtArgumentError extends MtcuteError {
+}
+/**
+ * Something isn't right with security of the connection.
+ */
+export declare class MtSecurityError extends MtcuteError {
+}
+/**
+ * Either you requested or the server returned something
+ * that is not (yet) supported.
+ *
+ * Stay tuned for future updates!
+ *
+ * In some cases, this error may mean that you are missing some
+ * optional peer dependencies, or that the feature is not supported
+ * in the current environment.
+ */
+export declare class MtUnsupportedError extends MtcuteError {
+}
+/**
+ * Server returned something of an unexpected type.
+ *
+ * This is usually a problem on library side.
+ * Feel free to open an issue about this!
+ */
+export declare class MtTypeAssertionError extends MtcuteError {
+    /**
+     * Context at which the error occurred.
+     * Usually a user-friendly string containing name
+     * of the high-level API method, name of the TL
+     * RPC method, and path of the entity,
+     * like this: `signIn (@ auth.signIn -> user)`
+     */
+    context: string;
+    /** Expected TL type */
+    expected: string;
+    /** Actual TL type */
+    actual: string;
+    constructor(context: string, expected: string, actual: string);
+}
+export declare class MtTimeoutError extends MtcuteError {
+    readonly timeout?: number | undefined;
+    constructor(timeout?: number | undefined);
+}

package/types/index.d.cts

@@ -0,0 +1,4 @@
+export * from './errors.js';
+export * from './peers.js';
+export * from './platform.js';
+export * from './utils.js';

package/types/peers.d.cts

@@ -0,0 +1,4 @@
+/**
+ * Peer types that have one-to-one relation to `tl.Peer*` types.
+ */
+export type BasicPeerType = 'user' | 'chat' | 'channel';

package/types/platform.d.cts

@@ -0,0 +1,15 @@
+import { UploadFileLike } from '../highlevel/types/files/utils.js';
+import { MaybePromise } from './index.js';
+export interface ICorePlatform {
+    beforeExit: (fn: () => void) => () => void;
+    log: (color: number, level: number, tag: string, fmt: string, args: unknown[]) => void;
+    getDefaultLogLevel: () => number | null;
+    getDeviceModel: () => string;
+    normalizeFile?: (file: UploadFileLike) => MaybePromise<{
+        file?: UploadFileLike;
+        fileSize?: number;
+        fileName?: string;
+    } | null>;
+    onNetworkChanged?: (fn: (connected: boolean) => void) => () => void;
+    isOnline?: () => boolean;
+}

package/types/utils.d.cts

@@ -0,0 +1,9 @@
+export type { MaybeArray, MaybePromise } from '@fuman/utils';
+export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
+export type PartialOnly<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+export type AnyToNever<T> = any extends T ? never : T;
+export type MustEqual<T, V> = (() => T) extends () => V ? ((() => V) extends () => T ? T : V) : V;
+export type PublicPart<T> = {
+    [K in keyof T]: T[K];
+};
+export declare function assertNever(_: never): never;

package/utils/abort-signal.d.cts

@@ -0,0 +1 @@
+export declare function combineAbortSignals(signal1: AbortSignal, signal2?: AbortSignal): AbortSignal;

package/utils/bigint-utils.d.cts

@@ -0,0 +1,18 @@
+import { ICryptoProvider } from './crypto/abstract.js';
+/**
+ * Generate a cryptographically safe random big integer of the given size (in bytes)
+ * @param size  Size in bytes
+ */
+export declare function randomBigInt(crypto: ICryptoProvider, size: number): bigint;
+/**
+ * Generate a random big integer of the given size (in bits)
+ * @param bits
+ */
+export declare function randomBigIntBits(crypto: ICryptoProvider, bits: number): bigint;
+/**
+ * Generate a random big integer in the range [min, max)
+ *
+ * @param max  Maximum value (exclusive)
+ * @param min  Minimum value (inclusive)
+ */
+export declare function randomBigIntInRange(crypto: ICryptoProvider, max: bigint, min?: bigint): bigint;

package/utils/bigint-utils.test.d.cts

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

package/utils/binary/asn1-parser.d.cts

@@ -0,0 +1,17 @@
+/**
+ * Parses a single PEM block to buffer.
+ * In fact just strips begin/end tags and parses the rest as Base64
+ */
+export declare function parsePemContents(pem: string): Uint8Array;
+interface Asn1Object {
+    type: number;
+    lengthSize: number;
+    length: number;
+    children?: Asn1Object[];
+    value?: Uint8Array;
+}
+/**
+ * Parses ASN.1 data to an object
+ */
+export declare function parseAsn1(data: Uint8Array): Asn1Object;
+export {};

package/utils/crypto/abstract.d.cts

@@ -0,0 +1,29 @@
+import { MaybePromise } from '../../types/index.js';
+export interface IEncryptionScheme {
+    encrypt: (data: Uint8Array) => Uint8Array;
+    decrypt: (data: Uint8Array) => Uint8Array;
+}
+export interface IAesCtr {
+    process: (data: Uint8Array) => Uint8Array;
+    close?: () => void;
+}
+export interface ICryptoProvider {
+    initialize?: () => MaybePromise<void>;
+    sha1: (data: Uint8Array) => Uint8Array;
+    sha256: (data: Uint8Array) => Uint8Array;
+    pbkdf2: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen?: number, // = 64
+    algo?: string) => MaybePromise<Uint8Array>;
+    hmacSha256: (data: Uint8Array, key: Uint8Array) => MaybePromise<Uint8Array>;
+    createAesCtr: (key: Uint8Array, iv: Uint8Array, encrypt: boolean) => IAesCtr;
+    createAesIge: (key: Uint8Array, iv: Uint8Array) => IEncryptionScheme;
+    factorizePQ: (pq: Uint8Array) => MaybePromise<[Uint8Array, Uint8Array]>;
+    gzip: (data: Uint8Array, maxSize: number) => Uint8Array | null;
+    gunzip: (data: Uint8Array) => Uint8Array;
+    randomFill: (buf: Uint8Array) => void;
+    randomBytes: (size: number) => Uint8Array;
+}
+export declare abstract class BaseCryptoProvider {
+    abstract randomFill(buf: Uint8Array): void;
+    factorizePQ(pq: Uint8Array): [Uint8Array, Uint8Array];
+    randomBytes(size: number): Uint8Array;
+}

package/utils/crypto/factorization.d.cts

@@ -0,0 +1,6 @@
+import { ICryptoProvider } from './abstract.js';
+/**
+ * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm
+ * @param pq
+ */
+export declare function factorizePQSync(crypto: ICryptoProvider, pq: Uint8Array): [Uint8Array, Uint8Array];

package/utils/crypto/factorization.test.d.cts

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

package/utils/crypto/index.d.cts

@@ -0,0 +1,6 @@
+export * from './abstract.js';
+export * from './factorization.js';
+export * from './keys.js';
+export * from './miller-rabin.js';
+export * from './mtproto.js';
+export * from './password.js';

package/utils/crypto/keys.d.cts

@@ -0,0 +1,27 @@
+import { TlPublicKey } from '@mtcute/tl/binary/rsa-keys.js';
+import { default as Long } from 'long';
+import { ICryptoProvider } from './abstract.js';
+/**
+ * Parse PEM-encoded RSA public key information into modulus and exponent
+ * and compute its fingerprint as defined by MTProto.
+ *
+ * @param crypto  Crypto provider
+ * @param key  PEM-encoded RSA public key
+ * @param old  Whether this is an "old" key
+ */
+export declare function parsePublicKey(crypto: ICryptoProvider, key: string, old?: boolean): TlPublicKey;
+/**
+ * Add public key to the global index.
+ *
+ * @param crypto  Crypto provider
+ * @param key  PEM-encoded RSA public key
+ * @param old  Whether this is an "old" key
+ */
+export declare function addPublicKey(crypto: ICryptoProvider, key: string, old?: boolean): void;
+/**
+ * Get public key by its fingerprint.
+ *
+ * @param fingerprints  Fingerprints to match. The first one to match is returned.
+ * @param allowOld  Whether to allow "old" keys
+ */
+export declare function findKeyByFingerprints(fingerprints: (string | Long)[], allowOld?: boolean): TlPublicKey | null;

package/utils/crypto/keys.test.d.cts

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

package/utils/crypto/miller-rabin.d.cts

@@ -0,0 +1,2 @@
+import { ICryptoProvider } from './abstract.js';
+export declare function millerRabin(crypto: ICryptoProvider, n: bigint, rounds?: number): boolean;

package/utils/crypto/miller-rabin.test.d.cts

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

package/utils/crypto/mtproto.d.cts

@@ -0,0 +1,31 @@
+import { ICryptoProvider, IEncryptionScheme } from './abstract.js';
+/**
+ * Generate AES key and IV from nonces as defined by MTProto.
+ * Used in authorization flow.
+ *
+ * @param crypto  Crypto provider
+ * @param serverNonce  Server nonce
+ * @param newNonce  New nonce
+ * @returns  Tuple: `[key, iv]`
+ */
+export declare function generateKeyAndIvFromNonce(crypto: ICryptoProvider, serverNonce: Uint8Array, newNonce: Uint8Array): [Uint8Array, Uint8Array];
+/**
+ * Create AES IGE instance for message (given auth key and message key)
+ * as defined by MTProto v2.
+ *
+ * @param crypto  Crypto provider
+ * @param authKey  Authorization key
+ * @param messageKey  Message key
+ * @param client  Whether this is a client to server message
+ */
+export declare function createAesIgeForMessage(crypto: ICryptoProvider, authKey: Uint8Array, messageKey: Uint8Array, client: boolean): IEncryptionScheme;
+/**
+ * Create AES IGE instance for file (given auth key and message key)
+ * as defined by MTProto v1.
+ *
+ * @param crypto  Crypto provider
+ * @param authKey  Authorization key
+ * @param messageKey  Message key
+ * @param client  Whether this is a client to server message
+ */
+export declare function createAesIgeForMessageOld(crypto: ICryptoProvider, authKey: Uint8Array, messageKey: Uint8Array, client: boolean): IEncryptionScheme;

package/utils/crypto/mtproto.test.d.cts

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

package/utils/crypto/password.d.cts

@@ -0,0 +1,29 @@
+import { tl } from '@mtcute/tl';
+import { ICryptoProvider } from './abstract.js';
+/**
+ * Compute password hash as defined by MTProto.
+ *
+ * See https://core.telegram.org/api/srp#checking-the-password-with-srp
+ *
+ * @param crypto  Crypto provider
+ * @param password  Password
+ * @param salt1  Salt 1
+ * @param salt2  Salt 2
+ */
+export declare function computePasswordHash(crypto: ICryptoProvider, password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array): Promise<Uint8Array>;
+/**
+ * Compute new password SRP hash as defined by MTProto.
+ *
+ * @param crypto  Crypto provider
+ * @param algo  KDF algorithm
+ * @param password  Password
+ */
+export declare function computeNewPasswordHash(crypto: ICryptoProvider, algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
+/**
+ * Compute SRP check parameters for 2fa password as defined by MTProto.
+ *
+ * @param crypto  Crypto provider
+ * @param request  SRP request
+ * @param password  2fa password
+ */
+export declare function computeSrpParams(crypto: ICryptoProvider, request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;

package/utils/crypto/password.test.d.cts

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

package/utils/dcs.d.cts

@@ -0,0 +1,18 @@
+export interface BasicDcOption {
+    ipAddress: string;
+    port: number;
+    id: number;
+    ipv6?: boolean;
+    mediaOnly?: boolean;
+    testMode?: boolean;
+}
+export declare function serializeBasicDcOption(dc: BasicDcOption): Uint8Array;
+export declare function parseBasicDcOption(data: Uint8Array): BasicDcOption | null;
+export interface DcOptions {
+    main: BasicDcOption;
+    media: BasicDcOption;
+}
+export declare const defaultProductionDc: DcOptions;
+export declare const defaultProductionIpv6Dc: DcOptions;
+export declare const defaultTestDc: DcOptions;
+export declare const defaultTestIpv6Dc: DcOptions;

package/utils/early-timer.d.cts

@@ -0,0 +1,41 @@
+/**
+ * Wrapper over JS timers that allows re-scheduling them
+ * to earlier time
+ */
+export declare class EarlyTimer {
+    private _timeout?;
+    private _timeoutTs?;
+    private _handler;
+    constructor();
+    /**
+     * Emit the timer when the event loop is idle
+     * (basically `setImmediate()`)
+     */
+    emitWhenIdle(): void;
+    /**
+     * Emit the timer before the next given milliseconds
+     *
+     * Shorthand for `emitBefore(Date.now() + ms)`
+     *
+     * @param ms  Milliseconds to schedule for
+     */
+    emitBeforeNext(ms: number): void;
+    /**
+     * Emit the timer before the given time
+     *
+     * @param ts  Unix time in MS
+     */
+    emitBefore(ts: number): void;
+    /**
+     * Emit the timer right now
+     */
+    emitNow(): void;
+    /**
+     * Cancel the timer
+     */
+    reset(): void;
+    /**
+     * Set timeout handler
+     */
+    onTimeout(handler: () => void): void;
+}

package/utils/error-reporting.d.cts

@@ -0,0 +1,3 @@
+import { tl } from '@mtcute/tl';
+import { Logger } from './logger.js';
+export declare function reportUnknownError(log: Logger, error: tl.RpcError, method: string): void;

package/utils/function-utils.d.cts

@@ -0,0 +1,22 @@
+export type ThrottledFunction = (() => void) & {
+    reset: () => void;
+};
+/**
+ * Throttle a function with a given delay.
+ * Similar to lodash.
+ *
+ * Throttling `F` for a delay of `D` means that
+ * `F` will be called no more than 1 time every `D`.
+ * In this implementation, `F` is called after `D`
+ * has passed since the previous non-throttled invocation
+ *
+ * @param func  Function to throttle
+ * @param delay  Throttle delay
+ */
+export declare function throttle(func: () => void, delay: number): ThrottledFunction;
+export declare function asyncResettable<T extends (...args: any[]) => Promise<any>>(func: T): {
+    run: T;
+    finished: () => boolean;
+    wait: () => Promise<any> | null;
+    reset: () => void;
+};

package/utils/function-utils.test.d.cts

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

package/utils/index.d.cts

@@ -0,0 +1,20 @@
+export * from '../highlevel/storage/service/current-user.js';
+export * from '../highlevel/storage/service/updates.js';
+export * from '../highlevel/utils/index.js';
+export * from '../storage/service/base.js';
+export * from '../storage/service/default-dcs.js';
+export * from './bigint-utils.js';
+export * from './crypto/index.js';
+export * from './dcs.js';
+export * from './early-timer.js';
+export * from './function-utils.js';
+export * from './linked-list.js';
+export * from './links/index.js';
+export * from './logger.js';
+export * from './long-utils.js';
+export * from './misc-utils.js';
+export * from './peer-utils.js';
+export * from './sorted-array.js';
+export * from './tl-json.js';
+export * from './type-assertions.js';
+export * from '@mtcute/tl-runtime';