@mtcute/core 0.16.7 → 0.16.9

package/package.json

@@ -1,51 +1,85 @@
 {
-  "name": "@mtcute/core",
-  "type": "module",
-  "version": "0.16.7",
-  "description": "Type-safe library for MTProto (Telegram API)",
-  "author": "alina sireneva <alina@tei.su>",
-  "license": "MIT",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "import": "./esm/index.js",
-      "require": "./cjs/index.js"
+    "name": "@mtcute/core",
+    "type": "module",
+    "version": "0.16.9",
+    "description": "Type-safe library for MTProto (Telegram API)",
+    "author": "alina sireneva <alina@tei.su>",
+    "license": "MIT",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        },
+        "./utils.js": {
+            "import": {
+                "types": "./utils.d.ts",
+                "default": "./utils.js"
+            },
+            "require": {
+                "types": "./utils.d.cts",
+                "default": "./utils.cjs"
+            }
+        },
+        "./client.js": {
+            "import": {
+                "types": "./client.d.ts",
+                "default": "./client.js"
+            },
+            "require": {
+                "types": "./client.d.cts",
+                "default": "./client.cjs"
+            }
+        },
+        "./worker.js": {
+            "import": {
+                "types": "./worker.d.ts",
+                "default": "./worker.js"
+            },
+            "require": {
+                "types": "./worker.d.cts",
+                "default": "./worker.cjs"
+            }
+        },
+        "./methods.js": {
+            "import": {
+                "types": "./methods.d.ts",
+                "default": "./methods.js"
+            },
+            "require": {
+                "types": "./methods.d.cts",
+                "default": "./methods.cjs"
+            }
+        },
+        "./platform.js": {
+            "import": {
+                "types": "./platform.d.ts",
+                "default": "./platform.js"
+            },
+            "require": {
+                "types": "./platform.d.cts",
+                "default": "./platform.cjs"
+            }
+        }
     },
-    "./utils.js": {
-      "import": "./esm/utils/index.js",
-      "require": "./cjs/utils/index.js"
+    "scripts": {},
+    "dependencies": {
+        "@mtcute/file-id": "^0.16.9",
+        "@mtcute/tl": "^187.0.0",
+        "@mtcute/tl-runtime": "^0.16.9",
+        "@types/events": "3.0.0",
+        "events": "3.2.0",
+        "long": "5.2.3"
     },
-    "./client.js": {
-      "import": "./esm/highlevel/client.js",
-      "require": "./cjs/highlevel/client.js"
-    },
-    "./worker.js": {
-      "import": "./esm/highlevel/worker/index.js",
-      "require": "./cjs/highlevel/worker/index.js"
-    },
-    "./methods.js": {
-      "import": "./esm/highlevel/methods.js",
-      "require": "./cjs/highlevel/methods.js"
-    },
-    "./platform.js": {
-      "import": "./esm/platform.js",
-      "require": "./cjs/platform.js"
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mtcute/mtcute"
     }
-  },
-  "scripts": {},
-  "dependencies": {
-    "@mtcute/file-id": "^0.16.7",
-    "@mtcute/tl": "^186.0.0",
-    "@mtcute/tl-runtime": "^0.16.7",
-    "@types/events": "3.0.0",
-    "events": "3.2.0",
-    "long": "5.2.3"
-  },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "homepage": "https://mtcute.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mtcute/mtcute"
-  }
 }

package/platform.cjs

@@ -0,0 +1,11 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("@mtcute/tl-runtime");
+const platform = require("./chunks/cjs/j7rWn_1y.js");
+exports.getPlatform = platform.getPlatform;
+exports.setPlatform = platform.setPlatform;

package/platform.d.cts

@@ -0,0 +1,18 @@
+import { ITlPlatform } from '@mtcute/tl-runtime';
+import { UploadFileLike } from './highlevel/types/files/utils.js';
+import { MaybePromise } from './types/index.js';
+export interface ICorePlatform extends ITlPlatform {
+    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;
+}
+export declare function setPlatform(platform: ICorePlatform): void;
+export declare function getPlatform(): ICorePlatform;

package/platform.d.ts

@@ -1 +1,18 @@
-export * from './esm/platform.js'
+import { ITlPlatform } from '@mtcute/tl-runtime';
+import { UploadFileLike } from './highlevel/types/files/utils.js';
+import { MaybePromise } from './types/index.js';
+export interface ICorePlatform extends ITlPlatform {
+    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;
+}
+export declare function setPlatform(platform: ICorePlatform): void;
+export declare function getPlatform(): ICorePlatform;

package/platform.js

@@ -1 +1,6 @@
-export * from './esm/platform.js'
+import "@mtcute/tl-runtime";
+import { getPlatform, setPlatform } from "./chunks/es/DBMBgE7t.js";
+export {
+  getPlatform,
+  setPlatform
+};

package/storage/driver.d.ts

