@e-mc/types 0.0.1

package/lib/android.d.ts

@@ -0,0 +1,53 @@
+import type { FinalizedElement, ControllerSettingsDirectoryUI as IControllerSettingsDirectoryUI } from './squared';
+
+import type { ExternalAsset } from './asset';
+import type { RequestData as IRequestData } from './node';
+
+export interface DocumentOutput {
+    targetAPI?: NumString;
+    manifest?: ManifestData;
+    namespace?: string;
+    profileable?: boolean | StringOfArray;
+    dependencies?: string[];
+    directories?: ControllerSettingsDirectoryUI;
+    elements?: FinalizedElement[];
+    projectName?: string;
+    mainParentDir?: string;
+    mainSrcDir?: string;
+    mainActivityFile?: string;
+    javaVersion?: NumString;
+    versionName?: string;
+    versionCode?: number;
+    dataBinding?: boolean;
+    commands?: ArrayOf<StringOfArray>;
+    extensionData?: PlainObject;
+}
+
+export interface RequestData extends IRequestData<ExternalAsset>, DocumentOutput {}
+
+export interface ManifestData {
+    package?: string;
+    application?: {
+        supportsRtl?: boolean;
+        label?: string;
+        theme?: string;
+        metaData?: { name?: string; resource?: string; value?: string }[];
+        activity?: ObjectMap<{
+            layout?: {
+                defaultWidth?: string;
+                defaultHeight?: string;
+                minWidth?: string;
+                minHeight?: string;
+                gravity?: string;
+            };
+        }>;
+        activityName?: string;
+        fontProvider?: string;
+    };
+}
+
+export interface ControllerSettingsDirectoryUI extends IControllerSettingsDirectoryUI {
+    main: string;
+    animation: string;
+    theme: string;
+}

package/lib/asset.d.ts

@@ -0,0 +1,71 @@
+import type { BundleAction, FileAsset, LocationUri, MimeTypeAction } from './squared';
+
+import type { IFileManager, IModule } from './index';
+import type { IAbortComponent } from './core';
+import type { FetchType } from './filemanager';
+
+interface ProcessInit {
+    threadCount: number;
+    startTime: number;
+    timeout: number;
+}
+
+export interface BinaryAction {
+    binOpts?: string[];
+}
+
+export interface FileData<T extends ExternalAsset> extends MimeTypeAction {
+    file: T;
+}
+
+export interface FileCommand<T extends ExternalAsset> extends FileData<T> {
+    command?: string;
+    outputType?: string;
+}
+
+export interface IFileThread<T extends ExternalAsset = ExternalAsset> extends IAbortComponent, Required<FileData<T>> {
+    threadCount: number;
+    readonly startTime: number;
+    openThread(instance: IModule, timeout?: number): boolean;
+    closeThread(instance: IModule, callback?: FunctionType<void>): boolean;
+    getObject<U extends FileCommand<T>>(data?: PlainObject): U;
+    get host(): IFileManager<T>;
+    get queuedTasks(): FunctionType<void>[];
+}
+
+export interface FileThreadConstructor<T extends ExternalAsset = ExternalAsset> {
+    readonly prototype: IFileThread<T>;
+    new(host: IFileManager<T>, file: ExternalAsset, threadCount: number): IFileThread<T>;
+}
+
+export interface OutputFinalize<T extends ExternalAsset> extends FileCommand<T> {
+    output: string;
+    baseDirectory?: string;
+}
+
+export interface InitialValue extends Partial<LocationUri>, MimeTypeAction {
+    localUri?: string;
+    buffer?: Buffer;
+    etag?: string;
+    cacheable?: boolean;
+}
+
+export interface ExternalAsset extends FileAsset, BundleAction, BinaryAction {
+    id?: number;
+    url?: URL;
+    socketPath?: string;
+    buffer?: Buffer;
+    localUri?: string;
+    fetchType?: FetchType;
+    sourceUTF8?: string;
+    transforms?: string[];
+    descendants?: string[];
+    torrentFiles?: string[];
+    sourceFiles?: string[];
+    initialValue?: InitialValue;
+    processModule?: ObjectMap<ProcessInit>;
+    etag?: string;
+    lastModified?: string;
+    contentLength?: number;
+    invalid?: boolean;
+}

