@datatruck/cli 0.27.0 → 0.28.0

package/SessionDriver/ConsoleSessionDriver.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-import { Progress } from "../utils/progress";
-import { WriteDataType, ReadResultType, SessionDriverAbstract, SessionDriverOptions } from "./SessionDriverAbstract";
-type BadgeType = {
-    name: string;
-    value: string;
-    color: (input: string) => string;
-};
-type MessageType = {
-    sessionId: number;
-    level?: number;
-    textPrefix?: string;
-    text?: string;
-    badges: BadgeType[];
-    errorBadge?: BadgeType;
-    progress?: Progress;
-};
-type ConsoleSessionDriverOptions = SessionDriverOptions & {
-    progress?: "auto" | "tty" | "plain";
-};
-export declare class ConsoleSessionDriver extends SessionDriverAbstract<ConsoleSessionDriverOptions> {
-    protected lastMessage: MessageType | undefined;
-    protected lastMessageText: string | undefined;
-    protected prints: number;
-    protected renderInterval: NodeJS.Timeout;
-    protected rendering?: boolean;
-    protected lastColumns?: number;
-    protected startTime: number;
-    protected chron: {
-        start: () => number;
-        elapsed: (formatted?: boolean | undefined) => string | number;
-    };
-    protected tty: boolean;
-    onInit(): Promise<void>;
-    onEnd(data?: Record<string, any>): Promise<void>;
-    onRead(): Promise<ReadResultType[]>;
-    protected printMessage(message: MessageType, endMessage: boolean): void;
-    protected renderSpinner(text: string): string;
-    protected renderMessage(message: MessageType): string;
-    onWrite(data: WriteDataType): Promise<void>;
-}
-export {};

package/SessionDriver/ConsoleSessionDriver.js

@@ -1,208 +0,0 @@
-"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");
-const cli_1 = require("../utils/cli");
-const date_1 = require("../utils/date");
-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} `);
-class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract {
-    lastMessage;
-    lastMessageText;
-    prints = 0;
-    renderInterval;
-    rendering;
-    lastColumns;
-    startTime;
-    chron = (0, date_1.createChron)();
-    tty;
-    async onInit() {
-        this.tty = this.options.verbose
-            ? false
-            : this.options.progress === "auto"
-                ? process.stdout.isTTY
-                : this.options.progress === "tty";
-        this.chron.start();
-        this.renderInterval = setInterval(() => {
-            if (this.lastMessage)
-                this.printMessage(this.lastMessage, false);
-        }, 100);
-    }
-    async onEnd(data) {
-        clearInterval(this.renderInterval);
-        if (this.tty)
-            process.stdout.write(cli_1.showCursorCommand);
-        (0, cli_1.logVars)({
-            ...data,
-            elapsed: this.chron.elapsed(true),
-        });
-    }
-    async onRead() {
-        throw new AppError_1.AppError("Method not implemented");
-    }
-    printMessage(message, endMessage) {
-        const text = this.renderMessage(message);
-        if (!this.tty && this.lastMessageText === text) {
-            return;
-        }
-        if (!this.tty) {
-            process.stdout.write(`${this.renderSpinner(text)}\n`);
-        }
-        else {
-            const columns = process.stdout.columns;
-            const line = this.renderSpinner(text);
-            const [truncatedLine, truncated] = endMessage
-                ? [line, false]
-                : (0, cli_1.truncate)(line, columns);
-            if (this.lastColumns && columns !== this.lastColumns && truncated)
-                process.stdout.write(`${cli_1.clearCommand}\n`);
-            process.stdout.write(`${cli_1.clearCommand}${truncatedLine}${cli_1.hideCursorCommand}`);
-            this.lastColumns = columns;
-        }
-        this.prints++;
-        this.lastMessage = message;
-        this.lastMessageText = text;
-    }
-    renderSpinner(text) {
-        return text.replace("{spinner}", (0, chalk_1.grey)(this.tty ? (0, cli_1.renderSpinner)(this.prints) : "?"));
-    }
-    renderMessage(message) {
-        const badges = renderBadges([
-            ...message.badges,
-            ...(message.errorBadge ? [message.errorBadge] : []),
-        ]);
-        const padding = "   ".repeat(message.level ?? 0);
-        const sessionId = message.sessionId.toString().padStart(2, "0");
-        let parts = [
-            `${padding}${message.textPrefix} [${(0, chalk_1.grey)(sessionId)}] ${message.text}`,
-            badges,
-        ];
-        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_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} `);
-    }
-    async onWrite(data) {
-        if (data.action === SessionDriverAbstract_1.ActionEnum.Init)
-            return;
-        const message = {
-            sessionId: "sessionId" in data.data ? data.data.sessionId : data.data.id,
-            badges: [],
-        };
-        const isHeader = data.entity === SessionDriverAbstract_1.EntityEnum.BackupSession ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSession;
-        const hasProgress = isHeader ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.BackupSessionTask ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.BackupSessionRepository ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSessionTask ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository;
-        if (data.action === SessionDriverAbstract_1.ActionEnum.Start) {
-            if (isHeader) {
-                message.textPrefix = data.data.error ? (0, chalk_1.red)("⨉") : (0, chalk_1.green)("✓");
-            }
-            else {
-                message.textPrefix = hasProgress ? "{spinner}" : (0, chalk_1.grey)("?");
-            }
-        }
-        else if (data.action === SessionDriverAbstract_1.ActionEnum.End) {
-            message.textPrefix = data.data.error ? (0, chalk_1.red)("⨉") : (0, chalk_1.green)("✓");
-            if (data.data.error)
-                message.errorBadge = {
-                    name: "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,
-                };
-        }
-        else if (data.action === SessionDriverAbstract_1.ActionEnum.Progress) {
-            message.textPrefix = "{spinner}";
-        }
-        if (hasProgress) {
-            message.progress = data.data.progress;
-        }
-        if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSession ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSession) {
-            message.text = data.data.packageName;
-            message.badges.push({
-                name: "snap",
-                value: data.data.snapshotId.slice(0, 8),
-                color: chalk_1.cyan,
-            });
-        }
-        else if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSessionTask ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSessionTask) {
-            message.text = data.sessionData.packageName;
-            message.badges.push({
-                name: "task",
-                value: data.data.taskName,
-                color: chalk_1.cyan,
-            });
-        }
-        else if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSessionRepository ||
-            data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository) {
-            message.text = data.sessionData.packageName;
-            message.badges.push({
-                name: "repo",
-                value: data.data.repositoryName,
-                color: chalk_1.cyan,
-            });
-        }
-        if (isHeader && data.action === SessionDriverAbstract_1.ActionEnum.End) {
-            return;
-        }
-        const endMessage = this.tty && (!hasProgress || data.action === SessionDriverAbstract_1.ActionEnum.End || isHeader);
-        this.printMessage(message, endMessage);
-        if (endMessage)
-            process.stdout.write("\n");
-    }
-}
-exports.ConsoleSessionDriver = ConsoleSessionDriver;