@@ -0,0 +1,56 @@
+import { MaybePromise } from '../types/utils.js';
+import { Logger } from '../utils/logger.js';
+/**
+ * Basic storage driver interface,
+ * describing the lifecycle of a storage driver
+ */
+export interface IStorageDriver {
+    /**
+     * Load session from some external storage.
+     * Should be used either to load data from file/network/etc
+     * to memory, or to open required connections to fetch data on demand
+     *
+     * May be called more than once, handle this with care
+     * (or use {@link BaseStorageDriver} that handles this for you)
+     */
+    load?: () => MaybePromise<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
+     *
+     * It is safe to batch all changes and only commit them here,
+     * unless stated otherwise in the method description
+     */
+    save?: () => MaybePromise<void>;
+    /**
+     * Cleanup session and release all used resources.
+     *
+     * May be called more than once, handle this with care
+     * (or use {@link BaseStorageDriver} that handles this for you)
+     */
+    destroy?: () => MaybePromise<void>;
+    /**
+     * Setup the driver, passing the logger instance,
+     * in case your driver needs it
+     */
+    setup?: (log: Logger) => void;
+}
+/**
+ * Base storage driver class, implementing {@link IStorageDriver}
+ * and handling the lifecycle for you
+ */
+export declare abstract class BaseStorageDriver implements IStorageDriver {
+    abstract _load(): MaybePromise<void>;
+    abstract _destroy(): MaybePromise<void>;
+    abstract _save?(): MaybePromise<void>;
+    private _loadedTimes;
+    private _destroyed;
+    protected _log: Logger;
+    setup(log: Logger): void;
+    protected get loaded(): boolean;
+    load(): Promise<void>;
+    destroy(): Promise<void>;
+    save(): MaybePromise<void>;
+}

package/storage/memory/driver.d.ts

@@ -0,0 +1,6 @@
+import { IStorageDriver } from '../driver.js';
+export declare class MemoryStorageDriver implements IStorageDriver {
+    readonly states: Map<string, object>;
+    getState<T extends object>(repo: string, def: () => T): T;
+    load(): void;
+}

package/storage/memory/index.d.ts

@@ -0,0 +1,22 @@
+import { ITelegramStorageProvider } from '../../highlevel/storage/provider.js';
+import { IMtStorageProvider } from '../provider.js';
+import { MemoryStorageDriver } from './driver.js';
+import { MemoryAuthKeysRepository } from './repository/auth-keys.js';
+import { MemoryKeyValueRepository } from './repository/kv.js';
+import { MemoryPeersRepository } from './repository/peers.js';
+import { MemoryRefMessagesRepository } from './repository/ref-messages.js';
+export { MemoryStorageDriver } from './driver.js';
+/**
+ * In-memory storage driver implementation for mtcute.
+ *
+ * This storage is **not persistent**, meaning that all data
+ * **will** be lost on restart. Only use this storage for testing,
+ * or if you know exactly what you're doing.
+ */
+export declare class MemoryStorage implements IMtStorageProvider, ITelegramStorageProvider {
+    readonly driver: MemoryStorageDriver;
+    readonly kv: MemoryKeyValueRepository;
+    readonly authKeys: MemoryAuthKeysRepository;
+    readonly peers: MemoryPeersRepository;
+    readonly refMessages: MemoryRefMessagesRepository;
+}

package/storage/memory/memory.test.d.ts

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

package/storage/memory/repository/auth-keys.d.ts

@@ -0,0 +1,19 @@
+import { IAuthKeysRepository } from '../../repository/auth-keys.js';
+import { MemoryStorageDriver } from '../driver.js';
+interface AuthKeysState {
+    authKeys: Map<number, Uint8Array>;
+    authKeysTemp: Map<string, Uint8Array>;
+    authKeysTempExpiry: Map<string, number>;
+}
+export declare class MemoryAuthKeysRepository implements IAuthKeysRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: AuthKeysState;
+    constructor(_driver: MemoryStorageDriver);
+    set(dc: number, key: Uint8Array | null): void;
+    get(dc: number): Uint8Array | null;
+    setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): void;
+    getTemp(dc: number, idx: number, now: number): Uint8Array | null;
+    deleteByDc(dc: number): void;
+    deleteAll(): void;
+}
+export {};

package/storage/memory/repository/kv.d.ts

@@ -0,0 +1,11 @@
+import { IKeyValueRepository } from '../../repository/key-value.js';
+import { MemoryStorageDriver } from '../driver.js';
+export declare class MemoryKeyValueRepository implements IKeyValueRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: Map<string, Uint8Array>;
+    constructor(_driver: MemoryStorageDriver);
+    set(key: string, value: Uint8Array): void;
+    get(key: string): Uint8Array | null;
+    delete(key: string): void;
+    deleteAll(): void;
+}

package/storage/memory/repository/peers.d.ts

