@datatruck/cli 0.15.0 → 0.16.0

package/SessionDriver/ConsoleSessionDriver.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleSessionDriver = void 0;
 const AppError_1 = require("../Error/AppError");
@@ -6,6 +9,7 @@ const cli_util_1 = require("../util/cli-util");
 const date_util_1 = require("../util/date-util");
 const SessionDriverAbstract_1 = require("./SessionDriverAbstract");
 const chalk_1 = require("chalk");
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
 const sep = (0, chalk_1.grey)(`|`);
 const renderBadge = (badge) => `${badge.color(badge.name)}${(0, chalk_1.grey)(`:`)} ${(0, chalk_1.white)(badge.value)}`;
 const renderBadges = (badges) => badges.map(renderBadge).join(` ${sep} `);
@@ -72,28 +76,53 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         ]);
         const padding = "   ".repeat(message.level ?? 0);
         const sessionId = message.sessionId.toString().padStart(2, "0");
-        const parts = [
+        let parts = [
             `${padding}${message.textPrefix} [${(0, chalk_1.grey)(sessionId)}] ${message.text}`,
             badges,
         ];
-        if (typeof message.progressPercent === "number") {
-            parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressPercent ?? 0, 10)), `${message.progressPercent?.toFixed(2)}%`);
-        }
-        if (typeof message.progressCurrent === "number" ||
-            typeof message.progressTotal === "number") {
-            parts.push(`${message.progressCurrent ?? "?"}/${message.progressTotal ?? "?"}`);
-        }
-        if (message.progressStepDescription && message.progressStepItem) {
-            parts.push(`${message.progressStepDescription}: ${message.progressStepItem}`);
-        }
-        else if (message.progressStepDescription) {
-            parts.push(message.progressStepDescription);
-        }
-        else if (message.progressStepItem) {
-            parts.push(message.progressStepItem);
-        }
-        if (typeof message.progressStepPercent === "number") {
-            parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressStepPercent ?? 0, 10)));
+        const progress = message.progress;
+        const absolute = progress?.absolute || {};
+        const relative = progress?.relative || {};
+        if (typeof absolute.percent === "number" ||
+            typeof relative.percent === "number") {
+            parts.push((0, cli_util_1.renderProgressBar)(absolute.percent ?? 0, 10, relative.percent ?? undefined));
+        }
+        const createProgressParts = (p) => {
+            const result = [];
+            if (typeof p.percent === "number")
+                result.push(`${p.percent.toFixed(2)}%`);
+            if (typeof p.current === "number" || typeof p.total === "number") {
+                const format = (value) => p.format === "size" ? (0, pretty_bytes_1.default)(value) : value;
+                if (typeof p.current === "number" && typeof p.total === "number") {
+                    result.push(`${format(p.current)}/${format(p.total)}`);
+                }
+                else if (typeof p.current === "number") {
+                    result.push(`${format(p.current)}`);
+                }
+                else if (typeof p.total === "number") {
+                    result.push(`?/${format(p.total)}`);
+                }
+            }
+            if (p.description && p.payload) {
+                result.push(`${p.description}: ${p.payload}`);
+            }
+            else if (p.description) {
+                result.push(p.description);
+            }
+            else if (p.payload) {
+                result.push(p.payload);
+            }
+            return result;
+        };
+        if (progress?.absolute)
+            parts.push(...createProgressParts(progress?.absolute));
+        if (progress?.relative) {
+            const relativeParts = createProgressParts(progress?.relative);
+            if (relativeParts.length) {
+                return (parts.join(` ${sep} `) +
+                    `  ${(0, chalk_1.cyan)("▷")}  ` +
+                    relativeParts.join(` ${sep} `));
+            }
         }
         return parts.join(` ${sep} `);
     }
@@ -124,7 +153,9 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             if (data.data.error)
                 message.errorBadge = {
                     name: "error",
-                    value: this.tty ? data.data.error.split("\n")[0] : data.data.error,
+                    value: this.tty && data.data.error.startsWith(`${AppError_1.AppError.name} :`)
+                        ? data.data.error.split("\n")[0]
+                        : data.data.error,
                     color: chalk_1.red,
                 };
         }