package/SessionDriver/SessionDriverAbstract.d.ts

@@ -1,77 +0,0 @@
-import { BackupSessionEntity } from "../Entity/BackupSessionEntity";
-import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
-import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
-import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
-import { RestoreSessionRepositoryEntity } from "../Entity/RestoreSessionRepositoryEntity";
-import { RestoreSessionTaskEntity } from "../Entity/RestoreSessionTaskEntity";
-export declare enum ActionEnum {
-    Init = 0,
-    Start = 1,
-    Progress = 2,
-    End = 3
-}
-export declare enum EntityEnum {
-    BackupSession = 0,
-    BackupSessionTask = 1,
-    BackupSessionRepository = 2,
-    RestoreSession = 3,
-    RestoreSessionTask = 4,
-    RestoreSessionRepository = 5
-}
-export type WriteDataType = {
-    action: ActionEnum;
-    entity: EntityEnum.BackupSession;
-    data: BackupSessionEntity;
-} | {
-    action: ActionEnum;
-    entity: EntityEnum.BackupSessionRepository;
-    data: BackupSessionRepositoryEntity;
-    sessionData: BackupSessionEntity;
-} | {
-    action: ActionEnum;
-    entity: EntityEnum.BackupSessionTask;
-    data: BackupSessionTaskEntity;
-    sessionData: BackupSessionEntity;
-} | {
-    action: ActionEnum;
-    entity: EntityEnum.RestoreSession;
-    data: RestoreSessionEntity;
-} | {
-    action: ActionEnum;
-    entity: EntityEnum.RestoreSessionTask;
-    data: RestoreSessionTaskEntity;
-    sessionData: RestoreSessionEntity;
-} | {
-    action: ActionEnum;
-    entity: EntityEnum.RestoreSessionRepository;
-    data: RestoreSessionRepositoryEntity;
-    sessionData: RestoreSessionEntity;
-};
-export type ReadDataType = {
-    repositoryNames?: string[];
-    packageNames?: string[];
-    tags?: string[];
-    limit?: number | null;
-    verbose?: boolean;
-};
-export type ReadResultType = {
-    id: number;
-    snapshotId: string;
-    creationDate: string;
-    state: "started" | "ended";
-    packageName: string;
-    repositoryName: string;
-    repositoryType: string;
-    error: string | null;
-};
-export type SessionDriverOptions = {
-    verbose?: boolean;
-};
-export declare abstract class SessionDriverAbstract<TOptions extends SessionDriverOptions = SessionDriverOptions> {
-    readonly options: TOptions;
-    constructor(options: TOptions);
-    onInit(): Promise<void>;
-    abstract onWrite(data: WriteDataType): Promise<void>;
-    onEnd(data?: Record<string, any>): Promise<void>;
-    abstract onRead(data: ReadDataType, entity: EntityEnum): Promise<ReadResultType[]>;
-}