@@ -0,0 +1,18 @@
+import { IPeersRepository } from '../../../highlevel/storage/repository/peers.js';
+import { MemoryStorageDriver } from '../driver.js';
+interface PeersState {
+    entities: Map<number, IPeersRepository.PeerInfo>;
+    usernameIndex: Map<string, number>;
+    phoneIndex: Map<string, number>;
+}
+export declare class MemoryPeersRepository implements IPeersRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: PeersState;
+    constructor(_driver: MemoryStorageDriver);
+    store(peer: IPeersRepository.PeerInfo): void;
+    getById(id: number): IPeersRepository.PeerInfo | null;
+    getByUsername(username: string): IPeersRepository.PeerInfo | null;
+    getByPhone(phone: string): IPeersRepository.PeerInfo | null;
+    deleteAll(): void;
+}
+export {};

package/storage/memory/repository/ref-messages.d.ts

@@ -0,0 +1,16 @@
+import { IReferenceMessagesRepository } from '../../../highlevel/storage/repository/ref-messages.js';
+import { MemoryStorageDriver } from '../driver.js';
+interface RefMessagesState {
+    refs: Map<number, Set<string>>;
+}
+export declare class MemoryRefMessagesRepository implements IReferenceMessagesRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: RefMessagesState;
+    constructor(_driver: MemoryStorageDriver);
+    store(peerId: number, chatId: number, msgId: number): void;
+    getByPeer(peerId: number): [number, number] | null;
+    delete(chatId: number, msgIds: number[]): void;
+    deleteByPeer(peerId: number): void;
+    deleteAll(): void;
+}
+export {};

package/storage/provider.d.ts

@@ -0,0 +1,10 @@
+import { IStorageDriver } from './driver.js';
+import { IAuthKeysRepository } from './repository/auth-keys.js';
+import { IKeyValueRepository } from './repository/key-value.js';
+export type IStorageProvider<T> = T & {
+    readonly driver: IStorageDriver;
+};
+export type IMtStorageProvider = IStorageProvider<{
+    readonly kv: IKeyValueRepository;
+    readonly authKeys: IAuthKeysRepository;
+}>;

package/storage/repository/auth-keys.d.ts

@@ -0,0 +1,41 @@
+import { MaybePromise } from '../../types/utils.js';
+export interface IAuthKeysRepository {
+    /**
+     * Store auth_key for the given DC
+     *
+     * If `key` is `null`, the key should be deleted instead
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    set: (dc: number, key: Uint8Array | null) => MaybePromise<void>;
+    /** Get auth_key for the given DC */
+    get: (dc: number) => MaybePromise<Uint8Array | null>;
+    /**
+     * Store temp_auth_key for the given DC and idx,
+     * along with its expiration date (in seconds)
+     *
+     * If `key` is `null`, the key should be deleted instead
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    setTemp: (dc: number, idx: number, key: Uint8Array | null, expires: number) => MaybePromise<void>;
+    /**
+     * Given the DC id, idx and point in time (in seconds),
+     * return the temp_auth_key that should be used for the next request
+     * (such that `now < key.expires`), or `null` if no such key exists
+     */
+    getTemp: (dc: number, idx: number, now: number) => MaybePromise<Uint8Array | null>;
+    /**
+     * Delete all stored auth keys for the given DC, including
+     * both permanent and temp keys
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    deleteByDc: (dc: number) => MaybePromise<void>;
+    /**
+     * Delete all stored auth keys, including both permanent and temp keys
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    deleteAll: () => MaybePromise<void>;
+}

package/storage/repository/key-value.d.ts

@@ -0,0 +1,10 @@
+import { MaybePromise } from '../../types/utils.js';
+export interface IKeyValueRepository {
+    /** Set a key-value pair */
+    set: (key: string, value: Uint8Array) => MaybePromise<void>;
+    /** Get a key-value pair */
+    get: (key: string) => MaybePromise<Uint8Array | null>;
+    /** Delete a key-value pair */
+    delete: (key: string) => MaybePromise<void>;
+    deleteAll: () => MaybePromise<void>;
+}

package/storage/service/auth-keys.d.ts

@@ -0,0 +1,9 @@
+import { IAuthKeysRepository } from '../repository/auth-keys.js';
+import { ServiceOptions, BaseService } from './base.js';
+import { FutureSaltsService } from './future-salts.js';
+export declare class AuthKeysService extends BaseService {
+    readonly _keys: IAuthKeysRepository;
+    readonly _salts: FutureSaltsService;
+    constructor(_keys: IAuthKeysRepository, _salts: FutureSaltsService, opts: ServiceOptions);
+    deleteByDc(dc: number): Promise<void>;
+}

package/storage/service/auth-keys.test.d.ts

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

package/storage/service/base.d.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

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

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

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

package/storage/sqlite/driver.d.ts

@@ -0,0 +1,24 @@
+import { BaseStorageDriver } from '../driver.js';
+import { ISqliteDatabase, ISqliteStatement } from './types.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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -0,0 +1,18 @@
+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;
+    getById(id: number): 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.ts

@@ -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;
+}