package/lib/chrome.d.ts

@@ -0,0 +1,106 @@
+import type { AttributeAction, ConditionProperty, CssConditionData, ElementAction, ExcludeAction, FileAsset, FromAction, HashAction, DataSource as IDataSource, ImportAction, MetadataAction, ViewEngine, XmlTagNode } from './squared';
+
+import type { UploadAction } from './cloud';
+import type { CascadeAction, DbSource } from './db';
+import type { RequestData as IRequestData } from './node';
+
+interface ImportFrom {
+    placeholder: string;
+    original: string;
+    uri: string;
+    type?: string;
+    dynamic?: boolean;
+}
+
+interface DataObject extends CascadeAction {
+    format?: string;
+    options?: PlainObject;
+}
+
+export interface DocumentOutput {
+    productionRelease?: boolean | string;
+    productionIncremental?: boolean;
+    useOriginalHtmlPage?: boolean | string;
+    useUnsafeReplace?: ArrayOf<"html" | "css"> | boolean;
+    stripCommentsAndCDATA?: boolean | string;
+    normalizeHtmlOutput?: boolean | string;
+    escapeReservedCharacters?: boolean;
+    ignoreServerCodeBlocks?: string[];
+    webBundle?: {
+        rootDirAlias?: string;
+        baseUrl?: string;
+        primaryUrl?: string;
+        copyTo?: string;
+        rewriteHtmlPage?: boolean | string;
+        excludeHtmlPage?: boolean;
+        excludeTransforms?: boolean;
+        includeScopes?: string[];
+        excludeScopes?: string[];
+    };
+    templateMap?: TemplateMap;
+}
+
+export interface RequestData extends IRequestData<ChromeAsset>, Readonly<DocumentOutput>, Readonly<CssRuleData> {}
+
+export interface ChromeAsset extends FileAsset, AttributeAction, ElementAction, MetadataAction<PlainObject>, UploadAction, HashAction, ExcludeAction, ImportAction<ImportFrom[] | boolean>, FromAction {
+    preserve?: boolean;
+    static?: boolean;
+    editing?: boolean;
+    inlineContent?: string;
+    originAddress?: boolean;
+}
+
+export interface TemplateMap extends PlainObject {
+    html?: ObjectMap<StringMap>;
+    js?: ObjectMap<StringMap>;
+    css?: ObjectMap<StringMap>;
+    data?: StringMap;
+}
+
+export interface CssRuleData {
+    usedVariables?: string[];
+    usedFontFace?: string[];
+    usedKeyframes?: string[];
+    unusedStyles?: string[];
+    unusedMedia?: string[];
+    unusedContainer?: string[];
+    unusedSupports?: string[];
+    unusedAtRules?: UnusedAtRule[];
+}
+
+export interface UnusedAtRule {
+    selector?: string;
+    media?: ConditionProperty;
+    supports?: ConditionProperty;
+    container?: CssConditionData & Partial<ConditionProperty>;
+    layer?: string[];
+}
+
+export interface DataSource<T = string> extends IDataSource<T>, ElementAction {
+    source: "cloud" | "uri" | "local" | "export" | DbSource;
+    element?: XmlTagNode;
+    type?: "text" | "attribute" | "display";
+    dynamic?: boolean;
+    value?: StringOfArray | ObjectMap<unknown>;
+    template?: string;
+    viewEngine?: ViewEngine | string;
+    ignoreEmpty?: boolean;
+}
+
+export interface UriDataSource extends DataSource, DataObject {
+    source: "uri";
+}
+
+export interface LocalDataSource extends DataSource, DataObject {
+    source: "local";
+    pathname?: string;
+}
+
+export interface ExportDataSource extends DataSource, CascadeAction {
+    source: "export";
+    execute?: FunctionType;
+    pathname?: string;
+    settings?: string;
+    params?: unknown;
+    persist?: boolean;
+}