package/SessionDriver/SessionDriverAbstract.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionDriverAbstract = exports.EntityEnum = exports.ActionEnum = void 0;
-var ActionEnum;
-(function (ActionEnum) {
-    ActionEnum[ActionEnum["Init"] = 0] = "Init";
-    ActionEnum[ActionEnum["Start"] = 1] = "Start";
-    ActionEnum[ActionEnum["Progress"] = 2] = "Progress";
-    ActionEnum[ActionEnum["End"] = 3] = "End";
-})(ActionEnum || (exports.ActionEnum = ActionEnum = {}));
-var EntityEnum;
-(function (EntityEnum) {
-    EntityEnum[EntityEnum["BackupSession"] = 0] = "BackupSession";
-    EntityEnum[EntityEnum["BackupSessionTask"] = 1] = "BackupSessionTask";
-    EntityEnum[EntityEnum["BackupSessionRepository"] = 2] = "BackupSessionRepository";
-    EntityEnum[EntityEnum["RestoreSession"] = 3] = "RestoreSession";
-    EntityEnum[EntityEnum["RestoreSessionTask"] = 4] = "RestoreSessionTask";
-    EntityEnum[EntityEnum["RestoreSessionRepository"] = 5] = "RestoreSessionRepository";
-})(EntityEnum || (exports.EntityEnum = EntityEnum = {}));
-class SessionDriverAbstract {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async onInit() { }
-    async onEnd(data) { }
-}
-exports.SessionDriverAbstract = SessionDriverAbstract;

package/SessionDriver/SqliteSessionDriver.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="./vendor-typings/sqlite3" />
-import { WriteDataType, EntityEnum, ReadDataType, SessionDriverAbstract } from "./SessionDriverAbstract";
-import { Database } from "sqlite";
-import sqlite3 from "sqlite3";
-export declare class SqliteSessionDriver extends SessionDriverAbstract {
-    protected idMap: {
-        [entity in EntityEnum]?: Record<number, number>;
-    };
-    protected db: Database<sqlite3.Database, sqlite3.Statement>;
-    onInit(): Promise<void>;
-    private buildInsertStm;
-    private buildUpdateStm;
-    private exec;
-    onRead(data: ReadDataType, type: EntityEnum): Promise<any[]>;
-    private setMapId;
-    private getMapId;
-    private static getEntityTable;
-    private static getParentEntity;
-    onWrite(data: WriteDataType): Promise<void>;
-}

package/SessionDriver/SqliteSessionDriver.js

