@datatruck/cli 0.32.1 → 0.32.3

package/{Action → lib/Action}/BackupAction.d.ts

@@ -1,6 +1,6 @@
-import type { ConfigType } from "../Config/Config";
-import { PackageConfigType } from "../Config/PackageConfig";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import type { Config } from "../Config/Config";
+import { PackageConfig } from "../Config/PackageConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { PreSnapshot } from "../Repository/RepositoryAbstract";
 import { DataFormat } from "../utils/DataFormat";
 import { Listr3TaskResultEnd } from "../utils/list";
@@ -9,7 +9,7 @@ import { Streams } from "../utils/stream";
 import { IfRequireKeys } from "../utils/ts";
 export type BackupActionOptions = {
     repositoryNames?: string[];
-    repositoryTypes?: RepositoryConfigType["type"][];
+    repositoryTypes?: RepositoryConfig["type"][];
     packageNames?: string[];
     packageTaskNames?: string[];
     tags?: string[];
@@ -49,11 +49,11 @@ type Context = {
     };
 };
 export declare class BackupAction<TRequired extends boolean = true> {
-    readonly config: ConfigType;
+    readonly config: Config;
     readonly options: IfRequireKeys<TRequired, BackupActionOptions>;
-    constructor(config: ConfigType, options?: IfRequireKeys<TRequired, BackupActionOptions>);
+    constructor(config: Config, options?: IfRequireKeys<TRequired, BackupActionOptions>);
     protected prepareSnapshot(): PreSnapshot;
-    protected getPackages(snapshot: PreSnapshot): PackageConfigType[];
+    protected getPackages(snapshot: PreSnapshot): PackageConfig[];
     protected getRepositoryNames(repositoryNames: string[]): {
         name: string;
         mirrors: string[];
@@ -62,14 +62,14 @@ export declare class BackupAction<TRequired extends boolean = true> {
         repositoryName: string;
         snapshot: PreSnapshot;
         snapshotPath: string | undefined;
-        pkg: PackageConfigType;
+        pkg: PackageConfig;
         onProgress: (data: Progress) => void;
     }): Promise<void>;
     protected copy(data: {
         repositoryName: string;
         mirrorRepositoryName: string;
         snapshot: PreSnapshot;
-        pkg: PackageConfigType;
+        pkg: PackageConfig;
         onProgress: (data: Progress) => void;
     }): Promise<void>;
     dataFormat(result: Listr3TaskResultEnd<Context>[], options?: {

package/{Action → lib/Action}/BackupAction.js

@@ -13,7 +13,8 @@ const date_1 = require("../utils/date");
 const fs_1 = require("../utils/fs");
 const list_1 = require("../utils/list");
 const progress_1 = require("../utils/progress");
-const steps_1 = require("../utils/steps");
+const reportSteps_1 = require("../utils/reportSteps");
+const spawnSteps_1 = require("../utils/spawnSteps");
 const temp_1 = require("../utils/temp");
 const PruneAction_1 = require("./PruneAction");
 const assert_1 = require("assert");
@@ -345,13 +346,31 @@ class BackupAction {
                                         (report.when === "error" && !success);
                                     if (!enabled)
                                         return task.skip(`Report send skipped: ${reportIndex}`);
-                                    const text = this.dataFormat(result).format(report.format ?? "list");
-                                    await (0, steps_1.runSteps)(report.run, {
-                                        vars: {
-                                            dtt: { title: "DTT Backup", text, result, success },
-                                        },
-                                        verbose: this.options.verbose,
-                                    });
+                                    const message = this.dataFormat(result).format(report.format ?? "list");
+                                    if ((0, spawnSteps_1.isSpawnStep)(report.run)) {
+                                        await (0, spawnSteps_1.runSpawnSteps)(report.run, {
+                                            data: {
+                                                dtt: {
+                                                    message,
+                                                    result,
+                                                    success,
+                                                },
+                                            },
+                                            verbose: this.options.verbose,
+                                        });
+                                    }
+                                    else if ((0, reportSteps_1.isReportStep)(report.run)) {
+                                        await (0, reportSteps_1.runReportSteps)(report.run, {
+                                            data: {
+                                                title: "DTT Backup",
+                                                message,
+                                                success,
+                                            },
+                                        });
+                                    }
+                                    else {
+                                        throw new Error(`Invalid step type: ${report.run.type}`);
+                                    }
                                 },
                             });
                         }),

