@wocker/ws 1.0.20 → 1.0.22

package/lib/keystore/types/Encryptor.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encryptor = void 0;
+const crypto = __importStar(require("crypto"));
+class Encryptor {
+    constructor(hash, salt) {
+        this._hash = hash;
+        this._salt = salt
+            ? Buffer.from(salt, "hex")
+            : crypto.randomBytes(16);
+    }
+    get hash() {
+        return this._hash;
+    }
+    get salt() {
+        return this._salt.toString("hex");
+    }
+    setPassword(password) {
+        return this;
+    }
+    encrypt() {
+    }
+    decrypt() {
+    }
+}
+exports.Encryptor = Encryptor;

package/lib/keystore/types/FileKeystore.d.ts

@@ -0,0 +1,17 @@
+type Secrets = Record<string, string>;
+type Props = {
+    passwordHash?: string;
+    secrets?: Secrets;
+};
+export declare abstract class FileKeystore {
+    passwordHash?: string;
+    protected secrets: Secrets;
+    constructor(data: Props);
+    abstract save(): void;
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    toObject(): {};
+    toString(): string;
+}
+export {};

package/lib/keystore/types/FileKeystore.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileKeystore = void 0;
+class FileKeystore {
+    constructor(data) {
+        const { passwordHash, secrets = {} } = data;
+        this.passwordHash = passwordHash;
+        this.secrets = secrets;
+    }
+    get(key) {
+        if (!(key in this.secrets)) {
+            return undefined;
+        }
+        return this.secrets[key];
+    }
+    set(key, value) {
+        this.secrets[key] = value;
+    }
+    delete(key) {
+        if (!(key in this.secrets)) {
+            return;
+        }
+        delete this.secrets[key];
+    }
+    toObject() {
+        return {};
+    }
+    toString() {
+        const secrets = JSON.stringify(this.secrets, null, 4);
+        return `// Wocker keystore\nexports.passwordHash = "${this.passwordHash}";\nexports.secrets = ${secrets};\n`;
+    }
+}
+exports.FileKeystore = FileKeystore;

package/lib/keystore/types/Keytar.d.ts

@@ -0,0 +1,8 @@
+import type { getPassword, setPassword, deletePassword, findPassword, findCredentials } from "keytar";
+export type Keytar = {
+    getPassword: typeof getPassword;
+    setPassword: typeof setPassword;
+    deletePassword: typeof deletePassword;
+    findPassword: typeof findPassword;
+    findCredentials: typeof findCredentials;
+};

package/lib/keystore/types/Keytar.js

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

package/lib/keystore/utils/createEncryptionKey.d.ts

@@ -0,0 +1 @@
+export declare const createEncryptionKey: (password: string, passwordHash: string) => Buffer<ArrayBufferLike>;

package/lib/keystore/utils/createEncryptionKey.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEncryptionKey = void 0;
+const crypto = __importStar(require("crypto"));
+const verifyPasswordHash_1 = require("./verifyPasswordHash");
+const createEncryptionKey = (password, passwordHash) => {
+    if (!(0, verifyPasswordHash_1.verifyPasswordHash)(password, passwordHash)) {
+        throw new Error("Invalid password provided");
+    }
+    const [, saltValue] = passwordHash.split(":"), salt = Buffer.from(saltValue, "hex");
+    return crypto.scryptSync(password, salt, 32);
+};
+exports.createEncryptionKey = createEncryptionKey;

package/lib/keystore/utils/createPasswordHash.d.ts

@@ -0,0 +1 @@
+export declare const createPasswordHash: (password: string, salt?: string) => string;

package/lib/keystore/utils/createPasswordHash.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPasswordHash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const createPasswordHash = (password, salt) => {
+    const saltBuffer = salt
+        ? Buffer.from(salt, "hex")
+        : crypto_1.default.randomBytes(16);
+    if (!salt) {
+        salt = saltBuffer.toString("hex");
+    }
+    const hash = crypto_1.default.createHmac("sha256", saltBuffer)
+        .update(password)
+        .digest("hex");
+    return `${hash}:${salt}`;
+};
+exports.createPasswordHash = createPasswordHash;

package/lib/keystore/utils/decrypt.d.ts

@@ -0,0 +1 @@
+export declare const decrypt: (encryptedKey: Buffer, encryptedValue: string) => string;