@@ -132,12 +163,7 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             message.textPrefix = "{spinner}";
         }
         if (hasProgress) {
-            message.progressPercent = data.data.progressPercent;
-            message.progressCurrent = data.data.progressCurrent;
-            message.progressTotal = data.data.progressTotal;
-            message.progressStepDescription = data.data.progressStepDescription;
-            message.progressStepItem = data.data.progressStepItem;
-            message.progressStepPercent = data.data.progressStepPercent;
+            message.progress = data.data.progress;
         }
         if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSession ||
             data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSession) {

package/SessionDriver/SqliteSessionDriver.js

@@ -134,6 +134,11 @@ class SqliteSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         let stm;
         let object = data.data;
         const id = object.id;
+        object = {
+            ...object,
+            // @ts-expect-error
+            progress: data.data.progress ? JSON.stringify(data.data.progress) : null,
+        };
         if (data.action === SessionDriverAbstract_1.ActionEnum.Init) {
             // @ts-expect-error
             object = { ...object, id: null };

package/SessionManager/BackupSessionManager.d.ts

@@ -2,9 +2,9 @@ import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction"
 import { BackupSessionEntity } from "../Entity/BackupSessionEntity";
 import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
 import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
-import { ProgressDataType } from "../Repository/RepositoryAbstract";
 import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
 import { ObjectVault } from "../util/ObjectVault";
+import { Progress } from "../util/progress";
 import SessionManagerAbstract from "./SessionManagerAbstract";
 export declare class BackupSessionManager extends SessionManagerAbstract {
     sessionVault: ObjectVault<BackupSessionEntity>;
@@ -33,11 +33,13 @@ export declare class BackupSessionManager extends SessionManagerAbstract {
     startTask(input: Pick<BackupSessionTaskEntity, "id">): Promise<number>;
     progressTask(input: {
         id: number;
-    } & ProgressDataType): Promise<number>;
+        progress: Progress;
+    }): Promise<number>;
     endTask(input: Pick<BackupSessionTaskEntity, "id" | "error">): Promise<number>;
     startRepository(input: Pick<BackupSessionRepositoryEntity, "id">): Promise<number>;
     progressRepository(input: {
         id: number;
-    } & ProgressDataType): Promise<number>;
+        progress: Progress;
+    }): Promise<number>;
     endRepository(input: Pick<BackupSessionRepositoryEntity, "id" | "error">): Promise<number>;
 }

package/SessionManager/BackupSessionManager.js

@@ -33,17 +33,25 @@ class BackupSessionManager extends SessionManagerAbstract_1.default {
     }
     async endDrivers(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        this.stopDelayedProgress();
         for (const driver of drivers) {
             await driver.onEnd(data);
         }
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        const write = async () => {
+            for (const driver of drivers) {
+                await driver.onWrite(data);
+            }
+        };
         if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
-            !this.checkProgress(data.data.progressStepDescription))
-            return data.data.id;
-        for (const driver of drivers) {
-            await driver.onWrite(data);
+            !this.checkProgress(data.data.progress?.relative?.description)) {
+            this.delayProgress(write);
+        }
+        else {
+            this.stopDelayedProgress();
+            await write();
         }
         return data.data.id;
     }
@@ -146,13 +154,7 @@ class BackupSessionManager extends SessionManagerAbstract_1.default {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                id: input.id,
-                progressCurrent: input.stats?.current,
-                progressTotal: input.stats?.total,
-                progressPercent: input.stats?.percent,
-                progressStepDescription: input.step?.description,
-                progressStepItem: input.step?.item,
-                progressStepPercent: input.step?.percent,
+                ...input,
                 updatingDate: new Date().toISOString(),
             },
         });
@@ -195,13 +197,7 @@ class BackupSessionManager extends SessionManagerAbstract_1.default {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                id: input.id,
-                progressCurrent: input.stats?.current,
-                progressTotal: input.stats?.total,
-                progressPercent: input.stats?.percent,
-                progressStepDescription: input.step?.description,
-                progressStepItem: input.step?.item,
-                progressStepPercent: input.step?.percent,
+                ...input,
                 updatingDate: new Date().toISOString(),
             },
         });

package/SessionManager/RestoreSessionManager.d.ts