package/{Action → lib/Action}/ConfigAction.d.ts

@@ -1,5 +1,5 @@
 import { GlobalOptions } from "../Command/CommandAbstract";
-import type { ConfigType } from "../Config/Config";
+import type { Config } from "../Config/Config";
 import { IfRequireKeys } from "../utils/ts";
 export type ConfigActionOptions = {
     path: string;
@@ -8,20 +8,20 @@ export type ConfigActionOptions = {
 export declare class ConfigAction<TRequired extends boolean = true> {
     readonly options: IfRequireKeys<TRequired, ConfigActionOptions>;
     constructor(options: IfRequireKeys<TRequired, ConfigActionOptions>);
-    static validate(config: ConfigType): void;
-    static check(config: ConfigType): void;
-    static normalize(config: ConfigType): ConfigType;
-    static parseFile(path: string): Promise<ConfigType>;
+    static validate(config: Config): void;
+    static check(config: Config): void;
+    static normalize(config: Config): Config;
+    static parseFile(path: string): Promise<Config>;
     static fromGlobalOptionsWithPath(globalOptions: GlobalOptions<true>): Promise<{
         path: string;
-        data: ConfigType;
+        data: Config;
     } | {
         path: null;
-        data: ConfigType;
+        data: Config;
     }>;
-    static fromGlobalOptions(globalOptions: GlobalOptions<true>): Promise<ConfigType>;
+    static fromGlobalOptions(globalOptions: GlobalOptions<true>): Promise<Config>;
     exec(): Promise<{
         path: string;
-        data: ConfigType;
+        data: Config;
     }>;
 }

package/{Action → lib/Action}/ConfigAction.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigAction = void 0;
 const AppError_1 = require("../Error/AppError");
-const JsonSchema_1 = require("../JsonSchema/JsonSchema");
+const config_schema_1 = require("../config.schema");
 const config_1 = require("../utils/datatruck/config");
 const fs_1 = require("../utils/fs");
 const ajv_1 = __importDefault(require("ajv"));
@@ -16,7 +16,9 @@ class ConfigAction {
         this.options = options;
     }
     static validate(config) {
-        const validate = new ajv_1.default().compile(JsonSchema_1.schema);
+        const validate = new ajv_1.default({
+            allowUnionTypes: true,
+        }).compile(config_schema_1.configSchema);
         if (!validate(config))
             throw new AppError_1.AppError("Json schema error: " + JSON.stringify(validate.errors, null, 2));
     }

package/{Action → lib/Action}/CopyAction.d.ts

@@ -1,11 +1,11 @@
-import type { ConfigType } from "../Config/Config";
+import type { Config } from "../Config/Config";
 import { Snapshot } from "../Repository/RepositoryAbstract";
 import { DataFormat } from "../utils/DataFormat";
 import { Listr3TaskResultEnd } from "../utils/list";
 import { ProgressMode } from "../utils/progress";
 import { Streams } from "../utils/stream";
 import { IfRequireKeys } from "../utils/ts";
-export type CopyActionOptionsType = {
+export type CopyActionOptions = {
     ids?: string[];
     last?: number;
     repositoryName: string;
@@ -32,9 +32,9 @@ export type Context = {
     };
 };
 export declare class CopyAction<TRequired extends boolean = true> {
-    readonly config: ConfigType;
-    readonly options: IfRequireKeys<TRequired, CopyActionOptionsType>;
-    constructor(config: ConfigType, options: IfRequireKeys<TRequired, CopyActionOptionsType>);
+    readonly config: Config;
+    readonly options: IfRequireKeys<TRequired, CopyActionOptions>;
+    constructor(config: Config, options: IfRequireKeys<TRequired, CopyActionOptions>);
     dataFormat(result: Listr3TaskResultEnd<Context>[], options?: {
         streams?: Streams;
         verbose?: number;

package/{Action → lib/Action}/InitAction.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigType } from "../Config/Config";
+import type { Config } from "../Config/Config";
 import { IfRequireKeys } from "../utils/ts";
 export type InitActionOptions = {
     repositoryNames?: string[];
@@ -6,9 +6,9 @@ export type InitActionOptions = {
     verbose?: boolean;
 };
 export declare class InitAction<TRequired extends boolean = true> {
-    readonly config: ConfigType;
+    readonly config: Config;
     readonly options: IfRequireKeys<TRequired, InitActionOptions>;
-    constructor(config: ConfigType, options: IfRequireKeys<TRequired, InitActionOptions>);
+    constructor(config: Config, options: IfRequireKeys<TRequired, InitActionOptions>);
     exec(): Promise<{
         repositoryName: string;
         repositoryType: string;

package/{Action → lib/Action}/PruneAction.d.ts

@@ -1,5 +1,5 @@
-import type { ConfigType } from "../Config/Config";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import type { Config } from "../Config/Config";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { KeepObject } from "../utils/date";
 import { IfRequireKeys } from "../utils/ts";
 import { ExtendedSnapshot, SnapshotsActionOptions } from "./SnapshotsAction";
@@ -7,7 +7,7 @@ export type PruneActionsOptions = KeepObject & {
     ids?: string[];
     packageNames?: string[];
     repositoryNames?: string[];
-    repositoryTypes?: RepositoryConfigType["type"][];
+    repositoryTypes?: RepositoryConfig["type"][];
     tags?: string[];
     verbose?: boolean;
     groupBy?: SnapshotsActionOptions["groupBy"];
@@ -23,9 +23,9 @@ export type PruneResult = {
     })[];
 };
 export declare class PruneAction<TRequired extends boolean = true> {
-    readonly config: ConfigType;
+    readonly config: Config;
     readonly options: IfRequireKeys<TRequired, PruneActionsOptions>;
-    constructor(config: ConfigType, options: IfRequireKeys<TRequired, PruneActionsOptions>);
+    constructor(config: Config, options: IfRequireKeys<TRequired, PruneActionsOptions>);
     confirm(snapshots: PruneResult["snapshots"]): Promise<void>;
     exec(): Promise<PruneResult>;
 }

package/{Action → lib/Action}/RestoreAction.d.ts

@@ -1,5 +1,5 @@
-import type { ConfigType } from "../Config/Config";
-import { PackageConfigType } from "../Config/PackageConfig";
+import type { Config } from "../Config/Config";
+import { PackageConfig } from "../Config/PackageConfig";
 import { Snapshot } from "../Repository/RepositoryAbstract";
 import { TaskAbstract } from "../Task/TaskAbstract";
 import { DataFormat } from "../utils/DataFormat";
@@ -37,15 +37,15 @@ type Context = {
     restore: RestoreSnapshot;
 };
 export declare class RestoreAction<TRequired extends boolean = true> {
-    readonly config: ConfigType;
+    readonly config: Config;
     readonly options: IfRequireKeys<TRequired, RestoreActionOptions>;
     protected taskErrors: Record<string, Error[]>;
     protected repoErrors: Record<string, Error[]>;
-    constructor(config: ConfigType, options: IfRequireKeys<TRequired, RestoreActionOptions>);
+    constructor(config: Config, options: IfRequireKeys<TRequired, RestoreActionOptions>);
     protected findSnapshots(): Promise<RestoreSnapshot[]>;
     protected groupSnapshots(snapshots: RestoreSnapshot[]): RestoreSnapshot[];
     protected restore(data: {
-        pkg: PackageConfigType;
+        pkg: PackageConfig;
         task: TaskAbstract | undefined;
         snapshot: RestoreSnapshot;
         gc: GargabeCollector;

package/{Action → lib/Action}/SnapshotsAction.d.ts

@@ -1,5 +1,5 @@
-import type { ConfigType } from "../Config/Config";
-import { RepositoryConfigEnabledActionType } from "../Config/RepositoryConfig";
+import type { Config } from "../Config/Config";
+import { RepositoryConfigEnabledAction } from "../Config/RepositoryConfig";
 import { Snapshot } from "../Repository/RepositoryAbstract";
 import { IfRequireKeys } from "../utils/ts";
 export type SnapshotGroupByType = keyof Pick<ExtendedSnapshot, "packageName" | "repositoryName" | "repositoryType">;
@@ -27,8 +27,8 @@ export type ExtendedSnapshot = {
     repositoryType: string;
 } & Snapshot;
 export declare class SnapshotsAction<TRequired extends boolean = true> {
-    readonly config: ConfigType;
+    readonly config: Config;
     readonly options: IfRequireKeys<TRequired, SnapshotsActionOptions>;
-    constructor(config: ConfigType, options: IfRequireKeys<TRequired, SnapshotsActionOptions>);
-    exec(sourceAction?: RepositoryConfigEnabledActionType): Promise<ExtendedSnapshot[]>;
+    constructor(config: Config, options: IfRequireKeys<TRequired, SnapshotsActionOptions>);
+    exec(sourceAction?: RepositoryConfigEnabledAction): Promise<ExtendedSnapshot[]>;
 }

package/{Command → lib/Command}/BackupCommand.d.ts

@@ -1,12 +1,12 @@
 import { BackupAction } from "../Action/BackupAction";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
 export type BackupCommandOptions<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
     tag?: If<TResolved, string[]>;
     dryRun?: boolean;
     date?: string;

package/{Command → lib/Command}/CommandAbstract.d.ts

@@ -1,12 +1,12 @@
-import { ConfigType } from "../Config/Config";
-import { FormatType } from "../utils/DataFormat";
+import { Config } from "../Config/Config";
+import { DataFormatType } from "../utils/DataFormat";
 import { OptionsType } from "../utils/cli";
 import { ProgressMode } from "../utils/progress";
 import { Streams } from "../utils/stream";
 import { If, SimilarObject } from "../utils/ts";
 export type GlobalOptions<TResolved = false> = {
-    config: string | ConfigType;
-    outputFormat?: FormatType;
+    config: string | Config;
+    outputFormat?: DataFormatType;
     verbose?: number;
     tty?: If<TResolved, "auto" | boolean, "auto" | "true" | "false">;
     progress?: If<TResolved, ProgressMode, Exclude<ProgressMode, boolean> | "true" | "false">;

package/{Command → lib/Command}/ConfigCommand.d.ts

@@ -1,12 +1,12 @@
 import { ConfigAction } from "../Action/ConfigAction";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
 export type ConfigCommandOptions<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
 };
 export type ConfigCommandResult = Unwrap<ConfigAction["exec"]>;
 export declare class ConfigCommand extends CommandAbstract<ConfigCommandOptions<false>, ConfigCommandOptions<true>> {

package/{Command → lib/Command}/InitCommand.d.ts

@@ -1,10 +1,10 @@
 import { InitAction } from "../Action/InitAction";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
 export type InitCommandOptions<TResolved = false> = {
     repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
 };
 export type InitCommandResult = Unwrap<InitAction["exec"]>;
 export declare class InitCommand extends CommandAbstract<InitCommandOptions<false>, InitCommandOptions<true>> {

package/{Command → lib/Command}/PruneCommand.d.ts

@@ -1,5 +1,5 @@
 import { SnapshotGroupByType } from "../Action/SnapshotsAction";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { KeepObject } from "../utils/date";
 import { If } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
@@ -8,7 +8,7 @@ export type PruneCommandOptions<TResolved = false> = KeepObject & {
     longId?: boolean;
     package?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
     tag?: If<TResolved, string[]>;
     groupBy?: If<TResolved, SnapshotGroupByType[]>;
     dryRun?: boolean;

package/{Command → lib/Command}/RestoreCommand.d.ts

@@ -1,4 +1,4 @@
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { If } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
 export type RestoreCommandOptionsType<TResolved = false> = {
@@ -7,7 +7,7 @@ export type RestoreCommandOptionsType<TResolved = false> = {
     packageTask?: If<TResolved, string[]>;
     packageConfig?: boolean;
     repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
     tag?: If<TResolved, string[]>;
     initial?: boolean;
 };

package/{Command → lib/Command}/SnapshotsCommand.d.ts

@@ -1,5 +1,5 @@
 import { SnapshotsAction } from "../Action/SnapshotsAction";
-import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { RepositoryConfig } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
 export type SnapshotsCommandOptions<TResolved = false> = {
@@ -8,7 +8,7 @@ export type SnapshotsCommandOptions<TResolved = false> = {
     packageTask?: If<TResolved, string[]>;
     packageConfig?: boolean;
     repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
     longId?: boolean;
     last?: If<TResolved, number>;
     lastMinutely?: If<TResolved, number>;

package/lib/Config/Config.d.ts

@@ -0,0 +1,28 @@
+import { DataFormatType } from "../utils/DataFormat";
+import { DatatruckCronServerOptions } from "../utils/datatruck/cron-server";
+import { DatatruckRepositoryServerOptions } from "../utils/datatruck/repository-server";
+import { ReportStep } from "../utils/reportSteps";
+import { SpawnStep } from "../utils/spawnSteps";
+import { PackageConfig } from "./PackageConfig";
+import { PrunePolicyConfig } from "./PrunePolicyConfig";
+import { RepositoryConfig } from "./RepositoryConfig";
+export type Config = {
+    $schema?: string;
+    tempDir?: string;
+    minFreeDiskSpace?: string | number;
+    repositories: RepositoryConfig[];
+    packages: PackageConfig[];
+    server?: DatatruckServerOptions;
+    reports?: ReportConfig[];
+    prunePolicy?: PrunePolicyConfig;
+};
+export type DatatruckServerOptions = {
+    log?: boolean;
+    repository?: DatatruckRepositoryServerOptions;
+    cron?: DatatruckCronServerOptions;
+};
+export type ReportConfig = {
+    when?: "success" | "error";
+    format?: Exclude<DataFormatType, "custom" | "tpl">;
+    run: SpawnStep | ReportStep;
+};

package/lib/Config/PackageConfig.d.ts

@@ -0,0 +1,24 @@
+import { SpawnStep } from "../utils/spawnSteps";
+import { PackageRepositoryConfig } from "./PackageRepositoryConfig";
+import { PrunePolicyConfig } from "./PrunePolicyConfig";
+import type { TaskConfig } from "./TaskConfig";
+export type Meta = {
+    [name: string]: any;
+};
+export type PackageConfig = {
+    name: string;
+    enabled?: boolean;
+    task?: TaskConfig;
+    path?: string;
+    restorePath?: string;
+    meta?: Meta;
+    restorePermissions?: {
+        uid: string | number;
+        gid: string | number;
+    };
+    include?: (string | SpawnStep)[];
+    exclude?: (string | SpawnStep)[];
+    repositoryNames?: string[];
+    prunePolicy?: PrunePolicyConfig;
+    repositoryConfigs?: PackageRepositoryConfig[];
+};

package/lib/Config/PackageConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Config/PackageRepositoryConfig.d.ts

@@ -0,0 +1,15 @@
+import { DatatruckPackageRepositoryConfig, datatruckRepositoryName } from "../Repository/DatatruckRepository";
+import { GitPackageRepositoryConfig, gitRepositoryName } from "../Repository/GitRepository";
+import { ResticPackageRepositoryConfig, resticRepositoryName } from "../Repository/ResticRepository";
+export type PackageRepositoryConfig = {
+    names?: string[];
+} & ({
+    type: typeof resticRepositoryName;
+    config: ResticPackageRepositoryConfig;
+} | {
+    type: typeof datatruckRepositoryName;
+    config: DatatruckPackageRepositoryConfig;
+} | {
+    type: typeof gitRepositoryName;
+    config: GitPackageRepositoryConfig;
+});

package/lib/Config/PackageRepositoryConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Config/PrunePolicyConfig.d.ts

@@ -0,0 +1,2 @@
+import { PruneActionsOptions } from "../Action/PruneAction";
+export type PrunePolicyConfig = Pick<PruneActionsOptions, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;

package/lib/Config/PrunePolicyConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Config/RepositoryConfig.d.ts

@@ -0,0 +1,27 @@
+import { DatatruckRepositoryConfig, datatruckRepositoryName } from "../Repository/DatatruckRepository";
+import { GitRepositoryConfig, gitRepositoryName } from "../Repository/GitRepository";
+import { ResticRepositoryConfig, resticRepositoryName } from "../Repository/ResticRepository";
+export type RepositoryConfigType = RepositoryConfig["type"];
+export type RepositoryConfigEnabledAction = "backup" | "init" | "prune" | "restore" | "snapshots";
+export type RepositoryEnabledObject = {
+    [K in "defaults" | RepositoryConfigEnabledAction]?: boolean;
+};
+export type ResticRepositoryConfigItem = {
+    type: typeof resticRepositoryName;
+    config: ResticRepositoryConfig;
+};
+export type DatatruckRepositoryConfigItem = {
+    type: typeof datatruckRepositoryName;
+    config: DatatruckRepositoryConfig;
+};
+export type GitRepositoryConfigItem = {
+    type: typeof gitRepositoryName;
+    config: GitRepositoryConfig;
+};
+type CommonRepositoryConfig = {
+    name: string;
+    mirrorRepoNames?: string[];
+    enabled?: boolean | RepositoryEnabledObject;
+};
+export type RepositoryConfig = CommonRepositoryConfig & (ResticRepositoryConfigItem | DatatruckRepositoryConfigItem | GitRepositoryConfigItem);
+export {};

package/lib/Config/RepositoryConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Config/TaskConfig.d.ts

@@ -0,0 +1,31 @@
+import { GitTaskConfig, gitTaskName } from "../Task/GitTask";
+import { MariadbTaskConfig, mariadbTaskName } from "../Task/MariadbTask";
+import { MssqlTaskConfig, mssqlTaskName } from "../Task/MssqlTask";
+import { MysqlDumpTaskConfig, mysqlDumpTaskName } from "../Task/MysqlDumpTask";
+import { PostgresqlDumpTaskConfig, postgresqlDumpTaskName } from "../Task/PostgresqlDumpTask";
+import { ScriptTaskConfig, scriptTaskName } from "../Task/ScriptTask";
+export type GitTaskConfigItem = {
+    name: typeof gitTaskName;
+    config: GitTaskConfig;
+};
+export type MariadbTaskConfigItem = {
+    name: typeof mariadbTaskName;
+    config: MariadbTaskConfig;
+};
+export type MssqlTaskConfigItem = {
+    name: typeof mssqlTaskName;
+    config: MssqlTaskConfig;
+};
+export type MysqlDumpTaskConfigItem = {
+    name: typeof mysqlDumpTaskName;
+    config: MysqlDumpTaskConfig;
+};
+export type PostgresqlDumpTaskConfigItem = {
+    name: typeof postgresqlDumpTaskName;
+    config: PostgresqlDumpTaskConfig;
+};
+export type ScriptTaskConfigItem = {
+    name: typeof scriptTaskName;
+    config: ScriptTaskConfig;
+};
+export type TaskConfig = GitTaskConfigItem | MariadbTaskConfigItem | MssqlTaskConfigItem | MysqlDumpTaskConfigItem | PostgresqlDumpTaskConfigItem | ScriptTaskConfigItem;

package/lib/Config/TaskConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{Factory → lib/Factory}/CommandFactory.d.ts

@@ -20,7 +20,7 @@ export declare enum CommandEnum {
     cleanCache = "clean-cache",
     startServer = "start-server"
 }
-export type OptionsMapType = {
+export type OptionsMap = {
     [CommandEnum.config]: ConfigCommandOptions;
     [CommandEnum.init]: InitCommandOptions;
     [CommandEnum.snapshots]: SnapshotsCommandOptions;
@@ -31,15 +31,15 @@ export type OptionsMapType = {
     [CommandEnum.cleanCache]: CleanCacheActionOptions;
     [CommandEnum.startServer]: StartServerCommandOptions;
 };
-export type LogMapType = {
+export type LogMap = {
     [CommandEnum.config]: ConfigCommandResult;
     [CommandEnum.init]: InitCommandResult;
     [CommandEnum.snapshots]: SnapshotsCommandResult;
     [CommandEnum.backup]: BackupCommandResult;
 };
-export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>, configPath?: string): StartServerCommand;
-export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): Promise<number>;
+export declare function CommandFactory<TCommand extends keyof OptionsMap>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMap[TCommand], streams?: Partial<Streams>, configPath?: string): StartServerCommand;
+export declare function exec<TCommand extends keyof OptionsMap>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMap[TCommand], streams?: Partial<Streams>): Promise<number>;
 export declare function createActionInterface(globalOptions: GlobalOptions<true>): {
-    [K in keyof OptionsMapType as `${K}`]: (options: OptionsMapType[K]) => Promise<K extends keyof LogMapType ? LogMapType[K] : never>;
+    [K in keyof OptionsMap as `${K}`]: (options: OptionsMap[K]) => Promise<K extends keyof LogMap ? LogMap[K] : never>;
 };
 export declare function CommandConstructorFactory(type: CommandEnum): typeof StartServerCommand;

package/lib/Factory/RepositoryFactory.d.ts

@@ -0,0 +1,3 @@
+import type { RepositoryConfig } from "../Config/RepositoryConfig";
+import type { RepositoryAbstract } from "../Repository/RepositoryAbstract";
+export declare function createRepo(repository: RepositoryConfig): RepositoryAbstract<any>;

package/lib/Factory/TaskFactory.d.ts

@@ -0,0 +1,3 @@
+import { TaskConfig } from "../Config/TaskConfig";
+import type { TaskAbstract } from "../Task/TaskAbstract";
+export declare function createTask(task: TaskConfig): TaskAbstract;