@datatruck/cli 0.26.2 → 0.28.0

package/utils/date.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChron = exports.filterByLast = void 0;
-const string_1 = require("./string");
+exports.duration = exports.createTimer = exports.filterByLast = void 0;
 const dayjs_1 = __importDefault(require("dayjs"));
 const advancedFormat_1 = __importDefault(require("dayjs/plugin/advancedFormat"));
+const duration_1 = __importDefault(require("dayjs/plugin/duration"));
 const isoWeek_1 = __importDefault(require("dayjs/plugin/isoWeek"));
 dayjs_1.default.extend(isoWeek_1.default);
 dayjs_1.default.extend(advancedFormat_1.default);
+dayjs_1.default.extend(duration_1.default);
 function filterByLast(items, options, reasons) {
     const filters = {
         last: { handler: (_, i) => i.toString(), value: options.last },
@@ -73,18 +74,25 @@ function filterByLast(items, options, reasons) {
     return items.filter((item) => validItems.includes(item));
 }
 exports.filterByLast = filterByLast;
-function createChron() {
-    let startTime;
-    return {
-        start: () => (startTime = Date.now()),
-        elapsed: (formatted) => {
-            if (!startTime)
-                throw new Error(`Chron was not started`);
-            const seconds = (Date.now() - startTime) / 1000;
-            if (formatted)
-                return (0, string_1.formatSeconds)(seconds);
-            return seconds;
+function createTimer() {
+    let startTime = Date.now();
+    let endTime;
+    const timer = {
+        elapsed: () => (endTime || Date.now()) - startTime,
+        check: (ms) => timer.elapsed() > ms,
+        stop: () => (endTime = Date.now()),
+        reset: (min) => {
+            if (typeof min === "number" && !timer.check(min))
+                return false;
+            startTime = Date.now();
+            endTime = undefined;
+            return true;
         },
     };
+    return timer;
 }
-exports.createChron = createChron;
+exports.createTimer = createTimer;
+function duration(ms) {
+    return dayjs_1.default.duration(ms, "ms").format("HH:mm:ss");
+}
+exports.duration = duration;

package/utils/fs.d.ts

@@ -11,6 +11,8 @@ export declare function isEmptyDir(path: string): Promise<boolean>;
 export declare function isLocalDir(path: string): boolean;
 export declare function mkdirIfNotExists(path: string): Promise<string>;
 export declare function ensureEmptyDir(path: string): Promise<void>;
+export declare function ensureSingleFile(path: string): Promise<string>;
+export declare function ensureExistsDir(path: string): Promise<void>;
 export declare function safeStat(path: string): Promise<Stats | undefined>;
 export declare function existsDir(path: string): Promise<boolean>;
 export declare function existsFile(path: string): Promise<boolean>;
@@ -23,13 +25,7 @@ export declare function parsePackageFile(): {
     description: string;
 };
 export declare function findFile(sourcePath: string, baseName: string, extensions: string[], errorMessage?: string): Promise<string>;
-export declare function parentTmpDir(): string;
-export declare function sessionTmpDir(): string;
-export declare function isTmpDir(path: string): boolean;
-export declare function rmTmpDir(input: string | string[]): Promise<void>;
-export declare function tmpDir(prefix: string, id?: string): string;
 export declare function fastFolderSizeAsync(path: string): Promise<number>;
-export declare function mkTmpDir(prefix: string, id?: string): Promise<string>;
 export declare function readPartialFile(path: string, positions: [number, number?]): Promise<string>;
 export declare function readDir(path: string, optional?: boolean): Promise<string[]>;
 export declare function forEachFile(dirPath: string, cb: (path: string, dir: boolean) => void, includeDir?: boolean): Promise<void>;
@@ -60,7 +56,7 @@ export declare function cpy(options: {
         path: string;
         basePath: string;
     };
-    targetPath: string;
+    outPath: string;
     /**
      * @default 1
      */
@@ -87,18 +83,24 @@ export declare function cpy(options: {
     files: number;
     dirs: number;
 }>;
+type ProgressObject = {
+    disposed: boolean;
+    total: number;
+    current: number;
+    update: (description: string, path?: string, increment?: boolean) => void;
+};
+export declare function createProgress(options: {
+    onProgress: (data: Progress) => void;
+}): ProgressObject;
 export declare function createFileScanner(options: {
     glob: Options & {
         include: string[];
     };
-    onProgress: (data: Progress) => Promise<void>;
-}): Promise<{
-    disposed: boolean;
-    total: number;
-    current: number;
-    progress: (description: string, path?: string, increment?: boolean) => Promise<void>;
-    end: () => Promise<void>;
-    start: (cb?: ((entry: Required<Entry>) => any) | undefined) => Promise<void>;
+    onProgress: (data: Progress) => void;
+}): Promise<ProgressObject & {
+    progress: ProgressObject["update"];
+    start: (cb?: (entry: Required<Entry>) => any) => Promise<void>;
+    end: () => void;
 }>;
 type StreamItem = {
     key: string;
@@ -121,4 +123,14 @@ export declare function createWriteStreamPool(options: {
 export declare function countFileLines(path: string): Promise<number>;
 export declare function fetchData<T>(input: T, onPath?: (input: Exclude<T, string>) => string | undefined): Promise<string | null>;
 export declare function safeRename(oldPath: string, newPath: string): Promise<void>;
+export declare function tryRm(path: string): Promise<void>;
+export declare function initEmptyDir(path: string | undefined): Promise<string>;
+export type DiskStats = {
+    total: number;
+    free: number;
+};
+export declare function fetchDiskStats(path: string): Promise<DiskStats>;
+export declare function checkFreeDiskSpace(stat: DiskStats, inSize: string | number): Promise<void>;
+export declare function ensureFreeDiskSpace(input: string[] | DiskStats, inSize: number | string): Promise<void>;
+export declare function groupFiles(inFiles: string[], suffixes?: string[], gzSuffix?: string): [string[], Record<string, string>];
 export {};

package/utils/fs.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.rmTmpDir = exports.isTmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
-const globalData_1 = __importDefault(require("../globalData"));
+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.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.fastFolderSizeAsync = exports.findFile = exports.parsePackageFile = exports.parseFile = 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 math_1 = require("./math");
 const path_1 = require("./path");
+const string_1 = require("./string");
 const async_1 = require("async");
-const crypto_1 = require("crypto");
+const bytes_1 = __importDefault(require("bytes"));
 const fast_folder_size_1 = __importDefault(require("fast-folder-size"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_1 = require("fs");
@@ -53,6 +53,19 @@ async function ensureEmptyDir(path) {
         throw new Error(`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}`);
+    const [file] = files;
+    return (0, path_2.join)(path, file);
+}
+exports.ensureSingleFile = ensureSingleFile;
+async function ensureExistsDir(path) {
+    if (!(await existsDir(path)))
+        throw new Error(`Dir is not crated: ${path}`);
+}
+exports.ensureExistsDir = ensureExistsDir;
 async function safeStat(path) {
     try {
         return await (0, promises_1.stat)(path);
@@ -116,48 +129,10 @@ async function findFile(sourcePath, baseName, extensions, errorMessage = "Path n
     return path;
 }
 exports.findFile = findFile;
-function parentTmpDir() {
-    return (0, path_2.join)(globalData_1.default.tempDir, "datatruck-temp");
-}
-exports.parentTmpDir = parentTmpDir;
-function sessionTmpDir() {
-    return (0, path_2.join)(parentTmpDir(), process.pid.toString());
-}
-exports.sessionTmpDir = sessionTmpDir;
-function isTmpDir(path) {
-    return path.startsWith(sessionTmpDir()) && path.includes("datatruck-temp");
-}
-exports.isTmpDir = isTmpDir;
-async function rmTmpDir(input) {
-    if (typeof input === "string") {
-        if (!isTmpDir(input))
-            throw new Error(`Path is not a temp dir: ${input}`);
-        await (0, promises_1.rm)(input, {
-            recursive: true,
-        });
-    }
-    else {
-        for (const path of input)
-            await rmTmpDir(path);
-    }
-}
-exports.rmTmpDir = rmTmpDir;
-function tmpDir(prefix, id) {
-    if (!id)
-        id = (0, crypto_1.randomUUID)().slice(0, 8);
-    return (0, path_2.join)(sessionTmpDir(), `${prefix}-${id}`);
-}
-exports.tmpDir = tmpDir;
 async function fastFolderSizeAsync(path) {
     return (await (0, util_1.promisify)(fast_folder_size_1.default)(path)) || 0;
 }
 exports.fastFolderSizeAsync = fastFolderSizeAsync;
-async function mkTmpDir(prefix, id) {
-    const path = tmpDir(prefix, id);
-    await (0, promises_1.mkdir)(path, { recursive: true });
-    return path;
-}
-exports.mkTmpDir = mkTmpDir;
 async function readPartialFile(path, positions) {
     let result = "";
     const statResult = await (0, promises_1.stat)(path);
@@ -316,7 +291,7 @@ async function cpy(options) {
         const isDir = rawEntryPath.endsWith("/");
         const entryPath = (0, path_2.normalize)(rawEntryPath);
         const entrySourcePath = (0, path_2.resolve)((0, path_2.join)(basePath, rawEntryPath));
-        const entryTargetPath = (0, path_2.resolve)((0, path_2.join)(options.targetPath, rawEntryPath));
+        const entryTargetPath = (0, path_2.resolve)((0, path_2.join)(options.outPath, rawEntryPath));
         const onPathResult = await options?.onPath?.({
             isDir,
             entryPath,
@@ -404,57 +379,65 @@ async function cpy(options) {
     return stats;
 }
 exports.cpy = cpy;
-async function createFileScanner(options) {
-    const object = {
+function createProgress(options) {
+    const progress = {
         disposed: false,
         total: 0,
         current: 0,
-        progress: async (description, path, increment = true) => {
-            if (object.disposed)
+        update: async (description, path, increment = true) => {
+            if (progress.disposed)
                 return;
             if (path && increment)
-                object.current++;
-            await options.onProgress({
+                progress.current++;
+            options.onProgress({
                 relative: {
                     description,
                     payload: path,
                 },
                 absolute: {
-                    total: object.total,
-                    current: object.current,
-                    percent: (0, math_1.progressPercent)(object.total, object.current),
+                    total: progress.total,
+                    current: progress.current,
+                    percent: (0, math_1.progressPercent)(progress.total, progress.current),
                 },
             });
         },
-        end: async () => {
-            if (!object.disposed)
-                await object.progress("Finished");
-            object.disposed = true;
+    };
+    return progress;
+}
+exports.createProgress = createProgress;
+async function createFileScanner(options) {
+    const progress = createProgress(options);
+    Object.assign(progress, {
+        progress: progress.update,
+        end: () => {
+            if (!progress.disposed)
+                progress.update("Finished");
+            progress.disposed = true;
         },
         start: async (cb) => {
             let lastTime = performance.now();
-            await object.progress("Scanning files");
+            progress.update("Scanning files");
             for await (const entry of pathIterator(stream)) {
                 if (cb) {
                     if (await cb(entry))
-                        object.total++;
+                        progress.total++;
                 }
                 else {
-                    object.total++;
+                    progress.total++;
                 }
                 if (lastTime - performance.now() > 500)
-                    await object.progress("Scanning files");
+                    progress.update("Scanning files");
             }
-            await object.progress("Scanned files");
+            progress.update("Scanned files");
         },
-    };
+    });
     const stream = fast_glob_1.default.stream(options.glob.include, {
         dot: true,
         markDirectories: true,
         stats: true,
         ...options.glob,
     });
-    return object;
+    return progress;
 }
 exports.createFileScanner = createFileScanner;
 function createWriteStreamPool(options) {
@@ -560,3 +543,68 @@ async function safeRename(oldPath, newPath) {
     }
 }
 exports.safeRename = safeRename;
+async function tryRm(path) {
+    try {
+        await (0, promises_1.rm)(path);
+    }
+    catch (_) { }
+}
+exports.tryRm = tryRm;
+async function initEmptyDir(path) {
+    if (!path)
+        throw new Error(`Path is not defined`);
+    await mkdirIfNotExists(path);
+    await ensureEmptyDir(path);
+    return path;
+}
+exports.initEmptyDir = initEmptyDir;
+async function fetchDiskStats(path) {
+    const fs = await (0, promises_1.statfs)(path);
+    const total = fs.bsize * fs.blocks;
+    const free = fs.bsize * fs.bavail;
+    return { total, free };
+}
+exports.fetchDiskStats = fetchDiskStats;
+async function checkFreeDiskSpace(stat, inSize) {
+    const humanSize = typeof inSize === "number" ? (0, bytes_1.default)(inSize) : inSize;
+    const size = bytes_1.default.parse(inSize);
+    if (stat.free < size)
+        throw new Error(`Free disk space is less than ${humanSize}: ${(0, bytes_1.default)(stat.free)}/${(0, bytes_1.default)(stat.total)}`);
+}
+exports.checkFreeDiskSpace = checkFreeDiskSpace;
+async function ensureFreeDiskSpace(input, inSize) {
+    if (Array.isArray(input)) {
+        for (const path of input) {
+            const stat = await fetchDiskStats(path);
+            await checkFreeDiskSpace(stat, inSize);
+        }
+    }
+    else {
+        await checkFreeDiskSpace(input, inSize);
+    }
+}
+exports.ensureFreeDiskSpace = ensureFreeDiskSpace;
+function groupFiles(inFiles, suffixes, gzSuffix = ".tar.gz") {
+    const compressed = {};
+    if (suffixes) {
+        const validGzSuffixes = suffixes.map((f) => `${f}${gzSuffix}`);
+        inFiles = inFiles.filter((f) => (0, string_1.endsWith)(f, suffixes) || (0, string_1.endsWith)(f, validGzSuffixes));
+    }
+    const grouped = inFiles.reduce((items, name) => {
+        const key = name.endsWith(gzSuffix)
+            ? name.slice(0, -gzSuffix.length)
+            : name;
+        if (!items[key])
+            items[key] = [];
+        items[key].push(name);
+        return items;
+    }, {});
+    for (const key in grouped) {
+        const suffixFile = grouped[key].find((v) => v.endsWith(gzSuffix));
+        if (suffixFile) {
+            compressed[key] = suffixFile;
+        }
+    }
+    return [Object.keys(grouped), compressed];
+}
+exports.groupFiles = groupFiles;

package/utils/http.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { IncomingMessage, Server } from "http";
+export declare function closeServer(server: Server): Promise<void>;
+export declare function readRequestData(req: IncomingMessage): Promise<string | undefined>;
+export declare function fetchJson<T = any>(url: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}): Promise<T>;
+export declare function post(url: string, data: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}): Promise<void>;
+export declare function downloadFile(url: string, output: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    timeout?: number;
+}): Promise<void>;
+export declare function uploadFile(url: string, path: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}): Promise<void>;

package/utils/http.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFile = exports.downloadFile = exports.post = exports.fetchJson = exports.readRequestData = exports.closeServer = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const http_1 = require("http");
+const https_1 = require("https");
+const request = (url, options, callback) => {
+    return url.startsWith("https://")
+        ? (0, https_1.request)(url, options, callback)
+        : (0, http_1.request)(url, options, callback);
+};
+function href(inUrl, query) {
+    const url = new URL(inUrl);
+    for (const key in query || {})
+        url.searchParams.set(key, query[key]);
+    return url.href;
+}
+async function closeServer(server) {
+    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+}
+exports.closeServer = closeServer;
+function readRequestData(req) {
+    let data;
+    return new Promise((resolve, reject) => {
+        req
+            .on("error", reject)
+            .on("data", (chunk) => {
+            if (data === undefined)
+                data = "";
+            data += chunk;
+        })
+            .on("close", async () => {
+            resolve(data);
+        });
+    });
+}
+exports.readRequestData = readRequestData;
+async function fetchJson(url, options = {}) {
+    return new Promise((resolve, reject) => {
+        let data;
+        request(href(url, options.query), {
+            method: "GET",
+            headers: options.headers,
+        }, (res) => {
+            if (res.statusCode !== 200)
+                return reject(new Error(`GET failed: ${res.statusCode} ${res.statusMessage}`));
+            res
+                .on("data", (chunk) => {
+                if (data === undefined)
+                    data = "";
+                data += chunk;
+            })
+                .on("error", reject)
+                .on("close", () => {
+                if (data === undefined) {
+                    resolve(undefined);
+                }
+                else {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+            });
+        })
+            .on("error", reject)
+            .end();
+    });
+}
+exports.fetchJson = fetchJson;
+async function post(url, data, options = {}) {
+    await new Promise((resolve, reject) => {
+        const req = request(href(url, options.query), { method: "POST", headers: options.headers }, (res) => {
+            res.on("error", reject);
+            if (res.statusCode !== 200) {
+                reject(new Error(`Post failed: ${res.statusCode} ${res.statusMessage}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+}
+exports.post = post;
+async function downloadFile(url, output, options = {}) {
+    const timeout = options.timeout ?? 3600 * 100;
+    const file = (0, fs_1.createWriteStream)(output);
+    await new Promise((resolve, reject) => {
+        const req = request(href(url, options.query), {
+            headers: options.headers,
+        }, (res) => {
+            if (res.statusCode === 200) {
+                res
+                    .on("error", async (error) => {
+                    file.destroy();
+                    try {
+                        await (0, promises_1.unlink)(output);
+                    }
+                    catch (_) { }
+                    reject(error);
+                })
+                    .pipe(file);
+                file.on("finish", () => {
+                    file.close((error) => {
+                        error ? reject(error) : resolve();
+                    });
+                });
+            }
+            else {
+                reject(new Error(`Download failed: ${res.statusCode} ${res.statusMessage}`));
+            }
+        }).on("error", async (error) => {
+            try {
+                await (0, promises_1.unlink)(output);
+            }
+            catch (_) { }
+            reject(error);
+        });
+        req.setTimeout(timeout, () => {
+            req.destroy();
+            reject(new Error(`Request timeout after ${timeout / 1000}s`));
+        });
+        req.end();
+    });
+}
+exports.downloadFile = downloadFile;
+async function uploadFile(url, path, options = {}) {
+    const { size } = await (0, promises_1.stat)(path);
+    const readStream = (0, fs_1.createReadStream)(path);
+    await new Promise((resolve, reject) => {
+        const req = request(href(url, options.query), {
+            method: "POST",
+            headers: {
+                ...options.headers,
+                "Content-length": size,
+            },
+        }, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Upload failed: ${res.statusCode} ${res.statusMessage}`));
+            }
+            else {
+                resolve();
+            }
+        }).on("error", reject);
+        readStream.on("error", reject).pipe(req);
+    });
+}
+exports.uploadFile = uploadFile;

package/utils/list.d.ts

@@ -0,0 +1,64 @@
+import { Timer } from "./date";
+import { ProgressManager } from "./progress";
+import { Streams } from "./stream";
+import { Listr, ListrGetRendererClassFromValue, ListrLogger, ListrTask, ListrTaskWrapper } from "listr2";
+export declare class List3Logger<Levels extends string = string> extends ListrLogger<Levels> {
+    constructor(options?: {
+        streams?: Partial<Streams>;
+    });
+}
+export type Listr3Context = Record<string, Record<string, any>>;
+type KeyIndex = number | string | (string | number)[];
+type Listr3Task<T extends Listr3Context, K extends keyof T> = {
+    key: K;
+    keyIndex?: KeyIndex;
+    data: T[K];
+    title: string | {
+        initial: string;
+        started?: string;
+        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;
+    skip?: boolean;
+};
+type List3TaskResultObject<K, D extends Record<string, any>> = {
+    key: K;
+    keyIndex?: string;
+    data: D;
+    elapsed: number;
+    error?: Error;
+};
+type SummaryResult = List3TaskResultObject<"summary", {
+    errors: number;
+}>;
+export type Listr3TaskResult<T extends Listr3Context> = {
+    [K in keyof T]: List3TaskResultObject<K, T[K]>;
+}[keyof T];
+export type Listr3TaskResultEnd<T extends Listr3Context> = Listr3TaskResult<T> | SummaryResult;
+export declare class Listr3<T extends Listr3Context> extends Listr<void, "default", "simple"> {
+    readonly $options: {
+        streams?: Streams;
+        progressManager?: ProgressManager;
+    };
+    readonly resultMap: Record<string, Listr3TaskResult<T>>;
+    readonly resultList: Listr3TaskResult<T>[];
+    protected execTimer: Timer;
+    constructor($options: {
+        streams?: Streams;
+        progressManager?: ProgressManager;
+    });
+    private serializeKeyIndex;
+    private createResultIndex;
+    result(key: keyof T, keyIndex?: KeyIndex): Listr3TaskResult<T>;
+    $task<K extends keyof T>(item: Listr3Task<T, K>): ListrTask;
+    $tasks<K extends keyof T>(...items: (Listr3Task<T, K> | ListrTask | false)[]): ListrTask[];
+    add(tasks: ListrTask<void, ListrGetRendererClassFromValue<"default">> | ListrTask<void, ListrGetRendererClassFromValue<"default">>[]): this;
+    getSummaryResult(): SummaryResult;
+    getResult(): (SummaryResult | Listr3TaskResult<T>)[];
+    exec(): Promise<(Listr3TaskResult<T> | SummaryResult)[]>;
+}
+export {};