package/lib/cloud.d.ts

@@ -0,0 +1,89 @@
+import type { DbDataSource, LocationUri, StorageAction } from './squared';
+
+import type { ExternalAsset } from './asset';
+
+export interface UploadAction {
+    cloudUrl?: string;
+}
+
+export interface CloudAsset<T = CloudStorage> extends ExternalAsset, UploadAction, StorageAction<T> {}
+
+export interface CloudService {
+    service: string;
+    credential?: unknown;
+}
+
+export interface CloudDatabase<T = unknown, U = PlainObject, V = unknown, W = unknown> extends CloudService, DbDataSource<T, U, V> {
+    id?: string;
+    params?: W;
+}
+
+export interface CloudStorage extends CloudService {
+    bucket?: string;
+    admin?: CloudStorageAdmin;
+    upload?: CloudStorageUpload;
+    download?: CloudStorageDownload;
+}
+
+export interface CloudStorageAdmin<T = unknown, U = string, V = unknown> extends CloudStorageACL<U> {
+    emptyBucket?: boolean;
+    configBucket?: {
+        create?: T;
+        policy?: V;
+        website?: BucketWebsiteOptions;
+    };
+    recursive?: boolean;
+    preservePath?: boolean;
+}
+
+export interface CloudStorageAction<T = unknown, U = string, V = unknown> extends Partial<LocationUri> {
+    active?: boolean;
+    overwrite?: boolean;
+    admin?: CloudStorageAdmin<T, U, V>;
+}
+
+export interface CloudStorageUpload<T = unknown, U = string, V = unknown, W = string> extends CloudStorageACL<U>, CloudStorageAction<V, W> {
+    buffer?: Null<Buffer>;
+    contentType?: string;
+    metadata?: Record<string, string>;
+    options?: T;
+    fileGroup?: [BufferContent, string, string?][];
+    localStorage?: boolean;
+    endpoint?: string;
+    all?: boolean;
+}
+
+export interface CloudStorageACL<T = string> {
+    publicRead?: boolean | 0;
+    acl?: T;
+}
+
+export interface CloudStorageDownload<T = unknown> extends CloudStorageAction {
+    versionId?: string;
+    deleteObject?: T;
+    waitStatus?: boolean;
+}
+
+export interface BucketWebsiteOptions {
+    indexPage?: string;
+    errorPage?: string;
+    indexPath?: string;
+    errorPath?: string;
+}
+
+export interface FunctionData {
+    bucket: string;
+}
+
+export interface UploadData<T = unknown, U = string, V = unknown, W = string> extends FunctionData {
+    upload: CloudStorageUpload<T, U, V, W>;
+    localUri: string;
+    buffer: Buffer;
+}
+
+export interface DownloadData<T = unknown> extends FunctionData {
+    download: CloudStorageDownload<T>;
+}
+
+export type CloudFeatures = "storage" | "database";
+export type CloudFunctions = "upload" | "download";

package/lib/compat-v4.d.ts