@@ -2,16 +2,16 @@ import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction"
 import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
 import { RestoreSessionRepositoryEntity } from "../Entity/RestoreSessionRepositoryEntity";
 import { RestoreSessionTaskEntity } from "../Entity/RestoreSessionTaskEntity";
-import { ProgressDataType } from "../Repository/RepositoryAbstract";
 import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
 import { ObjectVault } from "../util/ObjectVault";
+import { Progress } from "../util/progress";
 import SessionManagerAbstract from "./SessionManagerAbstract";
 export declare class RestoreSessionManager extends SessionManagerAbstract {
     sessionVault: ObjectVault<RestoreSessionEntity>;
     repositoryVault: ObjectVault<RestoreSessionRepositoryEntity>;
     taskVault: ObjectVault<RestoreSessionTaskEntity>;
     protected lastProgressDate: number | undefined;
-    protected lastProgressStepDescription: string | null | undefined;
+    protected lastRelativeProgressDescription: string | null | undefined;
     findId(data: {
         packageName: string;
     }): number;
@@ -36,10 +36,12 @@ export declare class RestoreSessionManager extends SessionManagerAbstract {
     startRepository(input: Pick<RestoreSessionRepositoryEntity, "id">): Promise<number>;
     progressTask(input: {
         id: number;
-    } & ProgressDataType): Promise<number>;
+        progress: Progress;
+    }): Promise<number>;
     endTask(input: Pick<RestoreSessionTaskEntity, "id" | "error">): Promise<number>;
     progressRepository(input: {
         id: number;
-    } & ProgressDataType): Promise<number>;
+        progress: Progress;
+    }): Promise<number>;
     endRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "error">): Promise<number>;
 }

package/SessionManager/RestoreSessionManager.js

@@ -33,17 +33,25 @@ class RestoreSessionManager extends SessionManagerAbstract_1.default {
     }
     async endDrivers() {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        this.stopDelayedProgress();
         for (const driver of drivers) {
             await driver.onEnd();
         }
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        const write = async () => {
+            for (const driver of drivers) {
+                await driver.onWrite(data);
+            }
+        };
         if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
-            !this.checkProgress(data.data.progressStepDescription))
-            return data.data.id;
-        for (const driver of drivers) {
-            await driver.onWrite(data);
+            !this.checkProgress(data.data.progress?.relative?.description)) {
+            this.delayProgress(write);
+        }
+        else {
+            this.stopDelayedProgress();
+            await write();
         }
         return data.data.id;
     }
@@ -161,13 +169,7 @@ class RestoreSessionManager extends SessionManagerAbstract_1.default {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                id: input.id,
-                progressCurrent: input.stats?.current,
-                progressTotal: input.stats?.total,
-                progressPercent: input.stats?.percent,
-                progressStepDescription: input.step?.description,
-                progressStepItem: input.step?.item,
-                progressStepPercent: input.step?.percent,
+                ...input,
                 updatingDate: new Date().toISOString(),
             },
         });
@@ -195,13 +197,7 @@ class RestoreSessionManager extends SessionManagerAbstract_1.default {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                id: input.id,
-                progressCurrent: input.stats?.current,
-                progressTotal: input.stats?.total,
-                progressPercent: input.stats?.percent,
-                progressStepDescription: input.step?.description,
-                progressStepItem: input.step?.item,
-                progressStepPercent: input.step?.percent,
+                ...input,
                 updatingDate: new Date().toISOString(),
             },
         });