package/lib/keystore/utils/decrypt.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const decrypt = (encryptedKey, encryptedValue) => {
+    const buffer = Buffer.from(encryptedValue, "base64"), iv = buffer.subarray(0, 12), authTag = buffer.subarray(12, 28), encrypted = buffer.subarray(28).toString("base64"), decipher = crypto_1.default.createDecipheriv("aes-256-gcm", encryptedKey, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+};
+exports.decrypt = decrypt;

package/lib/keystore/utils/encrypt.d.ts

@@ -0,0 +1 @@
+export declare const encrypt: (encryptedKey: Buffer, value: string) => string;

package/lib/keystore/utils/encrypt.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const encrypt = (encryptedKey, value) => {
+    const iv = crypto_1.default.randomBytes(12), cipher = crypto_1.default.createCipheriv("aes-256-gcm", encryptedKey, iv);
+    let encrypted = cipher.update(value, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([
+        iv,
+        authTag,
+        Buffer.from(encrypted, "base64")
+    ]).toString("base64");
+};
+exports.encrypt = encrypt;

package/lib/keystore/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./createEncryptionKey";
+export * from "./createPasswordHash";
+export * from "./decrypt";
+export * from "./encrypt";
+export * from "./verifyPasswordHash";

package/lib/keystore/utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createEncryptionKey"), exports);
+__exportStar(require("./createPasswordHash"), exports);
+__exportStar(require("./decrypt"), exports);
+__exportStar(require("./encrypt"), exports);
+__exportStar(require("./verifyPasswordHash"), exports);

package/lib/keystore/utils/verifyPasswordHash.d.ts

@@ -0,0 +1 @@
+export declare const verifyPasswordHash: (password: string, passwordHash: string) => boolean;

package/lib/keystore/utils/verifyPasswordHash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPasswordHash = void 0;
+const createPasswordHash_1 = require("./createPasswordHash");
+const verifyPasswordHash = (password, passwordHash) => {
+    const [, salt = ""] = (passwordHash || "").split(":");
+    return passwordHash === (0, createPasswordHash_1.createPasswordHash)(password, salt);
+};
+exports.verifyPasswordHash = verifyPasswordHash;

package/lib/main.js

@@ -5,13 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = void 0;
 const core_1 = require("@wocker/core");
-const chalk_1 = __importDefault(require("chalk"));
+const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
 const AppModule_1 = require("./AppModule");
 const services_1 = require("./services");
 exports.app = {
     async run(args) {
         const app = await core_1.Factory.create(AppModule_1.AppModule);
-        const config = app.get(services_1.AppConfigService);
+        const configService = app.get(services_1.AppConfigService);
         const logger = app.get(services_1.LogService);
         try {
             const res = await app.run(args);
@@ -21,9 +21,14 @@ exports.app = {
             }
         }
         catch (err) {
-            console.error(chalk_1.default.red(err.message));
-            const { debug } = config.getConfig();
-            if (debug) {
+            if (typeof err.name === "string" && ["ExitPromptError", "CancelPromptError", "AbortPromptError"].includes(err.name)) {
+                return;
+            }
+            console.error(yoctocolors_cjs_1.default.red(err.message));
+            if (err instanceof core_1.CommandNotFoundError) {
+                return;
+            }
+            if (configService.config.debug) {
                 logger.error(err.stack || err.toString());
             }
         }

package/lib/makes/FS.d.ts

@@ -11,10 +11,10 @@ export declare class FS extends CoreFS {
     static mkdir(dirPath: string, options?: MakeDirectoryOptions): Promise<void>;
     static mkdirSync(path: string, options?: MakeDirectoryOptions): string;
     static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
-    static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
+    static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<void>;
     static appendFileSync(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): void;
     static readBytes(filePath: PathLike, position?: number | bigint, size?: number | bigint): Promise<Buffer>;
-    static readFileSync(filePath: PathLike): Buffer;
+    static readFileSync(filePath: PathLike): NonSharedBuffer;
     static writeFileSync(path: PathLike, data: any, options?: WriteFileOptions): void;
     static createWriteStream(path: PathLike): fs.WriteStream;
     static unlink(filePath: PathLike): Promise<void>;

package/lib/makes/FS.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
 const core_1 = require("@wocker/core");
@@ -101,12 +111,12 @@ class FS extends core_1.FS {
     }
     static async appendFile(path, data, options) {
         return new Promise((resolve, reject) => {
-            fs.appendFile(path, data, options, (error, data) => {
+            fs.appendFile(path, data, options, (error) => {
                 if (error) {
                     reject(error);
                 }
                 else {
-                    resolve(data);
+                    resolve(undefined);
                 }
             });
         });

package/lib/makes/GithubClient.d.ts

@@ -0,0 +1,14 @@
+import { AxiosInstance } from "axios";
+type RepositoryInfo = {
+    default_branch: string;
+};
+export declare class GithubClient {
+    owner: string;
+    repository: string;
+    constructor(owner: string, repository: string);
+    get axios(): AxiosInstance;
+    getInfo(): Promise<RepositoryInfo>;
+    getFile(branch: string, path: string): Promise<any>;
+    download(branch: string, dirPath: string): Promise<void>;
+}
+export {};

package/lib/makes/GithubClient.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const core_1 = require("@wocker/core");
+class GithubClient {
+    constructor(owner, repository) {
+        this.owner = owner;
+        this.repository = repository;
+    }
+    get axios() {
+        return axios_1.default.create({
+            headers: {
+                "User-Agent": "Wocker"
+            },
+        });
+    }
+    async getInfo() {
+        const response = await this.axios.get(`https://api.github.com/repos/${this.owner}/${this.repository}`, {
+            headers: {
+                "Accept": "application/vnd.github+json"
+            }
+        });
+        return response.data;
+    }
+    async getFile(branch, path) {
+        const response = await this.axios.get(`https://raw.githubusercontent.com/${this.owner}/${this.repository}/${branch}/${path}`, {
+            headers: {
+                "Accept": "application/vnd.github+json"
+            }
+        });
+        return response.data;
+    }
+    async download(branch, dirPath) {
+        const res = await this.axios.get(`https://github.com/${this.owner}/${this.repository}/archive/refs/heads/${branch}.zip`, {
+            responseType: "stream"
+        });
+        const fs = new core_1.FileSystem(dirPath);
+        if (!fs.exists()) {
+            fs.mkdir("", {
+                recursive: true
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const { Parse } = require("unzipper"), pipe = res.data.pipe(Parse());
+            pipe.on("entry", (entry) => {
+                const path = entry.path.replace(/^[^\/]+\//, "");
+                if (entry.type === "File") {
+                    entry.pipe(fs.createWriteStream(path));
+                }
+                else if (entry.type === "Directory") {
+                    fs.mkdir(path, {
+                        recursive: true
+                    });
+                }
+            });
+            pipe.on("end", () => resolve());
+            pipe.on("error", reject);
+        });
+    }
+}
+exports.GithubClient = GithubClient;

package/lib/makes/Http.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Http = void 0;
 const axios_1 = __importStar(require("axios"));

package/lib/makes/Plugin.d.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+export declare class Plugin {
+    readonly type: any;
+    readonly name: string;
+    constructor(type: any);
+}

package/lib/makes/Plugin.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+require("reflect-metadata");
+const core_1 = require("@wocker/core");
+class Plugin {
+    constructor(type) {
+        this.type = type;
+        const pluginName = Reflect.getMetadata(core_1.PLUGIN_NAME_METADATA, this.type);
+        if (!pluginName || typeof pluginName !== "string") {
+            throw new Error("Invalid plugin package");
+        }
+        this.name = pluginName;
+    }
+}
+exports.Plugin = Plugin;

package/lib/makes/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./FS";
 export * from "./Http";
 export * from "./Logger";
+export * from "./Plugin";

package/lib/makes/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./FS"), exports);
 __exportStar(require("./Http"), exports);
 __exportStar(require("./Logger"), exports);
+__exportStar(require("./Plugin"), exports);

package/lib/plugins/MongodbPlugin.js

@@ -21,13 +21,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };

package/lib/plugins/index.d.ts

@@ -1,3 +1 @@
-export * from "./ElasticSearchPlugin";
 export * from "./MongodbPlugin";
-export * from "./ProxmoxPlugin";

package/lib/plugins/index.js

@@ -14,6 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ElasticSearchPlugin"), exports);
 __exportStar(require("./MongodbPlugin"), exports);
-__exportStar(require("./ProxmoxPlugin"), exports);

package/lib/repositories/PresetRepository.d.ts

@@ -0,0 +1,23 @@
+import { AppConfig, Preset, PresetSource } from "@wocker/core";
+import { AppConfigService } from "../services/AppConfigService";
+import { LogService } from "../services/LogService";
+type PresetData = {
+    name: string;
+    source: PresetSource;
+    path?: string;
+};
+type SearchOptions = Partial<{
+    name: string;
+    source: string;
+    path: string;
+}>;
+export declare class PresetRepository {
+    protected readonly appConfig: AppConfigService;
+    protected readonly logService: LogService;
+    constructor(appConfig: AppConfigService, logService: LogService);
+    protected load(data: PresetData): Preset;
+    protected configs(): AppConfig["presets"];
+    search(options?: SearchOptions): Preset[];
+    searchOne(options?: SearchOptions): Preset | null;
+}
+export {};