@open-audio-stack/core 0.0.24 → 0.1.0

package/README.md

@@ -3,13 +3,27 @@
 ![Test](https://github.com/open-audio-stack/open-audio-stack-core/workflows/Test/badge.svg)
 ![Release](https://github.com/open-audio-stack/open-audio-stack-core/workflows/Release/badge.svg)
 
-Common methods package shared across Open Audio Stack compatible registries, command-line tools, apps and websites for handling installing DAW VST plugin dependencies.
+Common package shared across Open Audio Stack compatible registries, command-line tools, apps and websites for handling installing DAW VST plugin dependencies.
 
 ## Features
 
-- Config - Get types, formats, values, paths and urls.
-- FileSystem - Perform operations on directories and files.
-- Registry - Create an audio registry with packages and files.
+High-level classes enable use without writing business-logic:
+
+- Config - Set and get common configuration types, formats, values, paths and urls.
+- ConfigLocal - All the Config functionality including ability to load and save configuration to a json file.
+- Manager - Search, filter and get packages from a registry.
+- ManagerLocal - Install/uninstall packages locally and scan directories for existing packages.
+- Package - Create a new package to add to a registry.
+- Registry - Create an audio package registry with packages and files.
+
+Low-level methods/utilities for more custom/advanced implementations:
+
+- api - get different types of data using web requests
+- config - default config options
+- file - directory and file helper functions
+- package - validation and recommendation functions
+- registry - default registry config
+- utils - various other utilities
 
 ## Installation
 

package/build/classes/Config.d.ts

@@ -0,0 +1,41 @@
+import { Architecture } from '../types/Architecture.js';
+import { ConfigInterface } from '../types/Config.js';
+import { FileFormat } from '../types/FileFormat.js';
+import { FileType } from '../types/FileType.js';
+import { License } from '../types/License.js';
+import { PluginFormat } from '../types/PluginFormat.js';
+import { PluginType } from '../types/PluginType.js';
+import { PresetFormat } from '../types/PresetFormat.js';
+import { PresetType } from '../types/PresetType.js';
+import { ProjectFormat } from '../types/ProjectFormat.js';
+import { ProjectType } from '../types/ProjectType.js';
+import { SystemType } from '../types/SystemType.js';
+export declare class Config {
+    config: ConfigInterface;
+    constructor(config?: ConfigInterface);
+    get(key: keyof ConfigInterface): string | import("../types/Config.js").ConfigRegistry[] | undefined;
+    getAll(): ConfigInterface;
+    set(key: keyof ConfigInterface, val: any): void;
+    architecture(type: Architecture): import("../types/Architecture.js").ArchitectureOption;
+    architectures(): import("../types/Architecture.js").ArchitectureOption[];
+    fileFormat(format: FileFormat): import("../types/FileFormat.js").FileFormatOption;
+    fileFormats(): import("../types/FileFormat.js").FileFormatOption[];
+    fileType(type: FileType): import("../types/FileType.js").FileTypeOption;
+    fileTypes(): import("../types/FileType.js").FileTypeOption[];
+    license(type: License): import("../types/License.js").LicenseOption;
+    licenses(): import("../types/License.js").LicenseOption[];
+    pluginFormat(format: PluginFormat): import("../types/PluginFormat.js").PluginFormatOption;
+    pluginFormats(): import("../types/PluginFormat.js").PluginFormatOption[];
+    pluginType(type: PluginType): import("../types/PluginType.js").PluginTypeOption;
+    pluginTypes(): import("../types/PluginType.js").PluginTypeOption[];
+    presetFormat(format: PresetFormat): import("../types/PresetFormat.js").PresetFormatOption;
+    presetFormats(): import("../types/PresetFormat.js").PresetFormatOption[];
+    presetType(type: PresetType): import("../types/PresetType.js").PresetTypeOption;
+    presetTypes(): import("../types/PresetType.js").PresetTypeOption[];
+    projectFormat(format: ProjectFormat): import("../types/ProjectFormat.js").ProjectFormatOption;
+    projectFormats(): import("../types/ProjectFormat.js").ProjectFormatOption[];
+    projectType(type: ProjectType): import("../types/ProjectType.js").ProjectTypeOption;
+    projectTypes(): import("../types/ProjectType.js").ProjectTypeOption[];
+    system(type: SystemType): import("../types/SystemType.js").SystemTypeOption;
+    systems(): import("../types/SystemType.js").SystemTypeOption[];
+}

package/build/{Config.js → classes/Config.js}

@@ -1,34 +1,28 @@
-import { architectures } from './types/Architecture.js';
-import { fileFormats } from './types/FileFormat.js';
-import { fileTypes } from './types/FileType.js';
-import { licenses } from './types/License.js';
-import { pluginFormats } from './types/PluginFormat.js';
-import { pluginTypes } from './types/PluginType.js';
-import { presetFormats } from './types/PresetFormat.js';
-import { presetTypes } from './types/PresetType.js';
-import { projectFormats } from './types/ProjectFormat.js';
-import { projectTypes } from './types/ProjectType.js';
-import { systemTypes } from './types/SystemType.js';
+import { architectures } from '../types/Architecture.js';
+import { configDefaults } from '../helpers/config.js';
+import { fileFormats } from '../types/FileFormat.js';
+import { fileTypes } from '../types/FileType.js';
+import { licenses } from '../types/License.js';
+import { pluginFormats } from '../types/PluginFormat.js';
+import { pluginTypes } from '../types/PluginType.js';
+import { presetFormats } from '../types/PresetFormat.js';
+import { presetTypes } from '../types/PresetType.js';
+import { projectFormats } from '../types/ProjectFormat.js';
+import { projectTypes } from '../types/ProjectType.js';
+import { systemTypes } from '../types/SystemType.js';
 export class Config {
     config;
     constructor(config) {
-        this.config = Object.assign({
-            registries: [
-                {
-                    name: 'Open Audio Registry',
-                    url: 'https://open-audio-stack.github.io/open-audio-stack-registry',
-                },
-            ],
-        }, config);
+        this.config = { ...configDefaults(), ...config };
     }
     get(key) {
-        if (key)
-            return this.config[key];
+        return this.config[key];
+    }
+    getAll() {
         return this.config;
     }
     set(key, val) {
         this.config[key] = val;
-        return this.get(key);
     }
     // Architectures.
     architecture(type) {

package/build/classes/ConfigLocal.d.ts

@@ -0,0 +1,10 @@
+import { Config } from './Config.js';
+import { ConfigInterface } from '../types/Config.js';
+export declare class ConfigLocal extends Config {
+    path: string;
+    constructor(configPath: string, config?: ConfigInterface);
+    delete(): boolean | void;
+    load(): ConfigInterface;
+    save(): void;
+    set(key: keyof ConfigInterface, val: any): void;
+}

package/build/classes/ConfigLocal.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import { Config } from './Config.js';
+import { dirCreate, fileCreateJson, fileDelete, fileExists, fileReadJson } from '../helpers/file.js';
+import { configDefaultsLocal } from '../helpers/configLocal.js';
+export class ConfigLocal extends Config {
+    path;
+    constructor(configPath, config) {
+        super(config);
+        this.config = { ...configDefaultsLocal(), ...config };
+        this.path = configPath;
+        if (fileExists(this.path)) {
+            this.config = { ...this.config, ...this.load() };
+        }
+        else {
+            this.save();
+        }
+    }
+    delete() {
+        return fileDelete(this.path);
+    }
+    load() {
+        return fileReadJson(this.path);
+    }
+    save() {
+        dirCreate(path.dirname(this.path));
+        return fileCreateJson(this.path, this.getAll());
+    }
+    set(key, val) {
+        super.set(key, val);
+        this.save();
+    }
+}

package/build/classes/Manager.d.ts

@@ -0,0 +1,20 @@
+import { Config } from './Config.js';
+import { ConfigInterface } from '../types/Config.js';
+import { Package } from './Package.js';
+import { PackageVersion } from '../types/Package.js';
+import { RegistryPackages, RegistryType } from '../types/Registry.js';
+export declare class Manager {
+    protected config: Config;
+    protected packages: Map<string, Package>;
+    type: RegistryType;
+    constructor(type: RegistryType, config?: ConfigInterface);
+    addPackage(pkg: Package): void;
+    filter(query: string | number | object, field: keyof PackageVersion): Package[];
+    getPackage(slug: string): Package | undefined;
+    listPackages(): Package[];
+    removePackage(slug: string): void;
+    reset(): void;
+    search(query: string): Package[];
+    sync(): Promise<void>;
+    toJSON(): RegistryPackages;
+}

package/build/classes/Manager.js

@@ -0,0 +1,85 @@
+import { apiJson } from '../helpers/api.js';
+import { Config } from './Config.js';
+import { Package } from './Package.js';
+export class Manager {
+    config;
+    packages;
+    type;
+    constructor(type, config) {
+        this.config = new Config(config);
+        this.packages = new Map();
+        this.type = type;
+    }
+    addPackage(pkg) {
+        const pkgExisting = this.packages.get(pkg.slug);
+        if (pkgExisting) {
+            for (const [version, pkgVersion] of pkg.versions) {
+                pkgExisting.addVersion(version, pkgVersion);
+            }
+        }
+        else {
+            this.packages.set(pkg.slug, pkg);
+        }
+    }
+    filter(query, field) {
+        const results = [];
+        for (const [, pkg] of this.packages) {
+            const pkgVersion = pkg.getVersionLatest();
+            if (!pkgVersion)
+                continue;
+            if (pkgVersion[field] === query) {
+                results.push(pkg);
+            }
+        }
+        return results;
+    }
+    getPackage(slug) {
+        return this.packages.get(slug);
+    }
+    listPackages() {
+        return Array.from(this.packages.values());
+    }
+    removePackage(slug) {
+        if (!this.packages.has(slug))
+            return;
+        this.packages.delete(slug);
+    }
+    reset() {
+        this.packages.clear();
+    }
+    search(query) {
+        const queryLower = query.trim().toLowerCase();
+        const results = [];
+        for (const [slug, pkg] of this.packages) {
+            const pkgVersion = pkg.getVersionLatest();
+            if (!pkgVersion)
+                continue;
+            const pkgTags = pkgVersion.tags.map((str) => str.trim().toLowerCase());
+            if (slug.indexOf(queryLower) !== -1 ||
+                pkgVersion.name.trim().toLowerCase().indexOf(queryLower) !== -1 ||
+                pkgVersion.description.trim().toLowerCase().indexOf(queryLower) !== -1 ||
+                pkgTags.includes(queryLower)) {
+                results.push(pkg);
+            }
+        }
+        return results;
+    }
+    async sync() {
+        const registries = this.config.get('registries');
+        for (const index in registries) {
+            const json = await apiJson(registries[index].url);
+            const type = this.type;
+            for (const slug in json[type]) {
+                const pkg = new Package(slug, json[type][slug].versions);
+                this.addPackage(pkg);
+            }
+        }
+    }
+    toJSON() {
+        const data = {};
+        for (const [slug, pkg] of this.packages.entries()) {
+            data[slug] = pkg.toJSON();
+        }
+        return data;
+    }
+}

package/build/classes/ManagerLocal.d.ts

@@ -0,0 +1,11 @@
+import { PackageVersion } from '../types/Package.js';
+import { Manager } from './Manager.js';
+import { RegistryType } from '../types/Registry.js';
+import { ConfigInterface } from '../types/Config.js';
+export declare class ManagerLocal extends Manager {
+    protected typeDir: string;
+    constructor(type: RegistryType, config: ConfigInterface);
+    scan(): void;
+    install(slug: string, version?: string): Promise<void | PackageVersion>;
+    uninstall(slug: string, version?: string): Promise<void | PackageVersion>;
+}

package/build/classes/ManagerLocal.js

@@ -0,0 +1,135 @@
+import path from 'path';
+import { Package } from './Package.js';
+import { Manager } from './Manager.js';
+import { archiveExtract, dirCreate, dirDelete, dirEmpty, dirRead, fileCreate, fileCreateJson, fileExists, fileHash, fileOpen, fileReadJson, filesMove, isAdmin, runCliAsAdmin, } from '../helpers/file.js';
+import { isTests, pathGetSlug, pathGetVersion } from '../helpers/utils.js';
+import { apiBuffer } from '../helpers/api.js';
+import { FileType } from '../types/FileType.js';
+import { RegistryType } from '../types/Registry.js';
+import { pluginFormatDir } from '../types/PluginFormat.js';
+import { ConfigLocal } from './ConfigLocal.js';
+import { packageCompatibleFiles } from '../helpers/package.js';
+import { presetFormatDir } from '../types/PresetFormat.js';
+import { projectFormatDir } from '../types/ProjectFormat.js';
+export class ManagerLocal extends Manager {
+    typeDir;
+    constructor(type, config) {
+        super(type, config);
+        const configPath = path.join(config.appDir || '', 'config.json');
+        this.config = new ConfigLocal(configPath, config);
+        this.typeDir = this.config.get(`${type}Dir`);
+    }
+    scan() {
+        const filePaths = dirRead(`${this.typeDir}/**/index.json`);
+        filePaths.forEach((filePath) => {
+            const subPath = filePath.replace(`${this.typeDir}/`, '');
+            const pkgJson = fileReadJson(filePath);
+            pkgJson.installed = true;
+            const pkg = new Package(pathGetSlug(subPath));
+            pkg.addVersion(pathGetVersion(subPath), pkgJson);
+            this.addPackage(pkg);
+        });
+    }
+    async install(slug, version) {
+        // Get package information from registry.
+        const pkg = this.getPackage(slug);
+        if (!pkg)
+            return console.error(`Package ${slug} not found in registry`);
+        const versionNum = version || pkg.latestVersion();
+        const pkgVersion = pkg?.getVersion(versionNum);
+        if (!pkgVersion)
+            return console.error(`Package ${slug} version ${versionNum} not found in registry`);
+        if (pkgVersion.installed)
+            return pkgVersion;
+        // Elevate permissions if not running as admin.
+        if (!isAdmin() && !isTests()) {
+            let command = `--operation install --type ${this.type} --slug ${slug}`;
+            if (version)
+                command += ` --ver ${version}`;
+            await runCliAsAdmin(command);
+            return this.getPackage(slug)?.getVersion(versionNum);
+        }
+        // Create temporary directory to store downloaded files.
+        const dirDownloads = path.join(this.config.get('appDir'), 'downloads', this.type, slug, versionNum);
+        dirCreate(dirDownloads);
+        // Filter for compatible files and download.
+        const files = packageCompatibleFiles(pkgVersion);
+        if (!files.length)
+            return console.error(`Error: No compatible files found for ${slug}`);
+        for (const key in files) {
+            // Download file to temporary directory if not already downloaded.
+            const file = files[key];
+            const filePath = path.join(dirDownloads, path.basename(file.url));
+            if (!fileExists(filePath)) {
+                const fileBuffer = await apiBuffer(file.url);
+                fileCreate(filePath, Buffer.from(fileBuffer));
+            }
+            // Check file hash matches expected hash.
+            const hash = await fileHash(filePath);
+            if (hash !== file.sha256)
+                return console.error(`Error: ${filePath} hash mismatch`);
+            // If installer, run the installer.
+            if (file.type === FileType.Installer) {
+                fileOpen(filePath);
+            }
+            // If archive, extract the archive to temporary directory, then move individual files.
+            if (file.type === FileType.Archive) {
+                const dirSource = path.join(this.config.get('appDir'), file.type, this.type, slug, versionNum);
+                const dirSub = path.join(slug, versionNum);
+                let formatDir = pluginFormatDir;
+                if (this.type === RegistryType.Presets)
+                    formatDir = presetFormatDir;
+                if (this.type === RegistryType.Projects)
+                    formatDir = projectFormatDir;
+                archiveExtract(filePath, dirSource);
+                const filesMoved = filesMove(dirSource, this.typeDir, dirSub, formatDir);
+                // Output json metadata into every directory a file was added to.
+                filesMoved.forEach((fileMoved) => {
+                    const fileJson = path.join(path.dirname(fileMoved), 'index.json');
+                    fileCreateJson(fileJson, pkgVersion);
+                });
+            }
+        }
+        pkgVersion.installed = true;
+        return pkgVersion;
+    }
+    async uninstall(slug, version) {
+        // Get package information from registry.
+        const pkg = this.getPackage(slug);
+        if (!pkg)
+            return console.error(`Package ${slug} not found in registry`);
+        const versionNum = version || pkg.latestVersion();
+        const pkgVersion = pkg?.getVersion(versionNum);
+        if (!pkgVersion)
+            return console.error(`Package ${slug} version ${versionNum} not found in registry`);
+        if (!pkgVersion.installed)
+            return console.error(`Package ${slug} version ${versionNum} not installed`);
+        // Elevate permissions if not running as admin.
+        if (!isAdmin() && !isTests()) {
+            let command = `--operation uninstall --type ${this.type} --slug ${slug}`;
+            if (version)
+                command += ` --ver ${version}`;
+            await runCliAsAdmin(command);
+            return this.getPackage(slug)?.getVersion(versionNum);
+        }
+        // Delete all directories for this package version.
+        const versionDirs = dirRead(`${this.typeDir}/**/${slug}/${versionNum}`);
+        versionDirs.forEach((versionDir) => {
+            dirDelete(versionDir);
+        });
+        // Delete all empty directories for this package.
+        const pkgDirs = dirRead(`${this.typeDir}/**/${slug}`);
+        pkgDirs.forEach((pkgDir) => {
+            if (dirEmpty(pkgDir))
+                dirDelete(pkgDir);
+        });
+        // Delete all empty directories for the org.
+        const orgDirs = dirRead(`${this.typeDir}/**/${slug.split('/')[0]}`);
+        orgDirs.forEach((orgDir) => {
+            if (dirEmpty(orgDir))
+                dirDelete(orgDir);
+        });
+        delete pkgVersion.installed;
+        return this.getPackage(slug)?.getVersion(versionNum);
+    }
+}

package/build/classes/Package.d.ts

@@ -0,0 +1,13 @@
+import { PackageInterface, PackageVersion, PackageVersions } from '../types/Package.js';
+export declare class Package {
+    slug: string;
+    version: string;
+    versions: Map<string, PackageVersion>;
+    constructor(slug: string, versions?: PackageVersions);
+    addVersion(version: string, details: PackageVersion): void;
+    removeVersion(version: string): void;
+    getVersion(version: string): PackageVersion | undefined;
+    getVersionLatest(): PackageVersion | undefined;
+    latestVersion(): string;
+    toJSON(): PackageInterface;
+}

package/build/classes/Package.js

@@ -0,0 +1,50 @@
+import * as semver from 'semver';
+import { PackageVersionValidator } from '../helpers/package.js';
+import { isValidSlug } from '../helpers/utils.js';
+export class Package {
+    slug;
+    version;
+    versions;
+    constructor(slug, versions) {
+        if (!isValidSlug(slug))
+            console.error('Invalid package slug', slug);
+        this.slug = slug;
+        this.versions = versions ? new Map(Object.entries(versions)) : new Map();
+        this.version = this.latestVersion();
+    }
+    addVersion(version, details) {
+        if (this.versions.has(version))
+            return;
+        const validationError = PackageVersionValidator.safeParse(details).error;
+        if (validationError)
+            return console.error('Invalid package version', validationError.issues);
+        this.versions.set(version, details);
+        this.version = this.latestVersion();
+    }
+    removeVersion(version) {
+        if (!this.versions.has(version))
+            return;
+        this.versions.delete(version);
+        this.version = this.latestVersion();
+    }
+    getVersion(version) {
+        return this.versions.get(version);
+    }
+    getVersionLatest() {
+        return this.versions.get(this.latestVersion());
+    }
+    latestVersion() {
+        return Array.from(this.versions.keys()).sort(semver.rcompare)[0] || '0.0.0';
+    }
+    toJSON() {
+        const data = {
+            slug: this.slug,
+            version: this.version,
+            versions: {},
+        };
+        this.versions.forEach((details, version) => {
+            data.versions[version] = details;
+        });
+        return data;
+    }
+}

package/build/classes/Registry.d.ts

@@ -0,0 +1,14 @@
+import { Manager } from './Manager.js';
+import { RegistryInterface, RegistryType } from '../types/Registry.js';
+export declare class Registry {
+    name: string;
+    url: string;
+    version: string;
+    private managers;
+    constructor(name: string, url: string, version: string);
+    addManager(manager: Manager): void;
+    getManager(type: RegistryType): Manager;
+    reset(): void;
+    sync(): Promise<void>;
+    toJSON(): RegistryInterface;
+}

package/build/classes/Registry.js

@@ -0,0 +1,37 @@
+export class Registry {
+    name;
+    url;
+    version;
+    managers;
+    constructor(name, url, version) {
+        this.name = name;
+        this.url = url;
+        this.version = version;
+        this.managers = {};
+    }
+    addManager(manager) {
+        this.managers[manager.type] = manager;
+    }
+    getManager(type) {
+        return this.managers[type];
+    }
+    reset() {
+        Object.values(this.managers).forEach(manager => manager.reset());
+    }
+    async sync() {
+        for (const [, manager] of Object.entries(this.managers)) {
+            await manager.sync();
+        }
+    }
+    toJSON() {
+        const data = {
+            name: this.name,
+            url: this.url,
+            version: this.version,
+        };
+        for (const [type, manager] of Object.entries(this.managers)) {
+            data[type] = manager.toJSON();
+        }
+        return data;
+    }
+}

package/build/helpers/admin.d.ts

@@ -0,0 +1,9 @@
+import { RegistryType } from '../types/Registry.js';
+export interface Arguments {
+    operation: string;
+    type: RegistryType;
+    id: string;
+    ver: string;
+}
+export declare function adminArguments(): Arguments;
+export declare function adminInit(): Promise<void>;

package/build/helpers/admin.js

@@ -0,0 +1,28 @@
+// Run when Electron needs elevated privileges
+// npm run build && node ./build/helpers/admin.js --operation install --type plugins --id surge-synthesizer/surge
+// npm run build && node ./build/helpers/admin.js --operation uninstall --type plugins --id surge-synthesizer/surge
+import { ManagerLocal } from '../classes/ManagerLocal.js';
+import { dirApp } from './file.js';
+export function adminArguments() {
+    return {
+        operation: process.argv[3],
+        type: process.argv[5],
+        id: process.argv[7],
+        ver: process.argv[9],
+    };
+}
+export async function adminInit() {
+    const argv = adminArguments();
+    const manager = new ManagerLocal(argv.type, { appDir: dirApp() });
+    manager.sync();
+    if (argv.operation === 'install') {
+        await manager.install(argv.id, argv.ver);
+    }
+    else if (argv.operation === 'uninstall') {
+        await manager.uninstall(argv.id, argv.ver);
+    }
+    else {
+        console.log('Missing --operation argument');
+    }
+}
+adminInit();

package/build/helpers/config.d.ts

@@ -0,0 +1,2 @@
+import { ConfigInterface } from '../types/Config.js';
+export declare function configDefaults(): ConfigInterface;

package/build/helpers/config.js

@@ -0,0 +1,11 @@
+export function configDefaults() {
+    return {
+        registries: [
+            {
+                name: 'Open Audio Registry',
+                url: 'https://open-audio-stack.github.io/open-audio-stack-registry',
+            },
+        ],
+        version: '1.0.0',
+    };
+}

package/build/helpers/configLocal.d.ts

@@ -0,0 +1,2 @@
+import { ConfigInterface } from '../types/Config.js';
+export declare function configDefaultsLocal(): ConfigInterface;

package/build/helpers/configLocal.js

@@ -0,0 +1,11 @@
+import { configDefaults } from './config.js';
+import { dirApp, dirPlugins, dirPresets, dirProjects } from './file.js';
+export function configDefaultsLocal() {
+    return {
+        ...configDefaults(),
+        appDir: dirApp(),
+        pluginsDir: dirPlugins(),
+        presetsDir: dirPresets(),
+        projectsDir: dirProjects(),
+    };
+}

package/build/helpers/file.d.ts

@@ -3,7 +3,10 @@ import { PluginFile } from '../types/Plugin.js';
 import { PresetFile } from '../types/Preset.js';
 import { ProjectFile } from '../types/Project.js';
 import { ZodIssue } from 'zod';
-export declare function dirApp(): string;
+import { SystemType } from '../types/SystemType.js';
+export declare function archiveExtract(filePath: string, dirPath: string): Promise<void>;
+export declare function dirApp(dirName?: string): string;
+export declare function dirContains(parentDir: string, childDir: string): boolean;
 export declare function dirCreate(dir: string): string | false;
 export declare function dirDelete(dir: string): false | void;
 export declare function dirEmpty(dir: string): boolean;
@@ -18,19 +21,22 @@ export declare function dirProjects(): string;
 export declare function dirRead(dir: string, options?: any): string[];
 export declare function dirRename(dir: string, dirNew: string): void | boolean;
 export declare function fileCreate(filePath: string, data: string | Buffer): void;
+export declare function fileCreateJson(filePath: string, data: object): void;
 export declare function fileDate(filePath: string): Date;
 export declare function fileDelete(filePath: string): boolean | void;
 export declare function fileExec(filePath: string): void;
 export declare function fileExists(filePath: string): boolean;
-export declare function fileJsonCreate(filePath: string, data: object): void;
 export declare function fileHash(filePath: string, algorithm?: string): Promise<string>;
 export declare function fileMove(filePath: string, newPath: string): void | boolean;
+export declare function filesMove(dirSource: string, dirTarget: string, dirSub: string, formatDir: Record<string, string>): string[];
 export declare function fileOpen(filePath: string): Buffer;
 export declare function fileRead(filePath: string): string;
 export declare function fileReadJson(filePath: string): any;
 export declare function fileReadString(filePath: string): string;
 export declare function fileReadYaml(filePath: string): unknown;
 export declare function fileSize(filePath: string): number;
+export declare function isAdmin(): boolean;
 export declare function fileValidateMetadata(filePath: string, fileMetadata: PluginFile | PresetFile | ProjectFile): Promise<ZodIssue[]>;
+export declare function getPlatform(): SystemType;
+export declare function runCliAsAdmin(args: string): Promise<string>;
 export declare function zipCreate(filesPath: string, zipPath: string): void;
-export declare function zipExtract(content: any, dirPath: string): void;