@@ -1,173 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteSessionDriver = void 0;
-const EntityDecorator_1 = require("../Decorator/EntityDecorator");
-const BackupSessionEntity_1 = require("../Entity/BackupSessionEntity");
-const BackupSessionRepositoryEntity_1 = require("../Entity/BackupSessionRepositoryEntity");
-const RestoreSessionEntity_1 = require("../Entity/RestoreSessionEntity");
-const RestoreSessionRepositoryEntity_1 = require("../Entity/RestoreSessionRepositoryEntity");
-const cli_1 = require("../utils/cli");
-const entity_1 = require("../utils/entity");
-const path_1 = require("../utils/path");
-const process_1 = require("../utils/process");
-const SessionDriverAbstract_1 = require("./SessionDriverAbstract");
-const assert_1 = require("assert");
-const os_1 = require("os");
-const path_2 = require("path");
-const sqlite_1 = require("sqlite");
-const sqlite3_1 = __importDefault(require("sqlite3"));
-class SqliteSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract {
-    idMap = {};
-    db;
-    async onInit() {
-        this.db = await (0, sqlite_1.open)({
-            filename: process.env["DATATRUCK_SQLITE_DB"] ??
-                (0, path_2.join)((0, os_1.homedir)(), "datatruck.sqlite"),
-            driver: sqlite3_1.default.Database,
-        });
-        await this.db.migrate({
-            migrationsPath: (0, path_2.join)(path_1.rootPath, "migrations"),
-        });
-    }
-    buildInsertStm(tableName, values) {
-        const keys = Object.keys(values);
-        const columnNames = keys.map((v) => `\`${v}\``).join(", ");
-        const paramNames = keys.map((v) => `:${v}`).join(", ");
-        return `INSERT INTO ${tableName} (${columnNames}) VALUES (${paramNames})`;
-    }
-    buildUpdateStm(tableName, values, pkColumnName = "id") {
-        const set = Object.keys(values)
-            .filter((v) => v !== pkColumnName)
-            .map((v) => `\`${v}\` = :${v}`)
-            .join(", ");
-        return `UPDATE ${tableName} SET ${set} WHERE ${pkColumnName} = :${pkColumnName}`;
-    }
-    async exec(query, cb) {
-        if (this.options.verbose) {
-            (0, cli_1.logExec)("query");
-            (0, process_1.logExecStdout)({ data: query, lineSalt: true });
-        }
-        const result = await cb();
-        if (this.options.verbose)
-            (0, process_1.logExecStdout)({ data: JSON.stringify(result, null, 2), lineSalt: true });
-        return result;
-    }
-    async onRead(data, type) {
-        const sessionMeta = (0, EntityDecorator_1.EntityDecoratorHandler)(type === SessionDriverAbstract_1.EntityEnum.BackupSession
-            ? BackupSessionEntity_1.BackupSessionEntity
-            : RestoreSessionEntity_1.RestoreSessionEntity);
-        const sessionRepositoryMeta = (0, EntityDecorator_1.EntityDecoratorHandler)(type === SessionDriverAbstract_1.EntityEnum.BackupSession
-            ? BackupSessionRepositoryEntity_1.BackupSessionRepositoryEntity
-            : RestoreSessionRepositoryEntity_1.RestoreSessionRepositoryEntity);
-        const sessionTable = (0, entity_1.makeTableSelector)(sessionMeta.get().tableName);
-        const repoTable = (0, entity_1.makeTableSelector)(sessionRepositoryMeta.get().tableName);
-        const where = {};
-        if (data.packageNames)
-            where[sessionTable("packageName")] = data.packageNames;
-        if (data.repositoryNames)
-            where[repoTable("repositoryName")] = data.repositoryNames;
-        if (data.packageNames)
-            where[sessionTable("packageName")] = data.packageNames;
-        if (type === SessionDriverAbstract_1.EntityEnum.BackupSession && data.tags)
-            data.tags.map((tag) => `(',' || ${sessionTable("tags")} || ',') LIKE '%,${tag},%' `);
-        let query = `
-      SELECT
-        ${sessionTable("id")},
-        ${sessionTable("snapshotId")},
-        ${sessionTable("creationDate")},
-        ${sessionTable("state")},
-        ${sessionTable("packageName")},
-        ${repoTable("repositoryName")},
-        ${repoTable("repositoryType")},
-        COALESCE(${repoTable("error")}, ${sessionTable("error")}) AS error
-      FROM 
-        ${sessionTable}
-      LEFT JOIN ${repoTable} ON
-        ${repoTable("sessionId")} = ${sessionTable("id")}
-      ORDER BY
-        ${sessionTable("id")} DESC
-    `;
-        if (data.limit)
-            query += `LIMIT ${data.limit}`;
-        return await this.exec(query, async () => await this.db.all(query));
-    }
-    setMapId(entity, id, value) {
-        if (!this.idMap[entity])
-            this.idMap[entity] = {};
-        const map = this.idMap[entity];
-        (0, assert_1.ok)(map);
-        map[id] = value;
-    }
-    getMapId(entity, id) {
-        const result = this.idMap[entity]?.[id];
-        if (!result)
-            throw new Error(`Entity id not found: ${entity}-${id}`);
-        return result;
-    }
-    static getEntityTable(entity) {
-        return {
-            [SessionDriverAbstract_1.EntityEnum.BackupSession]: "backup_session",
-            [SessionDriverAbstract_1.EntityEnum.BackupSessionRepository]: "backup_session_repository",
-            [SessionDriverAbstract_1.EntityEnum.BackupSessionTask]: "backup_session_task",
-            [SessionDriverAbstract_1.EntityEnum.RestoreSession]: "restore_session",
-            [SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository]: "restore_session_repository",
-            [SessionDriverAbstract_1.EntityEnum.RestoreSessionTask]: "restore_session_task",
-        }[entity];
-    }
-    static getParentEntity(entity) {
-        return {
-            [SessionDriverAbstract_1.EntityEnum.BackupSession]: SessionDriverAbstract_1.EntityEnum.BackupSession,
-            [SessionDriverAbstract_1.EntityEnum.BackupSessionRepository]: SessionDriverAbstract_1.EntityEnum.BackupSession,
-            [SessionDriverAbstract_1.EntityEnum.BackupSessionTask]: SessionDriverAbstract_1.EntityEnum.BackupSession,
-            [SessionDriverAbstract_1.EntityEnum.RestoreSession]: SessionDriverAbstract_1.EntityEnum.RestoreSession,
-            [SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository]: SessionDriverAbstract_1.EntityEnum.RestoreSession,
-            [SessionDriverAbstract_1.EntityEnum.RestoreSessionTask]: SessionDriverAbstract_1.EntityEnum.RestoreSession,
-        }[entity];
-    }
-    async onWrite(data) {
-        const tableName = SqliteSessionDriver.getEntityTable(data.entity);
-        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 };
-            stm = this.buildInsertStm(tableName, object);
-        }
-        else {
-            object = { ...object, id: this.getMapId(data.entity, id) };
-            if ("sessionId" in object) {
-                const parentEntity = SqliteSessionDriver.getParentEntity(data.entity);
-                object.sessionId = this.getMapId(parentEntity, object.sessionId);
-            }
-            stm = this.buildUpdateStm(tableName, object);
-        }
-        const params = Object.keys(object).reduce((result, name) => {
-            result[`:${name}`] = object[name];
-            return result;
-        }, {});
-        try {
-            const result = await this.exec(stm, async () => await this.db.run(stm, params));
-            if (data.action === SessionDriverAbstract_1.ActionEnum.Init &&
-                typeof result.lastID === "number") {
-                this.setMapId(data.entity, id, result.lastID);
-            }
-        }
-        catch (error) {
-            console.error({
-                query: stm,
-                params: params,
-            });
-            throw new Error(error.message);
-        }
-    }
-}
-exports.SqliteSessionDriver = SqliteSessionDriver;