package/SessionManager/SessionManagerAbstract.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
 export declare type OptionsType = {
     driver: SessionDriverAbstract;
@@ -8,7 +9,10 @@ export declare type OptionsType = {
 export default abstract class SessionManagerAbstract {
     readonly options: OptionsType;
     protected lastProgressDate: number | undefined;
-    protected lastProgressStepDescription: string | null | undefined;
+    protected lastRelativeProgressDescription: string | null | undefined;
+    protected progressTimeout: ReturnType<typeof setTimeout> | undefined;
     constructor(options: OptionsType);
+    protected stopDelayedProgress(): void;
+    protected delayProgress(cb: () => Promise<any>): void;
     protected checkProgress(description: string | null | undefined): boolean;
 }

package/SessionManager/SessionManagerAbstract.js

@@ -4,16 +4,27 @@ class SessionManagerAbstract {
     constructor(options) {
         this.options = options;
     }
+    stopDelayedProgress() {
+        clearTimeout(this.progressTimeout);
+        this.progressTimeout = undefined;
+    }
+    delayProgress(cb) {
+        clearTimeout(this.progressTimeout);
+        this.progressTimeout = setTimeout(async () => {
+            this.progressTimeout = undefined;
+            await cb();
+        }, 1500);
+    }
     checkProgress(description) {
         const progressInterval = this.options.progressInterval;
         if (progressInterval) {
             const skip = this.lastProgressDate &&
-                description === this.lastProgressStepDescription &&
+                description === this.lastRelativeProgressDescription &&
                 Date.now() - this.lastProgressDate < progressInterval;
             if (skip)
                 return false;
             this.lastProgressDate = Date.now();
-            this.lastProgressStepDescription = description;
+            this.lastRelativeProgressDescription = description;
         }
         return true;
     }

package/Task/GitTask.js

@@ -73,7 +73,7 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
         await data.onProgress({
-            step: {
+            relative: {
                 description: "Creating bundle",
             },
         });
@@ -176,11 +176,11 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                 onPath: async ({ entryPath }) => {
                     currentFiles++;
                     await data.onProgress({
-                        step: {
+                        relative: {
                             description: "Copying file",
-                            item: entryPath,
+                            payload: entryPath,
                         },
-                        stats: {
+                        absolute: {
                             total,
                             current: currentFiles,
                             percent: (0, math_util_1.progressPercent)(total, currentFiles),
@@ -210,12 +210,12 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         await (0, fs_util_1.forEachFile)(targetPath, () => totalFiles++, true);
         const incrementProgress = async (description, item, count = true) => {
             await data.onProgress({
-                stats: {
+                absolute: {
                     total: totalFiles,
                     current: Math.max(currentFiles, 0),
                     percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
                 },
-                step: { description, item },
+                relative: { description, payload: item },
             });
             if (count)
                 currentFiles++;

package/Task/MariadbTask.js

@@ -108,11 +108,11 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             else if (paths.length) {
                 const path = (0, posix_1.normalize)(paths[0]);
                 await data.onProgress({
-                    step: {
+                    relative: {
                         description: "Copying file",
-                        item: path,
+                        payload: path,
                     },
-                    stats: {
+                    absolute: {
                         current,
                         percent: (0, math_util_1.progressPercent)(total, current),
                         total,

package/Task/MysqlDumpTask.d.ts

@@ -9,7 +9,9 @@ export declare class MysqlDumpTask extends SqlDumpTaskAbstract<MysqlDumpTaskConf
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
     onFetchTableNames(database: string): Promise<string[]>;
-    onExportTables(tableNames: string[], output: string): Promise<void>;
+    onExportTables(tableNames: string[], output: string, onProgress: (progress: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     onExportStoredPrograms(output: string): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/MysqlDumpTask.js

@@ -70,7 +70,7 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         table_name
 	`);
     }
-    async onExportTables(tableNames, output) {
+    async onExportTables(tableNames, output, onProgress) {
         const stream = (0, fs_1.createWriteStream)(output);
         await Promise.all([
             new Promise((resolve, reject) => {
@@ -83,7 +83,10 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
                 "--skip-add-drop-table=false",
                 ...tableNames,
             ], null, {
-                pipe: { stream: stream },
+                pipe: {
+                    stream,
+                    onWriteProgress: onProgress,
+                },
                 log: {
                     exec: this.verbose,
                     stderr: this.verbose,

package/Task/PostgresqlDumpTask.d.ts

@@ -9,7 +9,9 @@ export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDu
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
     onFetchTableNames(database: string): Promise<string[]>;
-    onExportTables(tableNames: string[], output: string): Promise<void>;
+    onExportTables(tableNames: string[], output: string, onProgress: (progress: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     onExportStoredPrograms(): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/PostgresqlDumpTask.js

@@ -73,7 +73,7 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         CONCAT(table_schema, '.', table_name)
 	  `);
     }
-    async onExportTables(tableNames, output) {
+    async onExportTables(tableNames, output, onProgress) {
         const stream = (0, fs_1.createWriteStream)(output);
         await Promise.all([
             new Promise((resolve, reject) => {
@@ -84,7 +84,7 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
                 ...(await this.buildConnectionArgs()),
                 ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
             ], null, {
-                pipe: { stream: stream },
+                pipe: { stream, onWriteProgress: onProgress },
                 stderr: {
                     toExitCode: true,
                 },

package/Task/SqlDumpTaskAbstract.d.ts

@@ -29,7 +29,9 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
     abstract onFetchTableNames(database: string): Promise<string[]>;
     abstract onExecQuery(query: string): ReturnType<typeof exec>;
-    abstract onExportTables(tableNames: string[], output: string): Promise<void>;
+    abstract onExportTables(tableNames: string[], output: string, onProgress: (data: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     abstract onExportStoredPrograms(output: string): Promise<void>;
     abstract onImport(path: string, database: string): Promise<void>;
     onBackup(data: BackupDataType): Promise<void>;

package/Task/SqlDumpTaskAbstract.js

@@ -119,35 +119,57 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         if (!this.config.oneFileByTable) {
             const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ database: this.config.database }));
             data.onProgress({
-                step: {
+                relative: {
                     description: "Exporting",
                 },
             });
-            await this.onExportTables(tableNames, outPath);
+            await this.onExportTables(tableNames, outPath, async (progress) => {
+                await data.onProgress({
+                    absolute: {
+                        description: "Exporting in single file",
+                        current: progress.totalBytes,
+                        format: "size",
+                    },
+                });
+            });
         }
         else {
             let current = 0;
             for (const tableName of tableNames) {
-                data.onProgress({
-                    step: {
+                await data.onProgress({
+                    relative: {
                         description: "Exporting",
-                        item: tableName,
+                        payload: tableName,
                     },
-                    stats: {
+                    absolute: {
                         total: tableNames.length,
                         current: current,
                         percent: (0, math_util_1.progressPercent)(tableNames.length, current),
                     },
                 });
                 const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ table: tableName }));
-                await this.onExportTables([tableName], outPath);
+                await this.onExportTables([tableName], outPath, async (progress) => {
+                    await data.onProgress({
+                        relative: {
+                            description: "Exporting",
+                            payload: tableName,
+                            current: progress.totalBytes,
+                            format: "size",
+                        },
+                        absolute: {
+                            total: tableNames.length,
+                            current: current,
+                            percent: (0, math_util_1.progressPercent)(tableNames.length, current),
+                        },
+                    });
+                });
                 current++;
             }
         }
         if (this.config.storedPrograms) {
             const outPath = (0, path_1.join)(outputPath, "stored-programs.sql");
             data.onProgress({
-                step: {
+                relative: {
                     description: "Exporting storaged programs",
                 },
             });
@@ -199,11 +221,11 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         for (const item of items) {
             const path = (0, path_1.join)(restorePath, item.fileName);
             data.onProgress({
-                step: {
+                relative: {
                     description: "Importing",
-                    item: item.fileName,
+                    payload: item.fileName,
                 },
-                stats: {
+                absolute: {
                     total: items.length,
                     current: current,
                     percent: (0, math_util_1.progressPercent)(items.length, current),

package/Task/TaskAbstract.d.ts

@@ -2,27 +2,16 @@ import { BackupActionOptionsType } from "../Action/BackupAction";
 import { RestoreActionOptionsType } from "../Action/RestoreAction";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { SnapshotType } from "../Repository/RepositoryAbstract";
-export declare type ProgressDataType = {
-    stats?: {
-        total?: number;
-        current?: number;
-        percent?: number;
-    };
-    step?: {
-        description?: string;
-        item?: string;
-        percent?: number;
-    };
-};
+import { Progress } from "../util/progress";
 export declare type BackupDataType = {
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
     options: BackupActionOptionsType;
     package: PackageConfigType;
     targetPath: string | undefined;
     snapshot: SnapshotType;
 };
 export declare type RestoreDataType = {
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
     options: RestoreActionOptionsType;
     package: PackageConfigType;
     targetPath: string | undefined;