@@ -0,0 +1,125 @@
+import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IImage, IModule, ImageConstructor, ModuleConstructor, WatchConstructor } from './index';
+
+import type { ExternalAsset, IFileThread } from './asset';
+import type { CacheOptions } from './core';
+import type { QueryResult } from './db';
+import type { ITransformSeries, OutV3, TransformSeriesConstructor } from './document';
+import type { IHttpMemoryCache } from './filemanager';
+import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
+import type { CloneObjectOptions, GetFunctionsOptions } from './module';
+import type { LogFailOptions, LogType, LogValue } from './logger';
+import type { HostConfig, OpenOptions, ProxySettings } from './request';
+import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings } from './settings';
+
+import type { Readable, Writable } from 'stream';
+import type { OutgoingHttpHeaders } from 'http';
+import type { LookupFunction } from 'net';
+
+// @ts-ignore
+import type { BytesOptions } from 'bytes';
+
+type CpuUsage = NodeJS.CpuUsage;
+
+export interface IModuleLibV4 {
+    isString(value: unknown): value is string;
+    isObject<T = object>(value: unknown): value is T;
+    isPlainObject<T = PlainObject>(value: unknown): value is T;
+    escapePattern(value: unknown, lookBehind?: boolean): string;
+    generateUUID(format?: string, dictionary?: string): string;
+    validateUUID(value: unknown): value is string;
+    cloneObject<T, U = unknown>(data: T, options?: boolean | WeakSet<object> | CloneObjectOptions<U>): T;
+    coerceObject<T = unknown>(data: T, parseString?: FunctionType<unknown, string> | boolean, cache?: boolean): T;
+    asFunction<T = unknown, U = FunctionType<Promise<T> | T>>(value: unknown, sync?: boolean): Null<U>;
+    isFileHTTP(value: string | URL): boolean;
+    isFileUNC(value: string | URL): boolean;
+    isPathUNC(value: string | URL): boolean;
+    toTimeMs(hrtime: HighResolutionTime, format?: boolean): NumString;
+    renameExt(value: string, ext: string, when?: string): string;
+    existsSafe(value: string, isFile?: boolean): boolean;
+    readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<BufferContent>;
+    getFunctions<T extends FunctionType>(values: unknown[], absolute?: boolean | GetFunctionsOptions, sync?: boolean, outFailed?: string[]): T[];
+    formatSize(value: NumString, options?: BytesOptions): NumString;
+    hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
+    hasSize(value: string, keepEmpty?: boolean): boolean;
+    getSize(value: string, diskUsed?: boolean): number;
+    byteLength(value: BufferContent, encoding?: BufferEncoding): number;
+    cleanupStream(target: Readable | Writable, pathname?: string): void;
+    allSettled: AllSettledMethod;
+}
+
+export interface IModuleCompatV4<T extends IHost = IHost> extends IModule<T> {
+    set startCPU(value);
+    get startCPU(): Null<CpuUsage>;
+}
+
+export interface ModuleCompatV4Constructor extends ModuleConstructor, IModuleLibV4 {
+    readonly prototype: IModuleCompatV4;
+    new(...args: unknown[]): IModuleCompatV4;
+}
+
+export interface IFileManagerCompatV4<T extends ExternalAsset = ExternalAsset> extends IFileManager<T> {
+    cacheHttpRequest: boolean | FirstOf<string>;
+    cacheHttpRequestBuffer: IHttpMemoryCache<T>;
+    fetchTimeout: number;
+    httpProxy: Null<ProxySettings>;
+    acceptEncoding: boolean;
+    keepAliveTimeout: number;
+    addDns(hostname: string, address: string, family?: NumString): void;
+    lookupDns(hostname: string): LookupFunction;
+    getHttpProxy(uri: string, localhost?: boolean): Null<ProxySettings>;
+    getHttpHeaders(uri: string): Undef<OutgoingHttpHeaders>;
+    createHttpRequest(uri: string | URL, options?: OpenOptions): HostConfig;
+    getHttpClient(uri: string | URL, options: OpenOptions): HttpRequestClient;
+    set httpVersion(value);
+    get httpVersion(): Null<HttpProtocolVersion>;
+    set ipVersion(value);
+    get ipVersion(): InternetProtocolVersion;
+}
+
+export interface FileManagerCompatV4Constructor<T extends ExternalAsset = ExternalAsset> extends FileManagerConstructor<T> {
+    fromHttpStatusCode(value: NumString): string;
+    resetHttpHost(version?: HttpProtocolVersion): void;
+    defineHttpBuffer(options: HttpMemorySettings): void;
+    defineHttpSettings(options: HttpSettings): void;
+    defineHttpAgent(options: HttpAgentSettings): void;
+    defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
+    clearDnsLookup(): void;
+    getAria2Path(): string;
+    clearHttpBuffer(percent?: number, limit?: number): void;
+    readonly prototype: IFileManagerCompatV4<T>;
+    new(...args: unknown[]): IFileManagerCompatV4<T>;
+}
+
+export interface ImageCompatV4Constructor<T extends IHost = IHost, U extends IImage<T> = IImage<T>> extends ImageConstructor<T, U> {
+    using<V extends ExternalAsset>(this: T, instance: U, data: IFileThread<V>, command: string): Promise<unknown>;
+}
+
+export interface ICloudCompatV4<T extends IHost = IHost> extends ICloud<T> {
+    getDatabaseResult(service: string, credential: unknown, queryString: string, options?: CacheOptions | boolean | string): Undef<QueryResult>;
+    setDatabaseResult(service: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
+    hasDatabaseCache(service: string, sessionKey?: string): boolean;
+    hasDatabaseCoerce(service: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
+}
+
+export interface CloudCompatV4Constructor extends CloudConstructor {
+    readonly prototype: ICloudCompatV4;
+    new(...args: unknown[]): ICloudCompatV4;
+}
+
+export interface WatchCompatV4Constructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> extends WatchConstructor<T, U> {
+    readCACert(value: string, cache?: boolean): string;
+    readTLSKey(value: string, cache?: boolean): string;
+    readTLSCert(value: string, cache?: boolean): string;
+    isCert(value: string): boolean;
+    parseExpires(value: NumString, start?: number): number;
+}
+
+export interface ITransformSeriesCompatV4<T = AnyObject, U = T> extends ITransformSeries<T, U>, PropertyAction<OutV3, "out"> {}
+
+export interface TransformSeriesCompatV4Constructor extends TransformSeriesConstructor {
+    readonly prototype: ITransformSeriesCompatV4;
+    new(...args: unknown[]): ITransformSeriesCompatV4;
+}
+
+export type SupportedMethod = (major: number, minor?: number, patch?: number, lts?: boolean) => boolean;
+export type AllSettledMethod<T extends boolean = false> = <U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType) => Promise<T extends true ? PromiseFulfilledResult<U>[] : PromiseSettledResult<U>[]>;

package/lib/compress.d.ts

@@ -0,0 +1,25 @@
+import type { CompressFormat as ICompressFormat } from './squared';
+
+import type { LogBaseOptions, LogTime } from './logger';
+
+interface CompressFormat extends ICompressFormat, LogBaseOptions {
+    filename?: string;
+    startTime?: LogTime;
+    etag?: string;
+    proxyUrl?: string | ((uri: string) => Undef<string>);
+}
+
+interface Woff {
+    toWoff(this: void, data: BufferLike): Buffer;
+    toSfnt(this: void, data: BufferLike): Buffer;
+}
+
+type ResultCallback<T = Null<Buffer | Uint8Array>> = (err: unknown, data?: T, ext?: string) => void;
+type ResultData = Null<Buffer | Uint8Array> | string;
+
+export type BufferLike = Buffer | Uint8Array | ArrayBuffer | SharedArrayBuffer | ReadonlyArray<number>;
+export type TryFileCompressor = (data: string | Buffer, output: string, config: CompressFormat, callback?: TryFileResult) => Void<Promise<ResultData>>;
+export type TryFileCompressorAsync = (data: string | Buffer, output: string, config: CompressFormat) => Promise<ResultData>;
+export type TryFileResult = ResultCallback<ResultData>;
+export type TryImageResult = ResultCallback;
+export type BufferResult = Null<Buffer | Uint8Array>;

package/lib/core.d.ts

@@ -0,0 +1,187 @@
+/* eslint @typescript-eslint/no-explicit-any: "off" */
+
+import type { DataSource, RequestBase } from './squared';
+
+import type { IExternalConfig, IExternalFunction, IHost, IModule, ModuleConstructor } from './index';
+import type { QueryResult, TimeoutAction } from './db';
+import type { AddEventListenerOptions } from './dom';
+import type { Settings } from './node';
+import type { ClientDBSettings, ClientModule, DbCacheValue, DbCoerceSettings, DbCoerceValue, DbSourceOptions } from './settings';
+
+export interface IdentifierAction {
+    uuidKey?: string;
+}
+
+export interface IClient<T extends IHost, U extends ClientModule, V extends FunctionType = FunctionType> extends IModule<T>, IExternalConfig<U, U extends ClientModule<infer W> ? W : unknown>, IExternalFunction<V> {
+    init(...args: unknown[]): this;
+    set cacheDir(value: string);
+    get cacheDir(): string;
+}
+
+export interface ClientConstructor<T extends IHost = IHost, U extends ClientModule = ClientModule> extends ModuleConstructor {
+    readonly prototype: IClient<T, U>;
+    new(module?: U): IClient<T, U>;
+}
+
+export interface IClientDb<T extends IHost, U extends ClientModule<ClientDBSettings>, V extends DataSource = DataSource, W extends DbSourceOptions = DbSourceOptions, X extends DbCoerceSettings = DbCoerceSettings> extends IClient<T, U> {
+    database: V[];
+    cacheExpires: number;
+    add(item: V, state?: number): void;
+    hasCache(source: string, sessionKey?: string, override?: DbCacheValue): boolean;
+    hasCoerce(source: string, component: keyof DbCoerceSettings, uuidKey: Undef<string>): boolean;
+    hasCoerce(source: string, component: keyof DbCoerceSettings, override: Optional<DbCoerceValue>, credential?: unknown): boolean;
+    hasCoerce(source: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
+    getQueryResult(source: string, credential: unknown, queryString: string, renewCache: boolean): Undef<QueryResult>;
+    getQueryResult(source: string, credential: unknown, queryString: string, sessionKey: string, renewCache?: boolean): Undef<QueryResult>;
+    getQueryResult(source: string, credential: unknown, queryString: string, options?: CacheOptions | string, renewCache?: boolean): Undef<QueryResult>;
+    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, sessionKey: Undef<string>): QueryResult;
+    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
+    applyState(items: ArrayOf<V>, value: number, as?: boolean): void;
+    commit(items?: V[]): Promise<boolean>;
+    valueOfKey(credential: unknown, name: keyof W, component?: keyof X): unknown;
+    settingsOf(source: string, name: keyof W, component?: keyof X): unknown;
+    settingsKey(uuidKey: string, name: keyof W, component?: keyof X): unknown;
+    get pending(): V[];
+    get committed(): V[];
+    get failed(): V[];
+}
+
+export interface ClientDbConstructor<T extends IHost = IHost, U extends ClientModule = ClientModule, V extends DataSource = DataSource> extends ClientConstructor<T, U> {
+    STORE_RESULT_PARTITION_SIZE: number;
+    STORE_RESULT_PARTITION_MULT: number;
+    readonly TRANSACTION_ACTIVE: number;
+    readonly TRANSACTION_PARTIAL: number;
+    readonly TRANSACTION_COMMIT: number;
+    readonly TRANSACTION_TERMINATE: number;
+    readonly TRANSACTION_ABORT: number;
+    readonly TRANSACTION_FAIL: number;
+    loadSettings(settings: Pick<Settings, "process" | "memory">, password?: string) : boolean;
+    getTimeout(value: Undef<NumString | TimeoutAction>): number;
+    convertTime(value: NumString): number;
+    findResult(source: string, credential: unknown, queryString: string, timeout: number, sessionKey?: string | boolean, renewCache?: boolean): Undef<QueryResult>;
+    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, options: StoreResultOptions): QueryResult;
+    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, sessionKey: string, sessionExpires: number): QueryResult;
+    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: DbCacheValue): QueryResult;
+    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: Undef<DbCacheValue>, options: StoreResultOptions): QueryResult;
+    purgeResult(prefix?: string): Promise<number>;
+    extractUUID(credential: unknown): string;
+    setPoolConfig(value: unknown): void;
+    getPoolConfig(source: string): unknown;
+    keyOfResult(source: string, credential: unknown, uuidOnly?: boolean): string;
+    readonly prototype: IClientDb<T, U, V>;
+    new(module?: U, database?: V[]): IClientDb<T, U, V>;
+}
+
+export interface IAbortComponent extends AbortController {
+    reset(): void;
+    get aborted(): boolean;
+}
+
+export interface AbortComponentConstructor {
+    attach(instance: IAbortComponent, signal: AbortSignal, options?: AddEventListenerOptions): void;
+    detach(instance: IAbortComponent, signal: AbortSignal): void;
+    readonly prototype: IAbortComponent;
+    new(): IAbortComponent;
+}
+
+export interface IPermission {
+    setDiskRead(pathname?: StringOfArray, enabled?: boolean): void;
+    setDiskWrite(pathname?: StringOfArray, enabled?: boolean): void;
+    setUNCRead(pathname?: StringOfArray, enabled?: boolean): void;
+    setUNCWrite(pathname?: StringOfArray, enabled?: boolean): void;
+    getDiskRead(): StringOfArray;
+    getDiskWrite(): StringOfArray;
+    getUNCRead(): StringOfArray;
+    getUNCWrite(): StringOfArray;
+    hasDiskRead(pathname: string): boolean;
+    hasDiskWrite(pathname: string): boolean;
+    hasUNCRead(pathname: string): boolean;
+    hasUNCWrite(pathname: string): boolean;
+    get diskRead(): boolean;
+    get diskWrite(): boolean;
+    get uncRead(): boolean;
+    get uncWrite(): boolean;
+}
+
+export interface PermissionConstructor {
+    create(settings: PermittedDirectories, freeze?: boolean): Null<IPermission>;
+    create(settings: PermittedDirectories, parent: Null<IPermission>, freeze?: boolean): Null<IPermission>;
+    validate(settings: unknown): settings is PermittedDirectories;
+    clone(permission: IPermission, freeze?: boolean): IPermission;
+    match(pathname: string, pattern: StringOfArray): boolean;
+    readonly prototype: IPermission;
+    new(freeze?: boolean): IPermission;
+}
+
+export interface PermissionReadWrite<T = boolean> {
+    disk_read?: T;
+    disk_write?: T;
+    unc_read?: T;
+    unc_write?: T;
+}
+
+export interface PermissionAction {
+    permission?: PermittedDirectories;
+}
+
+export interface HostInitConfig extends PlainObject, RequestBase<HostInitLog> {
+    username?: string;
+    ignoreModules?: string[];
+}
+
+export interface HostInitLog {
+    enabled?: boolean;
+    level?: NumString;
+    exclude?: StringOfArray;
+    useColor?: boolean;
+}
+
+export interface PermittedDirectories extends PermissionReadWrite<StringOfArray> {
+    inherit?: boolean;
+}
+
+export interface StoreResultOptions {
+    cache?: DbCacheValue;
+    cacheDir?: string;
+    sessionKey?: string;
+    sessionExpires?: number;
+}
+
+export interface CacheOptions {
+    value?: DbCacheValue;
+    renewCache?: boolean;
+    sessionKey?: string;
+}
+
+export interface ThreadInfo {
+    pid: number;
+    startTime: number;
+    username?: string;
+    sessionId?: string;
+    broadcastId?: StringOfArray;
+}
+
+export interface ThreadCountStat {
+    count: number;
+    pending: number;
+    opened?: number;
+    closed?: number;
+    queued?: number;
+    rejected?: number;
+    killed?: number;
+    startTime?: number;
+    previousTime?: number;
+    max?: number;
+    admin?: ThreadInfo[];
+}
+
+export interface JoinQueueOptions {
+    args?: unknown[];
+    reject?: boolean;
+}
+
+export interface ResumeThreadOptions {
+    args: unknown[];
+    startTime: number;
+    aborted?: boolean;
+}