package/SessionManager/BackupSessionManager.d.ts

@@ -1,45 +0,0 @@
-import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction";
-import { BackupSessionEntity } from "../Entity/BackupSessionEntity";
-import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
-import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
-import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
-import { ObjectVault } from "../utils/ObjectVault";
-import { Progress } from "../utils/progress";
-import SessionManagerAbstract from "./SessionManagerAbstract";
-export declare class BackupSessionManager extends SessionManagerAbstract {
-    sessionVault: ObjectVault<BackupSessionEntity>;
-    taskVault: ObjectVault<BackupSessionTaskEntity>;
-    repositoryVault: ObjectVault<BackupSessionRepositoryEntity>;
-    findId(data: {
-        packageName: string;
-    }): number;
-    findTaskId(data: {
-        packageName: string;
-        taskName: string;
-    }): number;
-    findRepositoryId(data: {
-        packageName: string;
-        repositoryName: string;
-    }): number;
-    initDrivers(): Promise<void>;
-    endDrivers(data?: Record<string, any>): Promise<void>;
-    protected alter(data: WriteDataType): Promise<number>;
-    readAll(options: BackupSessionsActionOptionsType): Promise<import("../SessionDriver/SessionDriverAbstract").ReadResultType[]>;
-    init(input: Pick<BackupSessionEntity, "packageName" | "snapshotId" | "tags">): Promise<number>;
-    initTask(input: Pick<BackupSessionTaskEntity, "sessionId" | "taskName">): Promise<number>;
-    initRepository(input: Pick<BackupSessionRepositoryEntity, "repositoryName" | "sessionId" | "repositoryType">): Promise<number>;
-    start(input: Pick<BackupSessionEntity, "id">): Promise<number>;
-    end(input: Pick<BackupSessionEntity, "id" | "error">): Promise<number>;
-    startTask(input: Pick<BackupSessionTaskEntity, "id">): Promise<number>;
-    progressTask(input: {
-        id: number;
-        progress: Progress;
-    }): Promise<number>;
-    endTask(input: Pick<BackupSessionTaskEntity, "id" | "error">): Promise<number>;
-    startRepository(input: Pick<BackupSessionRepositoryEntity, "id">): Promise<number>;
-    progressRepository(input: {
-        id: number;
-        progress: Progress;
-    }): Promise<number>;
-    endRepository(input: Pick<BackupSessionRepositoryEntity, "id" | "error">): Promise<number>;
-}