@datatruck/cli 0.34.3 → 0.34.5

package/lib/utils/data-format.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataFormat = exports.dataFormats = void 0;
-const error_1 = require("./datatruck/error");
+const error_1 = require("./error");
 const stream_1 = require("./stream");
 const tty_table_1 = __importDefault(require("tty-table"));
 const util_1 = require("util");
@@ -47,13 +47,13 @@ class DataFormat {
     }
     formatToTable() {
         if (!this.options.table)
-            throw new Error(`Unsupported format: table`);
+            throw new error_1.AppError(`Unsupported format: table`);
         const table = (0, tty_table_1.default)(this.options.table.headers, this.options.table.rows(), {});
         return table.render();
     }
     formatToList() {
         if (!this.options.list)
-            throw new Error(`Unsupported format: list`);
+            throw new error_1.AppError(`Unsupported format: list`);
         return this.options.list().join("\n");
     }
     log(format, options) {

package/lib/utils/datatruck/client.d.ts

@@ -2,10 +2,14 @@ import { DiskStats } from "../fs";
 import { BasicProgress } from "../progress";
 import { AbstractFs, FsOptions } from "../virtual-fs";
 export declare class RemoteFs extends AbstractFs {
-    readonly options: FsOptions;
+    readonly options: FsOptions & {
+        verbose?: boolean;
+    };
     protected url: string;
     protected headers: Record<string, string>;
-    constructor(options: FsOptions);
+    constructor(options: FsOptions & {
+        verbose?: boolean;
+    });
     isLocal(): boolean;
     protected fetchJson(name: string, params: any[]): Promise<any>;
     protected post(name: string, params: any[], data: string): Promise<void>;
@@ -28,4 +32,4 @@ export declare class RemoteFs extends AbstractFs {
     }>;
 }
 export declare function isRemoteBackend(backend: string): boolean;
-export declare function createFs(backend: string): AbstractFs;
+export declare function createFs(backend: string, verbose: boolean | undefined): AbstractFs;

package/lib/utils/datatruck/client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFs = exports.isRemoteBackend = exports.RemoteFs = void 0;
+const cli_1 = require("../cli");
 const http_1 = require("../http");
 const virtual_fs_1 = require("../virtual-fs");
 const repository_server_1 = require("./repository-server");
@@ -69,9 +70,13 @@ class RemoteFs extends virtual_fs_1.AbstractFs {
         await this.fetchJson("rmAll", [path]);
     }
     async fetchDiskStats(path) {
+        if (this.options.verbose)
+            (0, cli_1.logExec)("fs.fetchDiskStats", [path]);
         return await this.fetchJson("fetchDiskStats", [path]);
     }
     async upload(source, target) {
+        if (this.options.verbose)
+            (0, cli_1.logExec)("fs.upload", [source, target]);
         await (0, http_1.uploadFile)(`${this.url}/upload`, source, {
             headers: this.headers,
             query: {
@@ -80,6 +85,8 @@ class RemoteFs extends virtual_fs_1.AbstractFs {
         });
     }
     async download(source, target, options = {}) {
+        if (this.options.verbose)
+            (0, cli_1.logExec)("fs.download", [source, target]);
         return await (0, http_1.downloadFile)(`${this.url}/download`, target, {
             ...options,
             headers: this.headers,
@@ -92,9 +99,9 @@ function isRemoteBackend(backend) {
     return backend.startsWith("http:") || backend.startsWith("https:");
 }
 exports.isRemoteBackend = isRemoteBackend;
-function createFs(backend) {
+function createFs(backend, verbose) {
     return isRemoteBackend(backend)
-        ? new RemoteFs({ backend })
+        ? new RemoteFs({ backend, verbose })
         : new virtual_fs_1.LocalFs({ backend });
 }
 exports.createFs = createFs;

package/lib/utils/datatruck/command.js

@@ -10,7 +10,7 @@ const PruneCommand_1 = require("../../commands/PruneCommand");
 const RestoreCommand_1 = require("../../commands/RestoreCommand");
 const SnapshotsCommand_1 = require("../../commands/SnapshotsCommand");
 const StartServerCommand_1 = require("../../commands/StartServerCommand");
-const error_1 = require("./error");
+const error_1 = require("../error");
 const stream_1 = require("stream");
 exports.datatruckCommandMap = {
     config: ConfigCommand_1.ConfigCommand,

package/lib/utils/datatruck/config.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepositoryByEnabled = exports.ensureSameRepositoryType = exports.sortReposByType = exports.filterRepository = exports.findPackageRepositoryConfig = exports.findPackageOrFail = exports.findRepositoryOrFail = void 0;
+const error_1 = require("../error");
 const string_1 = require("../string");
 const temp_1 = require("../temp");
-const error_1 = require("./error");
 const micromatch_1 = require("micromatch");
 function findRepositoryOrFail(config, repositoryName) {
     const repo = config.repositories.find((v) => v.name === repositoryName);
     if (!repo)
-        throw new error_1.AppError(`Repository '${repositoryName}' not found`);
+        throw new error_1.AppError(`Repository '${repositoryName}' not found in the config`);
     return repo;
 }
 exports.findRepositoryOrFail = findRepositoryOrFail;
 function findPackageOrFail(config, packageName) {
     const pkg = config.packages.find((v) => v.name === packageName);
     if (!pkg)
-        throw new error_1.AppError(`Package '${packageName}' not found`);
+        throw new error_1.AppError(`Package '${packageName}' not found in the config`);
     return pkg;
 }
 exports.findPackageOrFail = findPackageOrFail;
@@ -59,7 +59,7 @@ function ensureSameRepositoryType(a, b) {
     if (a.type !== b.type) {
         const names = [a.name, b.name].join(" and ");
         const types = [a.type, b.type].join(" != ");
-        throw new Error(`Incompatible repository types between ${names} (${types})`);
+        throw new error_1.AppError(`Incompatible repository types between ${names} (${types})`);
     }
 }
 exports.ensureSameRepositoryType = ensureSameRepositoryType;

package/lib/utils/datatruck/report-list.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReportListTasks = void 0;
+const error_1 = require("../error");
 const reportSteps_1 = require("../reportSteps");
 const spawnSteps_1 = require("../spawnSteps");
 function createReportListTasks(list, options) {
@@ -48,7 +49,7 @@ function createReportListTasks(list, options) {
                     });
                 }
                 else {
-                    throw new Error(`Invalid step type: ${report.run.type}`);
+                    throw new error_1.AppError(`Invalid step type: ${report.run.type}`);
                 }
             },
         });

package/lib/utils/datatruck/repository.d.ts

@@ -9,8 +9,8 @@ declare const repoMap: {
     datatruck: typeof DatatruckRepository;
 };
 export declare function getRepoConstructor(type: keyof typeof repoMap): {
-    new (config: RepositoryConfig): RepositoryAbstract<any>;
+    new (config: RepositoryConfig, verbose?: boolean): RepositoryAbstract<any>;
 };
-export declare function createRepo(repository: RepositoryConfig): RepositoryAbstract<any>;
-export declare function createAndInitRepo(repository: RepositoryConfig, verbose?: boolean): Promise<RepositoryAbstract<any>>;
+export declare function createRepo(repository: RepositoryConfig, verbose: boolean | undefined): RepositoryAbstract<any>;
+export declare function createAndInitRepo(repository: RepositoryConfig, verbose: boolean | undefined): Promise<RepositoryAbstract<any>>;
 export {};

package/lib/utils/datatruck/repository.js

@@ -4,7 +4,7 @@ exports.createAndInitRepo = exports.createRepo = exports.getRepoConstructor = vo
 const DatatruckRepository_1 = require("../../repositories/DatatruckRepository");
 const GitRepository_1 = require("../../repositories/GitRepository");
 const ResticRepository_1 = require("../../repositories/ResticRepository");
-const error_1 = require("./error");
+const error_1 = require("../error");
 const repoMap = {
     [GitRepository_1.gitRepositoryName]: GitRepository_1.GitRepository,
     [ResticRepository_1.resticRepositoryName]: ResticRepository_1.ResticRepository,
@@ -17,13 +17,13 @@ function getRepoConstructor(type) {
     return Constructor;
 }
 exports.getRepoConstructor = getRepoConstructor;
-function createRepo(repository) {
+function createRepo(repository, verbose) {
     const Constructor = getRepoConstructor(repository.type);
-    return new Constructor(repository);
+    return new Constructor(repository, verbose);
 }
 exports.createRepo = createRepo;
 async function createAndInitRepo(repository, verbose) {
-    const repo = createRepo(repository);
+    const repo = createRepo(repository, verbose);
     await repo.init({ options: { verbose } });
     return repo;
 }

package/lib/utils/datatruck/task.js

@@ -7,7 +7,7 @@ const MssqlTask_1 = require("../../tasks/MssqlTask");
 const MysqlDumpTask_1 = require("../../tasks/MysqlDumpTask");
 const PostgresqlDumpTask_1 = require("../../tasks/PostgresqlDumpTask");
 const ScriptTask_1 = require("../../tasks/ScriptTask");
-const error_1 = require("./error");
+const error_1 = require("../error");
 function createTask(task) {
     if (task.name === GitTask_1.gitTaskName) {
         return new GitTask_1.GitTask(task.config ?? {});

package/lib/utils/{datatruck/error.d.ts → error.d.ts}

@@ -1,4 +1,4 @@
 export declare class AppError extends Error {
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
     static create(message: string, errors: Error[]): Error;
 }

package/lib/utils/{datatruck/error.js → error.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppError = void 0;
 class AppError extends Error {
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
         this.name = AppError.name;
     }
     static create(message, errors) {

package/lib/utils/fs.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Progress } from "./progress";
+import { Progress, ProgressStats } from "./progress";
 import { Entry, Options } from "fast-glob";
 import { Stats } from "fs";
 import { WriteStream } from "fs";
@@ -90,6 +90,7 @@ type ProgressObject = {
     total: number;
     current: number;
     update: (description: string, path?: string, increment?: boolean) => void;
+    updateRelative: (description: string, path: string, stats: ProgressStats) => void;
 };
 export declare function createProgress(options: {
     onProgress: (data: Progress) => void;

package/lib/utils/fs.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.asFile = exports.groupFiles = exports.ensureFreeDiskSpace = exports.checkFreeDiskSpace = exports.fetchDiskStats = exports.initEmptyDir = exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.readTextFile = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.fastFolderSizeAsync = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.include = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureExistsDir = exports.ensureSingleFile = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
 const pkg_1 = require("../pkg");
 const bytes_1 = require("./bytes");
+const error_1 = require("./error");
 const math_1 = require("./math");
 const stream_1 = require("./stream");
 const string_1 = require("./string");
@@ -53,20 +54,20 @@ async function mkdirIfNotExists(path) {
 exports.mkdirIfNotExists = mkdirIfNotExists;
 async function ensureEmptyDir(path) {
     if (!(await isEmptyDir(path)))
-        throw new Error(`Dir is not empty: ${path}`);
+        throw new error_1.AppError(`Dir is not empty: ${path}`);
 }
 exports.ensureEmptyDir = ensureEmptyDir;
 async function ensureSingleFile(path) {
     const files = await readDir(path);
     if (files.length !== 1)
-        throw new Error(`Dir has not one file: ${files.length}`);
+        throw new error_1.AppError(`Dir has not one file: ${files.length}`);
     const [file] = files;
     return (0, path_1.join)(path, file);
 }
 exports.ensureSingleFile = ensureSingleFile;
 async function ensureExistsDir(path) {
     if (!(await existsDir(path)))
-        throw new Error(`Dir is not created: ${path}`);
+        throw new error_1.AppError(`Dir is not created: ${path}`);
 }
 exports.ensureExistsDir = ensureExistsDir;
 async function safeStat(path) {
@@ -399,11 +400,29 @@ function createProgress(options) {
         disposed: false,
         total: 0,
         current: 0,
+        updateRelative(description, path, stats) {
+            if (progress.disposed)
+                return;
+            options.onProgress({
+                relative: {
+                    ...stats,
+                    description,
+                    payload: path,
+                },
+                absolute: {
+                    total: progress.total,
+                    current: progress.current,
+                    percent: (0, math_1.progressPercent)(progress.total, progress.current),
+                },
+            });
+        },
         update: (description, path, increment = true) => {
             if (progress.disposed)
                 return;
             if (path && increment)
                 progress.current++;
+            if (path === "." || path === "./")
+                return;
             options.onProgress({
                 relative: {
                     description,

package/lib/utils/git.d.ts

@@ -28,6 +28,11 @@ export declare class Git {
     removeAll(): Promise<void>;
     haveChanges(): Promise<boolean>;
     fetchCommitId(tag: string): Promise<string>;
+    commit(description: string, options?: {
+        allowEmpty?: boolean;
+        userName?: string;
+        userEmail?: string;
+    }): Promise<void>;
     getTags(names?: string[]): Promise<{
         name: string;
         message?: string | undefined;

package/lib/utils/git.js

@@ -70,6 +70,16 @@ class Git {
     async fetchCommitId(tag) {
         return (await this.stdout(["rev-list", "-n", "1", tag])).trim();
     }
+    async commit(description, options = {}) {
+        await this.exec([
+            ...(options.userName ? ["-c", `user.name='${options.userName}'`] : []),
+            ...(options.userEmail ? ["-c", `user.email='${options.userEmail}'`] : []),
+            "commit",
+            "-m",
+            description,
+            ...(options.allowEmpty ? ["--allow-empty"] : []),
+        ]);
+    }
     async getTags(names) {
         const stdout = await this.stdout(["tag", "-n", ...(names ?? [])]);
         return stdout.split(/\r?\n/).reduce((result, value) => {

package/lib/utils/list.d.ts

@@ -1,6 +1,7 @@
 import { Timer } from "./date";
 import { ProgressManager } from "./progress";
 import { StdStreams } from "./stream";
+import { GargabeCollector } from "./temp";
 import { Listr, ListrGetRendererClassFromValue, ListrLogger, ListrTask, ListrTaskWrapper } from "listr2";
 export declare class List3Logger<Levels extends string = string> extends ListrLogger<Levels> {
     constructor(options?: {
@@ -19,7 +20,6 @@ type Listr3Task<T extends Listr3Context, K extends keyof T> = {
         failed?: string;
         completed?: string;
     };
-    runWrapper?: (cb: () => any) => any;
     run: (task: ListrTaskWrapper<any, any, any>, data: T[K]) => Promise<void | ListrTask[] | Listr | undefined> | void | undefined | ListrTask[] | Listr;
     exitOnError?: boolean;
     enabled?: boolean;
@@ -43,6 +43,7 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     readonly $options: {
         streams?: StdStreams;
         progressManager?: ProgressManager;
+        gargabeCollector?: GargabeCollector;
     };
     readonly resultMap: Record<string, Listr3TaskResult<T>>;
     readonly resultList: Listr3TaskResult<T>[];
@@ -51,6 +52,7 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     constructor($options: {
         streams?: StdStreams;
         progressManager?: ProgressManager;
+        gargabeCollector?: GargabeCollector;
     });
     private serializeKeyIndex;
     private createResultIndex;

package/lib/utils/list.js

@@ -89,9 +89,7 @@ class Listr3 extends listr2_1.Listr {
                 const timer = (0, date_1.createTimer)();
                 if (title)
                     try {
-                        const runResult = item.runWrapper
-                            ? await item.runWrapper(async () => await item.run(task, result.data))
-                            : await item.run(task, result.data);
+                        const runResult = await item.run(task, result.data);
                         if (title.completed)
                             task.title = title.completed;
                         return Array.isArray(runResult)
@@ -153,6 +151,7 @@ class Listr3 extends listr2_1.Listr {
             throw error;
         }
         finally {
+            await this.$options.gargabeCollector?.dispose();
             dispose();
         }
     }

package/lib/utils/mysql.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMysqlCli = exports.assertDumpFile = void 0;
 const async_process_1 = require("./async-process");
 const cli_1 = require("./cli");
-const error_1 = require("./datatruck/error");
+const error_1 = require("./error");
 const fs_1 = require("./fs");
 const process_1 = require("./process");
 const string_1 = require("./string");

package/lib/utils/object.d.ts

@@ -11,7 +11,7 @@ export declare class StrictMap<K, V> {
     has(key: K): boolean;
     get(key: K): NonNullable<V>;
     set(key: K, value: V): void;
-    with(key: K): {
+    withKey(key: K): {
         has: () => boolean;
         get: () => NonNullable<V>;
         set: (value: V) => void;

package/lib/utils/object.js

@@ -78,7 +78,7 @@ class StrictMap {
             throw new Error(`Map key already exists: ${stringKey}`);
         this.map.set(stringKey, value);
     }
-    with(key) {
+    withKey(key) {
         return {
             has: () => this.has(key),
             get: () => this.get(key),

package/lib/utils/progress.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Timer } from "./date";
 export type BasicProgress = {
     percent: number;
@@ -35,6 +36,7 @@ export declare class ProgressManager {
     protected interval: Timer | undefined;
     protected intervalMs: number;
     protected keydownListener: ((data: Buffer | undefined) => void) | undefined;
+    protected pendingProgress: Progress | undefined;
     readonly tty: Exclude<ProgressTty, "auto">;
     readonly mode: Exclude<ProgressMode, "auto" | `interval:${number}`>;
     constructor(options: {
@@ -51,7 +53,12 @@ export declare class ProgressManager {
     elapsed(): number;
     start(): void;
     dispose(): void;
-    update(progress: Progress, cb: (text: string) => void): void;
+    create(input: ((text: string) => void) | {
+        output: string;
+    }, delay?: number): Disposable & {
+        update: (progress: Progress) => void;
+    };
+    renderProgress(progress: Progress, force?: boolean): string | undefined;
 }
 export declare function renderProgress(progress: Progress, bar?: boolean): string[];
 export declare function renderProgressStats(stats: ProgressStats, progressBar?: boolean): string;

package/lib/utils/progress.js

@@ -13,6 +13,7 @@ class ProgressManager {
     interval = (0, date_1.createTimer)();
     intervalMs;
     keydownListener;
+    pendingProgress;
     tty;
     mode;
     constructor(options) {
@@ -66,19 +67,51 @@ class ProgressManager {
             this.keydownListener = undefined;
         }
     }
-    update(progress, cb) {
-        if (!this.mode)
+    create(input, delay = 1000) {
+        const update = (progress, force) => {
+            const text = this.renderProgress(progress, force);
+            if (typeof text === "string") {
+                if (typeof input === "function") {
+                    input(text);
+                }
+                else {
+                    input.output = text;
+                }
+            }
+        };
+        const updatePending = () => {
+            const pendingProgress = this.pendingProgress;
+            if (pendingProgress) {
+                this.pendingProgress = undefined;
+                update(pendingProgress, true);
+            }
+        };
+        const interval = setInterval(updatePending, delay);
+        return {
+            update,
+            [Symbol.dispose]: () => {
+                clearInterval(interval);
+                updatePending();
+            },
+        };
+    }
+    renderProgress(progress, force = false) {
+        if (!this.mode) {
             return;
-        if (this.mode === "interval") {
+        }
+        else if (this.mode === "interval") {
             if (this.interval) {
-                if (!this.interval.reset(this.intervalMs))
+                if (!this.interval.reset(this.intervalMs) && !force) {
+                    this.pendingProgress = progress;
                     return;
+                }
             }
             else {
                 this.interval = (0, date_1.createTimer)();
             }
         }
-        cb(renderProgress(progress, this.tty).join("\n"));
+        this.pendingProgress = undefined;
+        return renderProgress(progress, this.tty).join("\n");
     }
 }
 exports.ProgressManager = ProgressManager;

package/lib/utils/reportSteps.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runReportSteps = exports.isReportStep = void 0;
+const error_1 = require("./error");
 const http_1 = require("./http");
 function isReportStep(step) {
     return step.type === "telegram" || step.type === "ntfy";
@@ -25,7 +26,7 @@ async function runReportSteps(input, options) {
                 .filter(Boolean)
                 .join("-");
             if (topic.length < 32)
-                throw new Error(`Topic is less than 32 characters: ${topic}`);
+                throw new error_1.AppError(`'step.config.topic' is less than 32 characters: ${topic}`);
             await (0, http_1.post)(`https://ntfy.sh/${topic}`, options.data.message, {
                 headers: {
                     Title: options.data.title,
@@ -34,7 +35,7 @@ async function runReportSteps(input, options) {
             });
         }
         else {
-            throw new Error(`Invalid step type: ${step.type}`);
+            throw new error_1.AppError(`Invalid step type: ${step.type}`);
         }
     }
 }

package/lib/utils/string.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareJsons = exports.undefIfEmpty = exports.checkMatch = exports.createMatchFilter = exports.endsWith = exports.match = exports.makePathPatterns = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = void 0;
-const error_1 = require("./datatruck/error");
+const error_1 = require("./error");
 const micromatch_1 = require("micromatch");
 function snakeCase(value, char = "_") {
     return value.replace(/[A-Z]/g, (letter) => `${char}${letter.toLowerCase()}`);

package/lib/utils/temp.d.ts

@@ -5,6 +5,7 @@ export declare function ensureFreeDiskTempSpace(size: number | string): Promise<
 export declare function isTmpDir(path: string): boolean;
 export declare function rmTmpDir(input: string | string[]): Promise<void>;
 export declare function tmpDir(...keys: [string, ...string[]]): string;
+export declare const collectors: Set<GargabeCollector>;
 export declare function mkTmpDir(...keys: [string, ...string[]]): Promise<string>;
 export declare function useTempDir(...keys: [string, ...string[]]): Promise<AsyncDisposable & {
     path: string;
@@ -12,15 +13,17 @@ export declare function useTempDir(...keys: [string, ...string[]]): Promise<Asyn
 export declare function useTempFile(path: string): AsyncDisposable & {
     path: string;
 };
-export declare class CleanupListener {
-    readonly paths: string[];
-    stop(): void;
-    dispose(): Promise<void>;
-}
 export declare class GargabeCollector {
-    protected listeners: Set<CleanupListener>;
-    get pending(): boolean;
-    cleanup(cb?: () => any): Promise<void>;
-    cleanupOnFinish(cb: () => any): Promise<void>;
-    cleanupIfFail(cb: () => any): Promise<CleanupListener>;
+    protected parent?: GargabeCollector | undefined;
+    readonly paths: Set<string>;
+    readonly children: Set<GargabeCollector>;
+    constructor(parent?: GargabeCollector | undefined);
+    pending(): boolean;
+    cleanup(): Promise<void>;
+    dispose(): Promise<void>;
+    disposeIfFail<T>(cb: () => Promise<T>): Promise<T>;
+    disposeOnFinish(): {
+        [Symbol.asyncDispose]: () => Promise<void>;
+    };
+    create(): GargabeCollector;
 }