@datatruck/cli 0.16.0 → 0.16.2

package/Action/BackupAction.d.ts

@@ -1,12 +1,12 @@
 import type { ConfigType } from "../Config/Config";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
-import { TaskConfigType } from "../Config/TaskConfig";
 import { AppError } from "../Error/AppError";
 import { SnapshotType } from "../Repository/RepositoryAbstract";
 import { BackupSessionManager } from "../SessionManager/BackupSessionManager";
+import { TaskAbstract } from "../Task/TaskAbstract";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type BackupActionOptionsType = {
+export type BackupActionOptionsType = {
     repositoryNames?: string[];
     repositoryTypes?: string[];
     packageNames?: string[];
@@ -23,10 +23,26 @@ export declare class BackupAction<TRequired extends boolean = true> {
     protected repoErrors: Record<string, Error[]>;
     constructor(config: ConfigType, options?: IfRequireKeys<TRequired, BackupActionOptionsType>);
     protected init(session: BackupSessionManager): Promise<[SnapshotType, PackageConfigType[]]>;
-    protected execTask(session: BackupSessionManager, pkg: PackageConfigType, task: TaskConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
-    protected execRepository(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
-    protected execCopyRepository(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, mirrorRepo: RepositoryConfigType, snapshot: SnapshotType): Promise<boolean>;
+    protected task(session: BackupSessionManager, pkg: PackageConfigType, task: TaskAbstract<any>, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
+    protected backup(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
+    protected copyBackup(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, mirrorRepo: RepositoryConfigType, snapshot: SnapshotType): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
     protected getError(pkg: PackageConfigType): AppError | null;
+    protected splitRepositories(repositoryNames: string[]): {
+        repoNames: string[];
+        mirrors: {
+            sourceName: string;
+            name: string;
+        }[];
+    };
     exec(session: BackupSessionManager): Promise<{
         total: number;
         errors: number;

package/Action/BackupAction.js

@@ -5,6 +5,7 @@ const AppError_1 = require("../Error/AppError");
 const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
 const TaskFactory_1 = require("../Factory/TaskFactory");
 const config_util_1 = require("../util/datatruck/config-util");
+const fs_util_1 = require("../util/fs-util");
 const crypto_1 = require("crypto");
 class BackupAction {
     constructor(config, options = {}) {
@@ -53,10 +54,10 @@ class BackupAction {
         }
         return [snapshot, packages];
     }
-    async execTask(session, pkg, task, snapshot, targetPath) {
+    async task(session, pkg, task, snapshot, targetPath) {
         const taskId = session.findTaskId({
             packageName: pkg.name,
-            taskName: task.name,
+            taskName: pkg.task.name,
         });
         await session.startTask({
             id: taskId,
@@ -68,8 +69,7 @@ class BackupAction {
         }
         else {
             try {
-                const taskInstance = (0, TaskFactory_1.TaskFactory)(task);
-                await taskInstance.onBackup({
+                await task.onBackup({
                     package: pkg,
                     options: this.options,
                     snapshot,
@@ -92,9 +92,12 @@ class BackupAction {
             id: taskId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: task.tmpDirs,
+        };
     }
-    async execRepository(session, pkg, repo, snapshot, targetPath) {
+    async backup(session, pkg, repo, snapshot, targetPath) {
         const repositoryId = session.findRepositoryId({
             packageName: pkg.name,
             repositoryName: repo.name,
@@ -103,12 +106,13 @@ class BackupAction {
             id: repositoryId,
         });
         let error;
+        let repoInstance;
         if (this.taskErrors[pkg.name]?.length) {
             error = new AppError_1.AppError("Task failed");
         }
         else {
             try {
-                const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+                repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
                 await repoInstance.onBackup({
                     package: pkg,
                     targetPath,
@@ -134,9 +138,12 @@ class BackupAction {
             id: repositoryId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: repoInstance?.tmpDirs ?? [],
+        };
     }
-    async execCopyRepository(session, pkg, repo, mirrorRepo, snapshot) {
+    async copyBackup(session, pkg, repo, mirrorRepo, snapshot) {
         const repositoryId = session.findRepositoryId({
             packageName: pkg.name,
             repositoryName: mirrorRepo.name,
@@ -145,12 +152,13 @@ class BackupAction {
             id: repositoryId,
         });
         let error;
+        let repoInstance;
         if (this.taskErrors[pkg.name]?.length) {
             error = new AppError_1.AppError("Task failed");
         }
         else {
             try {
-                const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+                repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
                 await repoInstance.onCopyBackup({
                     options: this.options,
                     package: pkg,
@@ -174,7 +182,10 @@ class BackupAction {
             id: repositoryId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: repoInstance?.tmpDirs ?? [],
+        };
     }
     getError(pkg) {
         const taskErrors = this.taskErrors[pkg.name]?.length;
@@ -192,12 +203,33 @@ class BackupAction {
             return null;
         }
     }
+    splitRepositories(repositoryNames) {
+        const mirrorRepoMap = {};
+        const allMirrorRepoNames = [];
+        const repoNames = repositoryNames ?? [];
+        for (const repoName of repoNames) {
+            const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
+            if (repo.mirrorRepoNames)
+                mirrorRepoMap[repoName] = repo.mirrorRepoNames.filter((mirrorRepoName) => {
+                    allMirrorRepoNames.push(mirrorRepoName);
+                    return repoNames.includes(mirrorRepoName);
+                });
+        }
+        return {
+            repoNames: repoNames.filter((v) => !allMirrorRepoNames.includes(v)),
+            mirrors: repoNames.flatMap((sourceName) => {
+                const mirrorNames = mirrorRepoMap[sourceName] || [];
+                return mirrorNames.map((name) => ({
+                    sourceName,
+                    name,
+                }));
+            }),
+        };
+    }
     async exec(session) {
         const [snapshot, packages] = await this.init(session);
-        let total = 0;
         let errors = 0;
         for (const pkg of packages) {
-            total++;
             const id = session.findId({
                 packageName: pkg.name,
             });
@@ -205,6 +237,7 @@ class BackupAction {
                 id,
             });
             let targetPath;
+            let taskTmpDirs = [];
             if (pkg.task) {
                 const taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
                 const result = await taskInstance.onBeforeBackup({
@@ -212,35 +245,29 @@ class BackupAction {
                     package: pkg,
                     snapshot,
                 });
-                await this.execTask(session, pkg, pkg.task, snapshot, (targetPath = result?.targetPath));
-            }
-            const mirrorRepoMap = {};
-            const allMirrorRepoNames = [];
-            const repoNames = pkg.repositoryNames ?? [];
-            for (const repoName of repoNames) {
-                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                if (repo.mirrorRepoNames)
-                    mirrorRepoMap[repoName] = repo.mirrorRepoNames.filter((mirrorRepoName) => {
-                        allMirrorRepoNames.push(mirrorRepoName);
-                        return repoNames.includes(mirrorRepoName);
-                    });
+                const taskResult = await this.task(session, pkg, taskInstance, snapshot, (targetPath = result?.targetPath));
+                taskTmpDirs.push(...taskResult.tmpDirs);
             }
+            const { repoNames, mirrors } = this.splitRepositories(pkg.repositoryNames ?? []);
             for (const repoName of repoNames) {
-                if (allMirrorRepoNames.includes(repoName))
-                    continue;
                 const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                await this.execRepository(session, pkg, repo, snapshot, targetPath);
+                const { tmpDirs } = await this.backup(session, pkg, repo, snapshot, targetPath);
+                if (!this.options.verbose)
+                    await (0, fs_util_1.rmTmpDir)(tmpDirs);
             }
-            for (const repoName of repoNames) {
-                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                const mirrorRepoNames = mirrorRepoMap[repoName];
-                if (mirrorRepoNames) {
-                    for (const mirrorRepoName of mirrorRepoNames) {
-                        const mirrorRepo = (0, config_util_1.findRepositoryOrFail)(this.config, mirrorRepoName);
-                        await this.execCopyRepository(session, pkg, repo, mirrorRepo, snapshot);
-                    }
+            if (!this.options.verbose) {
+                await (0, fs_util_1.rmTmpDir)(taskTmpDirs);
+                if (pkg.path && (0, fs_util_1.isTmpDir)(pkg.path)) {
+                    await (0, fs_util_1.rmTmpDir)(pkg.path);
                 }
             }
+            for (const mirror of mirrors) {
+                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, mirror.sourceName);
+                const mirrorRepo = (0, config_util_1.findRepositoryOrFail)(this.config, mirror.name);
+                const { tmpDirs } = await this.copyBackup(session, pkg, repo, mirrorRepo, snapshot);
+                if (!this.options.verbose)
+                    await (0, fs_util_1.rmTmpDir)(tmpDirs);
+            }
             const error = this.getError(pkg);
             if (error)
                 errors++;
@@ -253,7 +280,7 @@ class BackupAction {
             snapshotId: snapshot.id.slice(0, 8),
         });
         return {
-            total: total,
+            total: packages.length,
             errors: errors,
         };
     }

package/Action/BackupSessionsAction.d.ts

@@ -2,7 +2,7 @@ import type { ConfigType } from "../Config/Config";
 import { ReadDataType } from "../SessionDriver/SessionDriverAbstract";
 import { BackupSessionManager } from "../SessionManager/BackupSessionManager";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type BackupSessionsActionOptionsType = ReadDataType & {
+export type BackupSessionsActionOptionsType = ReadDataType & {
     verbose?: boolean;
 };
 export declare class BackupSessionsAction<TRequired extends boolean = true> {

package/Action/CleanCacheAction.d.ts

@@ -1,5 +1,5 @@
 import { IfRequireKeys } from "../util/ts-util";
-export declare type CleanCacheActionOptionsType = {
+export type CleanCacheActionOptionsType = {
     verbose?: boolean;
 };
 export declare class CleanCacheAction<TRequired extends boolean = true> {

package/Action/ConfigAction.d.ts

@@ -1,7 +1,7 @@
 import { GlobalOptionsType } from "../Command/CommandAbstract";
 import type { ConfigType } from "../Config/Config";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type ConfigActionOptionsType = {
+export type ConfigActionOptionsType = {
     path: string;
     verbose?: boolean;
 };

package/Action/InitAction.d.ts

@@ -1,6 +1,6 @@
 import type { ConfigType } from "../Config/Config";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type InitActionOptionsType = {
+export type InitActionOptionsType = {
     repositoryNames?: string[];
     repositoryTypes?: string[];
     verbose?: boolean;

package/Action/PruneAction.d.ts

@@ -2,7 +2,7 @@ import type { ConfigType } from "../Config/Config";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { IfRequireKeys } from "../util/ts-util";
 import { SnapshotExtendedType, SnapshotsActionOptionsType } from "./SnapshotsAction";
-export declare type PruneActionsOptionsType = {
+export type PruneActionsOptionsType = {
     ids?: string[];
     packageNames?: string[];
     repositoryNames?: string[];
@@ -21,7 +21,7 @@ export declare type PruneActionsOptionsType = {
     longId?: boolean;
     returnsAll?: boolean;
 };
-export declare type PruneResultType = {
+export type PruneResultType = {
     total: number;
     prune: number;
     snapshots: (SnapshotExtendedType & {

package/Action/RestoreAction.d.ts

@@ -1,12 +1,12 @@
 import type { ConfigType } from "../Config/Config";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
-import { TaskConfigType } from "../Config/TaskConfig";
 import { AppError } from "../Error/AppError";
 import { SnapshotResultType } from "../Repository/RepositoryAbstract";
 import { RestoreSessionManager } from "../SessionManager/RestoreSessionManager";
+import { TaskAbstract } from "../Task/TaskAbstract";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type RestoreActionOptionsType = {
+export type RestoreActionOptionsType = {
     snapshotId: string;
     tags?: string[];
     packageNames?: string[];
@@ -16,10 +16,10 @@ export declare type RestoreActionOptionsType = {
     repositoryTypes?: string[];
     verbose?: boolean;
 };
-declare type SnapshotType = SnapshotResultType & {
+type SnapshotType = SnapshotResultType & {
     repositoryName: string;
 };
-declare type SnapshotAndConfigType = [SnapshotType, PackageConfigType | null];
+type SnapshotAndConfigType = [SnapshotType, PackageConfigType | null];
 export declare class RestoreAction<TRequired extends boolean = true> {
     readonly config: ConfigType;
     readonly options: IfRequireKeys<TRequired, RestoreActionOptionsType>;
@@ -30,8 +30,14 @@ export declare class RestoreAction<TRequired extends boolean = true> {
     protected init(session: RestoreSessionManager, snapshotId: string, snapshots: SnapshotAndConfigType[]): Promise<void>;
     protected findSnapshots(): Promise<SnapshotType[]>;
     protected groupSnapshots(snapshots: SnapshotType[]): SnapshotType[];
-    protected execTask(session: RestoreSessionManager, pkg: PackageConfigType, task: TaskConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
-    protected execRepository(session: RestoreSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
+    protected task(session: RestoreSessionManager, pkg: PackageConfigType, task: TaskAbstract<any>, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
+    protected restore(session: RestoreSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
     protected getError(pkg: PackageConfigType): AppError | null;
     exec(session: RestoreSessionManager): Promise<boolean>;
 }

package/Action/RestoreAction.js

@@ -88,10 +88,10 @@ class RestoreAction {
             return true;
         });
     }
-    async execTask(session, pkg, task, snapshot, targetPath) {
+    async task(session, pkg, task, snapshot, targetPath) {
         const taskId = session.findTaskId({
             packageName: pkg.name,
-            taskName: task.name,
+            taskName: pkg.task.name,
         });
         await session.startTask({
             id: taskId,
@@ -105,8 +105,7 @@ class RestoreAction {
         }
         else {
             try {
-                const taskInstance = (0, TaskFactory_1.TaskFactory)(task);
-                await taskInstance.onRestore({
+                await task.onRestore({
                     package: pkg,
                     options: this.options,
                     snapshot,
@@ -129,9 +128,12 @@ class RestoreAction {
             id: taskId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: task?.tmpDirs ?? [],
+        };
     }
-    async execRepository(session, pkg, repo, snapshot, targetPath) {
+    async restore(session, pkg, repo, snapshot, targetPath) {
         const repositoryId = session.findRepositoryId({
             packageName: pkg.name,
             repositoryName: repo.name,
@@ -140,6 +142,7 @@ class RestoreAction {
             id: repositoryId,
         });
         let repoError;
+        let repoInstance;
         try {
             if (typeof pkg.restorePath !== "string")
                 throw new AppError_1.AppError("Restore path is not defined");
@@ -148,7 +151,7 @@ class RestoreAction {
                 throw new AppError_1.AppError(`Restore path is not empty: ${pkg.restorePath}`);
             if (this.options.verbose)
                 (0, cli_util_1.logExec)(`restorePath=${pkg.restorePath}`);
-            const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+            repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
             await repoInstance.onRestore({
                 package: pkg,
                 targetPath,
@@ -179,7 +182,10 @@ class RestoreAction {
             id: repositoryId,
             error: repoError?.stack,
         });
-        return repoError ? false : true;
+        return {
+            error: repoError ? false : true,
+            tmpDirs: repoInstance?.tmpDirs || [],
+        };
     }
     getError(pkg) {
         const taskErrors = this.taskErrors[pkg.name]?.length;
@@ -223,8 +229,9 @@ class RestoreAction {
             });
             await session.start({ id });
             let targetPath;
+            let taskInstance;
             if (pkg.task) {
-                const taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
+                taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
                 const result = await taskInstance.onBeforeRestore({
                     options: this.options,
                     package: pkg,
@@ -232,9 +239,16 @@ class RestoreAction {
                 });
                 targetPath = result?.targetPath;
             }
-            await this.execRepository(session, pkg, repo, snapshot, targetPath);
-            if (pkg.task)
-                await this.execTask(session, pkg, pkg.task, snapshot, targetPath);
+            const { tmpDirs } = await this.restore(session, pkg, repo, snapshot, targetPath);
+            if (taskInstance) {
+                await this.task(session, pkg, taskInstance, snapshot, targetPath);
+            }
+            if (!this.options.verbose) {
+                await (0, fs_util_1.rmTmpDir)(taskInstance?.tmpDirs || []);
+                await (0, fs_util_1.rmTmpDir)(tmpDirs);
+                if (pkg.restorePath && (0, fs_util_1.isTmpDir)(pkg.restorePath))
+                    await (0, fs_util_1.rmTmpDir)(pkg.restorePath);
+            }
             const error = this.getError(pkg);
             await session.end({
                 id,

package/Action/RestoreSessionsAction.d.ts

@@ -2,7 +2,7 @@ import type { ConfigType } from "../Config/Config";
 import { ReadDataType } from "../SessionDriver/SessionDriverAbstract";
 import { RestoreSessionManager } from "../SessionManager/RestoreSessionManager";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type RestoreSessionsActionOptionsType = ReadDataType & {
+export type RestoreSessionsActionOptionsType = ReadDataType & {
     verbose?: boolean;
 };
 export declare class RestoreSessionsAction<TRequired extends boolean = true> {

package/Action/SnapshotsAction.d.ts

@@ -2,8 +2,8 @@ import type { ConfigType } from "../Config/Config";
 import { RepositoryConfigEnabledActionType } from "../Config/RepositoryConfig";
 import { SnapshotResultType } from "../Repository/RepositoryAbstract";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type SnapshotGroupByType = keyof Pick<SnapshotExtendedType, "packageName" | "repositoryName" | "repositoryType">;
-export declare type SnapshotsActionOptionsType = {
+export type SnapshotGroupByType = keyof Pick<SnapshotExtendedType, "packageName" | "repositoryName" | "repositoryType">;
+export type SnapshotsActionOptionsType = {
     ids?: string[];
     repositoryNames?: string[];
     packageNames?: string[];
@@ -21,7 +21,7 @@ export declare type SnapshotsActionOptionsType = {
     lastYearly?: number;
     groupBy?: SnapshotGroupByType[];
 };
-export declare type SnapshotExtendedType = {
+export type SnapshotExtendedType = {
     shortId: string;
     repositoryName: string;
     repositoryType: string;

package/Command/BackupCommand.d.ts

@@ -1,7 +1,7 @@
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type BackupCommandOptionsType<TResolved = false> = {
+export type BackupCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;

package/Command/BackupSessionsCommand.d.ts

@@ -1,6 +1,6 @@
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type BackupSessionsCommandOptionsType<TResolved = false> = {
+export type BackupSessionsCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     tag?: If<TResolved, string[]>;

package/Command/CleanCacheCommand.d.ts

@@ -1,5 +1,5 @@
 import { CommandAbstract } from "./CommandAbstract";
-export declare type CleanCacheCommandOptionsType<TResolved = false> = {};
+export type CleanCacheCommandOptionsType<TResolved = false> = {};
 export declare class CleanCacheCommand extends CommandAbstract<CleanCacheCommandOptionsType<false>, CleanCacheCommandOptionsType<true>> {
     onOptions(): import("../util/cli-util").OptionsType<CleanCacheCommandOptionsType<false>, CleanCacheCommandOptionsType<true>>;
     onExec(): Promise<number>;

package/Command/CommandAbstract.d.ts

@@ -2,14 +2,14 @@ import { ConfigType } from "../Config/Config";
 import { FormatType } from "../util/DataFormat";
 import { OptionsType } from "../util/cli-util";
 import { SimilarObject } from "../util/ts-util";
-export declare type GlobalOptionsType<TResolved = false> = {
+export type GlobalOptionsType<TResolved = false> = {
     config: string | ConfigType;
     outputFormat?: FormatType;
     verbose?: number;
     progress?: "auto" | "plain" | "tty";
     progressInterval?: number;
 };
-export declare type CommandConstructorType<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> = {
+export type CommandConstructorType<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> = {
     new (globalOptions: GlobalOptionsType<true>, options: TOptions): CommandAbstract<TUnresolvedOptions, TOptions>;
 };
 export declare abstract class CommandAbstract<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> {

package/Command/ConfigCommand.d.ts

@@ -1,13 +1,13 @@
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type ConfigCommandOptionsType<TResolved = false> = {
+export type ConfigCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
 };
-export declare type ConfigCommandLogType = {
+export type ConfigCommandLogType = {
     packageName: string;
     repositoryNames: string[];
     taskName: string | undefined;

package/Command/InitCommand.d.ts

@@ -2,11 +2,11 @@ import { InitAction } from "../Action/InitAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type InitCommandOptionsType<TResolved = false> = {
+export type InitCommandOptionsType<TResolved = false> = {
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
 };
-export declare type InitCommandLogType = Unwrap<InitAction["exec"]>;
+export type InitCommandLogType = Unwrap<InitAction["exec"]>;
 export declare class InitCommand extends CommandAbstract<InitCommandOptionsType<false>, InitCommandOptionsType<true>> {
     onOptions(): import("../util/cli-util").OptionsType<InitCommandOptionsType<false>, InitCommandOptionsType<true>>;
     onExec(): Promise<number>;

package/Command/PruneCommand.d.ts

@@ -2,7 +2,7 @@ import { SnapshotGroupByType } from "../Action/SnapshotsAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type PruneCommandOptionsType<TResolved = false> = {
+export type PruneCommandOptionsType<TResolved = false> = {
     id?: If<TResolved, string[]>;
     longId?: boolean;
     package?: If<TResolved, string[]>;

package/Command/RestoreCommand.d.ts

@@ -1,7 +1,7 @@
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type RestoreCommandOptionsType<TResolved = false> = {
+export type RestoreCommandOptionsType<TResolved = false> = {
     id: string;
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;

package/Command/RestoreSessionsCommand.d.ts

@@ -1,6 +1,6 @@
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type RestoreSessionsCommandOptionsType<TResolved = false> = {
+export type RestoreSessionsCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     tag?: If<TResolved, string[]>;

package/Command/SnapshotsCommand.d.ts

@@ -2,7 +2,7 @@ import { SnapshotsAction } from "../Action/SnapshotsAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type SnapshotsCommandOptionsType<TResolved = false> = {
+export type SnapshotsCommandOptionsType<TResolved = false> = {
     id?: If<TResolved, string[]>;
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
@@ -20,7 +20,7 @@ export declare type SnapshotsCommandOptionsType<TResolved = false> = {
     groupBy?: If<TResolved, SnapshotsAction["options"]["groupBy"]>;
     tag?: If<TResolved, string[]>;
 };
-export declare type SnapshotsCommandLogType = Unwrap<SnapshotsAction["exec"]>;
+export type SnapshotsCommandLogType = Unwrap<SnapshotsAction["exec"]>;
 export declare class SnapshotsCommand extends CommandAbstract<SnapshotsCommandOptionsType<false>, SnapshotsCommandOptionsType<true>> {
     onOptions(): import("../util/cli-util").OptionsType<SnapshotsCommandOptionsType<false>, SnapshotsCommandOptionsType<true>>;
     onExec(): Promise<number>;

package/Config/Config.d.ts

@@ -1,7 +1,7 @@
 import { PackageConfigType } from "./PackageConfig";
 import { RepositoryConfigType } from "./RepositoryConfig";
 import type { JSONSchema7 } from "json-schema";
-export declare type ConfigType = {
+export type ConfigType = {
     tempDir?: string;
     repositories: RepositoryConfigType[];
     packages: PackageConfigType[];

package/Config/PackageConfig.d.ts

@@ -4,12 +4,12 @@ import type { TaskConfigType } from "./TaskConfig";
 import { JSONSchema7 } from "json-schema";
 export declare const packageConfigDefinition: JSONSchema7;
 export declare const pathsObjectDefinition: JSONSchema7;
-export declare type PathsObjectType = {
+export type PathsObjectType = {
     type: "spawn";
     command: string;
     args?: string[];
 };
-export declare type PackageConfigType = {
+export type PackageConfigType = {
     name: string;
     enabled?: boolean;
     task?: TaskConfigType;

package/Config/PackageRepositoryConfig.d.ts

@@ -3,7 +3,7 @@ import { GitPackageRepositoryConfigType, gitRepositoryName } from "../Repository
 import { ResticPackageRepositoryConfigType, resticRepositoryName } from "../Repository/ResticRepository";
 import type { JSONSchema7 } from "json-schema";
 export declare const packageRepositoryConfigDefinition: JSONSchema7;
-export declare type PackageRepositoryConfigType = {
+export type PackageRepositoryConfigType = {
     names?: string[];
 } & ({
     type: typeof resticRepositoryName;

package/Config/PrunePolicyConfig.d.ts

@@ -1,4 +1,4 @@
 import { PruneActionsOptionsType } from "../Action/PruneAction";
 import { JSONSchema7 } from "json-schema";
 export declare const prunePolicyConfigDefinition: JSONSchema7;
-export declare type PrunePolicyConfigType = Pick<PruneActionsOptionsType, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;
+export type PrunePolicyConfigType = Pick<PruneActionsOptionsType, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;