@e-mc/types 0.11.7 → 0.12.0

package/lib/core.d.ts

@@ -1,10 +1,15 @@
-import type { DataSource, RequestBase } from './squared';
+import type { DataSource, RequestBase, WorkerAction } from './squared';
 
 import type { IExternalConfig, IExternalFunction, IHost, IModule, ModuleConstructor } from './index';
 import type { QueryResult, TimeoutAction } from './db';
+import type { StatusType } from '@e-mc/types/lib/logger';
 import type { Settings } from './node';
 import type { ClientDbSettings, ClientModule, DbCacheValue, DbCoerceSettings, DbSourceOptions } from './settings';
 
+import type { TransferListItem, Worker, WorkerOptions } from 'node:worker_threads';
+
+import type * as EventEmitter from 'node:events';
+
 export interface IdentifierAction {
     uuidKey?: string;
 }
@@ -77,6 +82,115 @@ export interface ClientDbConstructor<T extends IHost = IHost, U extends ClientMo
     new(module?: U, database?: V[]): IClientDb<T, U, V>;
 }
 
+export interface IWorkerGroup extends WorkerBase {
+    [Symbol.iterator](): IteratorObject<IWorkerChannel, BuiltinIteratorReturn>;
+    add(name: string, item: IWorkerChannel, priority?: number): this;
+    get(name: string, force?: boolean | number): IWorkerChannel | undefined;
+    delete(name: string | IWorkerChannel): boolean;
+    free(count?: number): number;
+    print(format: "stats" | "errors"): void;
+    clear(): void;
+    set max(value);
+    get max(): number;
+    get workers(): IWorkerChannel[];
+    get pending(): number;
+    get available(): number;
+    get errors(): WorkerChannelError[];
+    get size(): number;
+    get sizeOf(): number;
+}
+
+export interface WorkerGroupConstructor {
+    checkTimeout(value: number, active?: boolean): number;
+    readonly prototype: IWorkerGroup;
+    new(max?: number, locked?: boolean): IWorkerGroup;
+}
+
+export interface IWorkerChannel<T = unknown> extends EventEmitter, Iterable<Worker>, WorkerInfo {
+    [Symbol.iterator](): IteratorObject<Worker, BuiltinIteratorReturn>;
+    sendObject(data: unknown, transferList?: TransferListItem[], callback?: WorkerChannelResponse<T>, ...returnArgs: unknown[]): Worker;
+    sendBuffer(data: Buffer, shared?: boolean, callback?: WorkerChannelResponse<T>, ...returnArgs: unknown[]): Worker | null;
+    send(data: unknown, transferList?: TransferListItem[]): Promise<T>;
+    drop(count?: number): number;
+    join(group: IWorkerGroup, label?: string): void;
+    quit(): void;
+    kill(count?: number): Promise<number>;
+    lock(): void;
+    addLog(err: unknown, type?: StatusType): void;
+    isEmpty(): boolean;
+    set min(value);
+    get min(): number;
+    set max(value);
+    get max(): number;
+    set idleTimeout(value);
+    get idleTimeout(): number;
+    get filename(): string;
+    get workers(): Worker[];
+    get detached(): boolean;
+    get lastAccessed(): Date;
+    get timesAccessed(): number;
+    get frequencyAccessed(): number;
+    get pending(): number;
+    get available(): number;
+    get errors(): WorkerChannelError[];
+    get size(): number;
+
+    /* EventEmitter */
+    on(event: "error" | "messageerror" | "abort", listener: (err: Error) => void): this;
+    on(event: "exit", listener: (exitCode: number) => void): this;
+    on(event: "online", listener: () => void): this;
+    on(event: "message", listener: (value: any) => void): this;
+    on(event: "data", listener: (data: T) => void): this;
+    on(event: "pass", listener: (data: unknown, transferList: TransferListItem[] | undefined) => void): this;
+    once(event: "error" | "messageerror" | "abort", listener: (err: Error) => void): this;
+    once(event: "exit", listener: (exitCode: number) => void): this;
+    once(event: "online", listener: () => void): this;
+    once(event: "message", listener: (value: any) => void): this;
+    once(event: "data", listener: (data: T) => void): this;
+    once(event: "pass", listener: (data: unknown, transferList: TransferListItem[] | undefined) => void): this;
+}
+
+export interface WorkerChannelConstructor<T = unknown> {
+    create<U>(filename: string, name: string): IWorkerChannel<U>;
+    create<U>(filename: string, options?: WorkerOptions, name?: string): IWorkerChannel<U>;
+    hasPermission(options?: WorkerAction): boolean;
+    readonly prototype: IWorkerChannel<T>;
+    new(filename: string | URL, options?: WorkerOptions, init?: WorkerChannelInit): IWorkerChannel<T>;
+}
+
+export interface WorkerBase {
+    max: number;
+    readonly pending: number;
+    readonly available: number;
+    readonly errors: WorkerChannelError[];
+    readonly size: number;
+}
+
+export interface WorkerInfo extends WorkerBase {
+    min: number;
+    readonly filename: string;
+    readonly workers: Worker[];
+    readonly detached: boolean;
+    readonly idleTimeout: number;
+    readonly lastAccessed: Date;
+    readonly timesAccessed: number;
+    readonly frequencyAccessed: number;
+
+}
+
+export interface WorkerChannelInit {
+    max?: number;
+    idleTimeout?: number;
+    verbose?: boolean;
+}
+
+export interface WorkerChannelError {
+    timeStamp: Date;
+    type: StatusType;
+    value: unknown;
+    label?: string;
+}
+
 export interface IAbortComponent extends AbortController {
     reset(): void;
     get aborted(): boolean;
@@ -90,9 +204,13 @@ export interface AbortComponentConstructor {
 }
 
 export interface IPermission {
+    setDiskRead(enabled: boolean): void;
     setDiskRead(pathname?: string | string[], enabled?: boolean): void;
+    setDiskWrite(enabled: boolean): void;
     setDiskWrite(pathname?: string | string[], enabled?: boolean): void;
+    setUNCRead(enabled: boolean): void;
     setUNCRead(pathname?: string | string[], enabled?: boolean): void;
+    setUNCWrite(enabled: boolean): void;
     setUNCWrite(pathname?: string | string[], enabled?: boolean): void;
     getDiskRead(): string | string[];
     getDiskWrite(): string | string[];
@@ -194,4 +312,11 @@ export interface ResumeThreadOptions {
     args: unknown[];
     startTime: number;
     aborted?: boolean;
-}
+}
+
+export interface WorkerMessage<T = PlainObject, U = Buffer> {
+    data: U;
+    options?: T;
+}
+
+export type WorkerChannelResponse<T = unknown> = (result: T, ...args: unknown[]) => void;

package/lib/db.d.ts

@@ -79,7 +79,9 @@ export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V =
 
 export interface DbPoolConstructor<T extends DbDataSource = DbDataSource, U = unknown, V = unknown, W = unknown> {
     CACHE_UNUSED: readonly string[];
+    CACHE_IGNORE: readonly string[];
     asString(credential: unknown): string;
+    canCache(credential: unknown): boolean;
     sanitize(credential: unknown): unknown;
     removeUUIDKey<X>(credential: X & IdentifierAction): X;
     findKey<X extends IDbPool, Y extends DbDataSource>(pools: ObjectMap<X>, uuidKey: unknown, poolKey: string | undefined, ...items: Y[]): X | null;

package/lib/document.d.ts

@@ -1,4 +1,4 @@
-import type { LocationUri, MimeTypeAction, StorageAction } from './squared';
+import type { EncodingAction, LocationUri, MimeTypeAction, StorageAction } from './squared';
 
 import type { IDocument, IFileManager, IModule } from './index';
 import type { ExternalAsset, InitialValue } from './asset';
@@ -47,10 +47,9 @@ export interface ChunkData extends ChunkFile {
     sourceMap?: SourceMap;
 }
 
-export interface CacheData {
+export interface CacheData extends EncodingAction {
     uri?: string;
     etag?: string;
-    encoding?: BufferEncoding;
     override?: boolean;
 }
 
@@ -81,7 +80,7 @@ export interface TransformOptions<T = AnyObject, U = T> extends TransformOutput
     supplementChunks: ChunkData[];
 }
 
-export interface ITransformSeries<T = AnyObject, U = T> extends IModule, TransformOptions<T, U> {
+export interface ITransformSeries<T = AnyObject, U = T, V = object> extends IModule, TransformOptions<T, U> {
     readonly type: string;
     init(instance: IModule, dirname?: string): this;
     close(instance: IModule): void;
@@ -89,12 +88,12 @@ export interface ITransformSeries<T = AnyObject, U = T> extends IModule, Transfo
     getMainFile(code?: string, imports?: StringMap): SourceInput<string> | undefined;
     getSourceFiles(imports?: StringMap): SourceInput | undefined;
     toBaseConfig(all?: boolean): T;
-    upgrade<V = unknown>(context: V, dirname?: string, pkgname?: string): V;
-    upgradeESM<V = unknown>(context: V, dirname?: string, pkgname?: string): Promise<V>;
+    upgrade<W = unknown>(context: W, dirname?: string, pkgname?: string): W;
+    upgradeESM<W = unknown>(context: W, dirname?: string, pkgname?: string): Promise<W>;
     set code(value);
     get code(): string;
     get out(): IOut;
-    get metadata(): object;
+    get metadata(): V;
     get options(): TransformOutput;
     get productionRelease(): boolean;
     get imported(): boolean;
@@ -136,12 +135,14 @@ export interface SourceMapOptions extends MimeTypeAction {
 export interface SourceMap extends SourceCode {
     output: Map<string, SourceCode>;
     reset(): void;
+    nextMap(name: string, code: string, map: unknown, emptySources: boolean): boolean;
     nextMap(name: string, code: string, map: unknown, sourceMappingURL?: string, emptySources?: boolean): boolean;
     set map(value);
     get map(): RawSourceMap | undefined;
 }
 
 export interface SourceMapConstructor {
+    readonly SOURCE_MAPPING_URL: RegExp;
     findSourceMap(code?: string, uri?: string): RawSourceMap | undefined;
     removeSourceMappingURL(value: string): [string, string?, (RawSourceMap | null)?];
     isRaw(map: unknown): map is RawSourceMap;
@@ -188,12 +189,11 @@ export interface CustomizeOptions {
     transform?: DocumentTransform;
 }
 
-export interface AsSourceFileOptions {
-    encoding?: BufferEncoding;
+export interface AsSourceFileOptions extends EncodingAction {
     cache?: boolean;
 }
 
-export type Transformer = FunctionType<Promise<string> | string> | undefined;
+export type Transformer = FunctionType<Promise<string> | string>;
 export type ConfigOrTransformer = AnyObject | Transformer;
-export type PluginConfig = [string, ConfigOrTransformer | undefined, AnyObject | undefined, boolean?] | [];
+export type PluginConfig<T = ConfigOrTransformer> = [string, T | undefined, AnyObject | undefined, boolean?] | [];
 export type TransformCallback<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> = (this: T, instance: IDocument<T, U>, requireOrDocumentDir?: NodeJS.Require | string) => Promise<void >;

package/lib/filemanager.d.ts

@@ -1,4 +1,4 @@
-import type { BundleAction, ChecksumOutput, FileInfo, LogStatus } from './squared';
+import type { BundleAction, ChecksumOutput, EncodingAction, FileInfo, LogStatus } from './squared';
 
 import type { IFileManager, IImage, IModule, ImageConstructor, ModuleConstructor } from './index';
 import type { ExternalAsset } from './asset';
@@ -64,9 +64,8 @@ export interface HttpDiskCacheAddOptions {
     contentLength?: number;
 }
 
-export interface HttpMemoryCacheAddOptions extends Omit<HttpDiskCacheAddOptions, "buffer"> {
+export interface HttpMemoryCacheAddOptions extends Omit<HttpDiskCacheAddOptions, "buffer">, EncodingAction {
     toDisk?: string;
-    encoding?: BufferEncoding;
 }
 
 export interface ReplaceOptions {
@@ -110,6 +109,7 @@ export interface FindAssetOptions<T extends ExternalAsset = ExternalAsset> {
 
 export interface ChecksumOptions extends ReadHashOptions, Pick<ChecksumOutput, "include" | "exclude" | "recursive"> {
     dot?: boolean;
+    matchBase?: boolean;
     sortBy?: number;
     verbose?: boolean;
     ignore?: string[];

package/lib/http.d.ts

@@ -81,6 +81,10 @@ export const enum QUERY_RESULT {
     TIMEOUT
 }
 
+export interface HeadersAction {
+    headers?: OutgoingHttpHeaders | Headers;
+}
+
 export interface HttpAgentSettings {
     http?: HttpAgent;
     https?: HttpsAgent;

package/lib/image.d.ts

@@ -4,6 +4,7 @@ import type { BroadcastValue, LogTime } from './logger';
 import type { ImageModule } from './settings';
 
 export interface CommandData {
+    value: string;
     resize?: ResizeData | null;
     crop?: CropData | null;
     rotate?: RotateData | null;

package/lib/index.d.ts

@@ -4,7 +4,7 @@ import type { DataSource, DbDataSource, IncrementalMatch, LogStatus, TaskAction,
 
 import type { ExternalAsset, FileCommand, FileData, IFileThread, OutputFinalize } from './asset';
 import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload, DeleteObjectsOptions, UploadAssetOptions } from './cloud';
-import type { BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from './compress';
+import type { BrotliCompressLevel, BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from './compress';
 import type { ClientDbConstructor, HostInitConfig, IAbortComponent, IClient, IClientDb, IPermission, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, ThreadCountStat } from './core';
 import type { BatchQueryResult, DB_TYPE, ErrorQueryCallback, ExecuteBatchQueryOptions, ExecuteQueryOptions, HandleFailOptions, ProcessRowsOptions, QueryResult, SQL_COMMAND } from './db';
 import type { AsSourceFileOptions, ConfigOrTransformer, CustomizeOptions as CustomizeDocument, GenerateLintTableOptions, LintMessage, PluginConfig, SourceCode, SourceInput, SourceMap, SourceMapOptions, TransformAction, TransformCallback, TransformOutput, TransformResult, UpdateGradleOptions } from './document';
@@ -12,9 +12,9 @@ import type { AssetContentOptions, ChecksumOptions, DeleteFileAddendum, FileOutp
 import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
 import type { CommandData, CropData, QualityData, ResizeData, RotateData, TransformOptions } from './image';
 import type { ExecCommand, LOG_TYPE, LogArguments, LogComponent, LogDate, LogFailOptions, LogMessageOptions, LogOptions, LogProcessOptions, LogState, LogTime, LogType, LogValue, STATUS_TYPE, StatusType } from './logger';
-import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, FileTypeFormat, GlobDirOptions, MoveFileOptions, ParseFunctionOptions, PermissionOptions, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, TempDirOptions, WriteFileOptions } from './module';
+import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, FileTypeFormat, GlobDirOptions, MoveFileOptions, PackageVersionOptions, ParseFunctionOptions, PermissionOptions, PermissionType, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, TempDirOptions, WriteFileOptions } from './module';
 import type { HighResolutionTime, RequestData, Settings } from './node';
-import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostOptions, ProxySettings, PutOptions, ReadExpectType, RequestInit, StatusOnCallback } from './request';
+import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from './request';
 import type { ClientModule, CloudAuthSettings, CloudModule, CloudServiceOptions, CompressModule, CompressSettings, DbCoerceSettings, DbModule, DbSourceOptions, DnsLookupSettings, DocumentComponent, DocumentComponentOption, DocumentModule, HandlerSettings, HttpConnectSettings, HttpMemorySettings, ImageModule, LoggerFormat, LoggerFormatSettings, PoolConfig, RequestModule, RequestSettings, TaskModule, WatchModule } from './settings';
 import type { Command, SpawnResult } from './task';
 import type { IFileGroup, ModifiedPostFinalizeListener, SecureOptions, WatchInitResult } from './watch';
@@ -26,7 +26,7 @@ import type { ClientRequest, OutgoingHttpHeaders } from 'node:http';
 import type { LookupFunction } from 'node:net';
 import type { Readable, Writable } from 'node:stream';
 import type { SecureContextOptions } from 'node:tls';
-import type { BrotliCompress, Gzip } from 'node:zlib';
+import type { BrotliCompress, BrotliOptions, Gzip, ZlibOptions } from 'node:zlib';
 // @ts-ignore
 import type { FileTypeResult } from 'file-type';
 
@@ -57,6 +57,10 @@ declare namespace functions {
         get extensions(): T[];
     }
 
+    interface IWorkerConstructor {
+        asBuffer(data: Buffer | Uint8Array): Buffer;
+    }
+
     interface ICompress<T extends CompressModule = CompressModule, U extends CompressSettings = CompressSettings> extends IModule, IExternalConfig<T, U> {
         level: ObjectMap<number>;
         compressors: ObjectMap<TryFileCompressor>;
@@ -64,20 +68,23 @@ declare namespace functions {
         getLevel(value: string, fallback?: number): number | undefined;
         getReadable(file: string | URL | Buffer, options?: ReadableOptions): Readable;
         createGzip(file: string | Buffer, options?: CompressLevel): Gzip;
-        createBrotliCompress(file: string | Buffer, options?: CompressLevel): BrotliCompress;
+        createBrotliCompress(file: string | Buffer, options?: BrotliCompressLevel): BrotliCompress;
         createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
         createWriteStreamAsBrotli(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
+        intoGzipStream(output: string, options?: ZlibOptions): WriteStream;
+        intoBrotliStream(output: string, options?: BrotliOptions): WriteStream;
         writeGzip(file: string | Buffer, output: string, options?: CompressLevel): Promise<void>;
         writeBrotli(file: string | Buffer, output: string, options?: CompressLevel): Promise<void>;
         tryFile(file: string | Buffer, options: CompressFormat): Promise<BufferResult>;
         tryFile(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
         tryImage(file: string, options: CompressFormat): Promise<BufferResult>;
         tryImage(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
+        hasPermission(type: string, options?: unknown): boolean;
         set chunkSize(value: number | string | undefined);
         get chunkSize(): number | undefined;
     }
 
-    interface CompressConstructor<T extends CompressModule = CompressModule, U extends CompressSettings = CompressSettings> extends ModuleConstructor {
+    interface CompressConstructor<T extends CompressModule = CompressModule, U extends CompressSettings = CompressSettings> extends ModuleConstructor, IWorkerConstructor {
         singleton(): ICompress<T, U>;
         readonly prototype: ICompress<T, U>;
         new(module?: U): ICompress<T, U>;
@@ -94,21 +101,27 @@ declare namespace functions {
         setCommand(value: string | CommandData, outputAs?: string): void;
         getCommand(): string;
         parseCommand(value: string): CommandData;
-        parseMethod(value: string): Optional<[string, unknown[]?][]>;
-        parseResize(value: string): Optional<ResizeData>;
-        parseCrop(value: string): Optional<CropData>;
-        parseRotate(value: string): Optional<RotateData>;
-        parseQuality(value: string): Optional<QualityData>;
+        parseMethod(value: string): [string, unknown[]?][] | null;
+        parseResize(value: string): ResizeData | null;
+        parseCrop(value: string): CropData | null;
+        parseRotate(value: string): RotateData | null;
+        parseQuality(value: string): QualityData | null;
         parseOpacity(value: string): number;
+        parseWorker(command: string | CommandData, outputType?: string): CommandData | null;
         using?<V extends ExternalAsset>(data: IFileThread<V>, command: string): Promise<unknown>;
         get outputAs(): string;
         set host(value);
         get host(): T | null;
     }
 
-    interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ModuleConstructor {
-        /** @deprecated */
-        readonly REGEXP_SIZERANGE: RegExp;
+    interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ModuleConstructor, IWorkerConstructor {
+        readonly MIME_JPEG: string;
+        readonly MIME_PNG: string;
+        readonly MIME_WEBP: string;
+        readonly MIME_SVG: string;
+        readonly MIME_GIF: string;
+        readonly MIME_BMP: string;
+        readonly MIME_TIFF: string;
         transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<V extends { tempFile: true } ? string : Buffer | null>;
         clamp(value: unknown, min?: number, max?: number): number;
         isBinary(mime: unknown): mime is string;
@@ -255,7 +268,7 @@ declare namespace functions {
         cloudUpload?(state: IScopeOrigin<T, Y>, file: U, url: string, active: boolean): Promise<boolean>;
         cloudFinalize?(state: IScopeOrigin<T, Y>): Promise<unknown[]>;
         watchInit?(watch: IFileGroup<U>, assets: U[], sanitize?: boolean): WatchInitResult | undefined;
-        watchModified?(watch: IFileGroup<U>, assets?: U[]): PostFinalizeCallback;
+        watchModified?(watch: IFileGroup<U>, assets?: U[], recursive?: [string, string[]][]): PostFinalizeCallback;
         set dataSource(value: DataSource[]);
         get dataSource(): DataSource[];
         set imports(value);
@@ -289,6 +302,7 @@ declare namespace functions {
         setSSLKey(value: string): boolean;
         setSSLCert(value: string): boolean;
         hasSecureProtocol(): boolean;
+        getRecursiveFiles(watch: IFileGroup<U>): [string, string[]][];
         whenModified?(assets: U[], postFinalize: PostFinalizeCallback): IFileManager<U>;
         whenModified?(assets: U[], sanitize?: boolean, postFinalize?: PostFinalizeCallback): IFileManager<U>;
         set assets(value: U[]);
@@ -335,6 +349,8 @@ declare namespace functions {
         headersOf(uri: string): OutgoingHttpHeaders | undefined;
         aria2c(uri: string | URL, pathname: string): Promise<string[]>;
         aria2c(uri: string | URL, options?: Aria2Options): Promise<string[]>;
+        rclone(uri: string, pathname: string): Promise<string[]>;
+        rclone(uri: string, options?: RcloneOptions): Promise<string[]>;
         json(uri: string | URL, options?: OpenOptions): Promise<object | null>;
         pipe(uri: string | URL, to: Writable, options?: OpenOptions): Promise<null>;
         opts<V extends OpenOptions>(url: string | URL, options?: V): HostConfig & V;
@@ -373,6 +389,7 @@ declare namespace functions {
         defineHttpAgent(options: HttpAgentSettings): void;
         defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
         getAria2Path(): string;
+        getRclonePath(): string;
         readonly prototype: IRequest<T, U>;
         new(module?: T): IRequest<T, U>;
     }
@@ -414,7 +431,7 @@ declare namespace functions {
         install(name: "watch", target: WatchConstructor<IFileManager<T>, T>, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
         install(name: "watch", module: WatchModule): WatchInstance<T> | undefined;
         install(name: "compress", module?: CompressModule): ICompress | undefined;
-        install(name: string, ...args: unknown[]): IModule | undefined;
+        install<U extends IModule>(name: string, ...args: unknown[]): U | undefined;
         using(...items: FirstOf<T>): this;
         contains(item: T, condition?: FunctionArgs<[T], boolean>): boolean;
         removeCwd(value: unknown): string;
@@ -440,8 +457,8 @@ declare namespace functions {
         removeProcessTimeout(instance: IModule, file: T): void;
         getProcessTimeout(handler: InstallData): number;
         clearProcessTimeout(): void;
-        scheduleTask(url: string | URL, data: unknown, priority: number): Promise<unknown>;
-        scheduleTask(url: string | URL, data: unknown, thenCallback?: FunctionType, catchCallback?: FunctionType, priority?: number): Promise<unknown>;
+        scheduleTask(uri: string | URL, data: unknown, priority: number): Promise<unknown>;
+        scheduleTask(uri: string | URL, data: unknown, thenCallback?: FunctionType, catchCallback?: FunctionType, priority?: number): Promise<unknown>;
         setTaskLimit(value: number): void;
         addDownload(value: number | Bufferable, encoding: BufferEncoding): number;
         addDownload(value: number | Bufferable, type?: number | BufferEncoding, encoding?: BufferEncoding): number;
@@ -461,7 +478,7 @@ declare namespace functions {
         fetchObject(uri: string | URL, options?: OpenOptions | BufferFormat): Promise<object | null>;
         fetchBuffer<U extends OpenOptions>(uri: string | URL, options?: U): Promise<DataEncodedResult<U>>;
         fetchFiles(uri: string | URL, pathname: string): Promise<string[]>;
-        fetchFiles(uri: string | URL, options?: Aria2Options): Promise<string[]>;
+        fetchFiles(uri: string | URL, options?: Aria2Options | RcloneOptions): Promise<string[]>;
         updateProgress(name: "request", id: number | string, receivedBytes: number, totalBytes: number, dataTime?: HighResolutionTime): void;
         start(emptyDir?: boolean): Promise<FinalizeResult>;
         processAssets(emptyDir?: boolean, using?: T[]): void;
@@ -491,6 +508,7 @@ declare namespace functions {
         get cleared(): boolean;
         set finalizeState(value);
         get finalizeState(): number;
+        get retryLimit(): number;
 
         /* Set */
         add(value: string, parent?: T, type?: number): this;
@@ -591,6 +609,8 @@ declare namespace functions {
         loadSettings(settings: Settings, permission?: PermissionReadWrite, password?: string): boolean;
         isPermission(value: unknown): value is IPermission;
         createPermission(all?: boolean, freeze?: boolean): IPermission;
+        kill(username: string, all: true): number;
+        kill(username: string, pid: number | number[]): number;
         kill(username: string, iv: BinaryLike, all: true): number;
         kill(username: string, iv: BinaryLike, pid: number | number[]): number;
         getThreadCount(full: true): ThreadCountStat;
@@ -654,8 +674,8 @@ declare namespace functions {
         allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions): Promise<PromiseFulfilledResult<U>[]>;
         formatMessage(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions): void;
         formatFail(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogFailOptions): void;
-        writeFail(value: LogValue, message?: unknown, type?: LogType): void;
-        writeFail(value: LogValue, message?: unknown, options?: LogFailOptions): void;
+        writeFail(value: LogValue, message: unknown, options: LogFailOptions): void;
+        writeFail(value: LogValue, message?: unknown, type?: LogType | LogFailOptions): void;
         writeTimeProcess(title: string, value: string, startTime: LogTime, options?: LogProcessOptions): void;
         writeTimeElapsed(title: string, value: LogValue, startTime: LogTime, options?: LogMessageOptions): void;
         checkPackage(err: unknown, name: string | undefined, type: LogType): boolean;
@@ -673,7 +693,9 @@ declare namespace functions {
         getLog(...type: StatusType[]): LogStatus<StatusType>[];
         flushLog(): void;
         willAbort(value: unknown): boolean;
+        /** @deprecated hasPermission("fs") */
         hasOwnPermission(): boolean;
+        hasPermission(type: PermissionType | string, ...values: unknown[]): boolean;
         isFatal(err?: unknown): boolean;
         detach(): void;
         reset(): void;
@@ -741,10 +763,12 @@ declare namespace functions {
         readonly LOG_TYPE: LOG_TYPE;
         readonly LOG_FORMAT: LoggerFormatSettings<LoggerFormat<number>>;
         readonly STATUS_TYPE: STATUS_TYPE;
+        readonly REQUIRE_ESM: boolean;
         readonly PLATFORM_WIN32: boolean;
         readonly MAX_TIMEOUT: number;
         readonly TEMP_DIR: string;
-        /** @deprecated Types.supported */
+        constructorOf<U extends ModuleConstructor>(value: unknown, moduleName?: string): value is U;
+        /** @deprecated @e-mc/types */
         supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
         formatMessage(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions): void;
         writeFail(value: LogValue, message?: unknown, options?: LogFailOptions | LogType): void;
@@ -754,7 +778,7 @@ declare namespace functions {
         asString(value: unknown, cacheKey?: boolean | "throws"): string;
         asHash(data: BinaryLike, options?: AsHashOptions): string;
         asHash(data: BinaryLike, algorithm?: string, options?: HashOptions): string;
-        asHash(data: BinaryLike, algorithm?: string, digest?: BinaryToTextEncoding): string;
+        asHash(data: BinaryLike, algorithm?: string, encoding?: BinaryToTextEncoding): string;
         readHash(value: string | URL, options?: ReadHashOptions): Promise<string>;
         toPosix(value: unknown, normalize: boolean): string;
         toPosix(value: unknown, filename?: string, normalize?: boolean): string;
@@ -795,19 +819,21 @@ declare namespace functions {
         getMemUsage(format: true): string;
         getMemUsage(format?: boolean): number;
         formatCpuMem(start: CpuUsage, all?: boolean): string;
+        getPackageVersion(name: string | [string, string], options?: PackageVersionOptions): string;
         /** @deprecated */
         getPackageVersion(name: string | [string, string], startDir: string, baseDir?: string): string;
         /** @deprecated */
         getPackageVersion(name: string | [string, string], unstable?: boolean, startDir?: string, baseDir?: string): string;
         checkSemVer(name: string | [string, string], options: CheckSemVerOptions): boolean;
-        /** @deprecated */
-        checkSemVer(name: string | [string, string], min: number | string, max?: number | string, unstable?: boolean, startDir?: string): boolean;
+        checkSemVer(name: string | [string, string], min: number | string, max?: number | string): boolean;
         checkSemVer(name: string | [string, string], min: number | string, max: number | string, options?: Omit<CheckSemVerOptions, "min" | "max" | "equals">): boolean;
         /** @deprecated */
+        checkSemVer(name: string | [string, string], min: number | string, max?: number | string, unstable?: boolean, startDir?: string): boolean;
+        /** @deprecated @e-mc/types */
         sanitizeCmd(value: string): string;
-        /** @deprecated */
+        /** @deprecated @e-mc/types */
         sanitizeArgs(value: string, doubleQuote?: boolean): string;
-        /** @deprecated */
+        /** @deprecated @e-mc/types */
         sanitizeArgs(values: string[], doubleQuote?: boolean): string[];
         purgeMemory(percent: number, limit: number, parent?: boolean): Promise<number>;
         purgeMemory(percent?: number, limit?: number | boolean, parent?: unknown): Promise<number>;

package/lib/logger.d.ts

@@ -4,6 +4,7 @@ import type { HighResolutionTime } from './node';
 
 import type { LOG_STATE, LOG_TYPE, STATUS_TYPE } from '../index.d';
 
+// @ts-ignore
 import type { BackgroundColor as IBackgroundColor, ForegroundColor as IForegroundColor } from 'chalk';
 
 type HexColor = `#${string}`;
@@ -111,6 +112,6 @@ export type BackgroundColor = typeof IBackgroundColor | HexColor;
 export type ForegroundColor = typeof IForegroundColor | HexColor;
 export type TextAlign = "left" | "center" | "right";
 export type TextWrapStyle = "ellipsis" | "nowrap" | "ellipsis-end" | "nowrap-end" | "none";
-export type ErrorOutMethod = (err: Error, data: LogTypeValue, require?: NodeRequire) => void;
-export type BroadcastOutMethod = (value: string, options: LogMessageOptions, require?: NodeRequire) => void;
+export type ErrorOutMethod = (err: Error, data: LogTypeValue, require?: NodeJS.Require) => void;
+export type BroadcastOutMethod = (value: string, options: LogMessageOptions, require?: NodeJS.Require) => void;
 export type BroadcastValue = string | string[] | { value: string | string[]; stripAnsi?: boolean };

package/lib/module.d.ts

@@ -1,4 +1,4 @@
-import type { ChecksumBase } from './squared';
+import type { ChecksumBase, EncodingAction } from './squared';
 
 import type { StreamAction } from './asset';
 
@@ -41,14 +41,12 @@ export interface FileSystemOptions extends PermissionOptions, ThrowsAction {
     ignorePermission?: boolean;
 }
 
-export interface ReadFileOptions extends FileSystemOptions, StreamBase, RequireAction {
+export interface ReadFileOptions extends FileSystemOptions, StreamBase, RequireAction, EncodingAction {
     cache?: boolean;
-    encoding?: BufferEncoding;
 }
 
-export interface WriteFileOptions extends FileSystemOptions {
+export interface WriteFileOptions extends FileSystemOptions, EncodingAction {
     overwrite?: boolean;
-    encoding?: BufferEncoding;
 }
 
 export interface DeleteFileOptions extends FileSystemOptions {
@@ -76,6 +74,12 @@ export interface ParseFunctionOptions extends RequireAction {
     context?: unknown;
 }
 
+export interface PackageVersionOptions {
+    unstable?: boolean;
+    startDir?: string;
+    baseDir?: string;
+}
+
 export interface CheckSemVerOptions {
     min?: number;
     max?: number;
@@ -118,8 +122,7 @@ export interface ReadHashOptions extends ChecksumBase, StreamBase {
     chunkSize?: number;
 }
 
-export interface ReadBufferOptions extends StreamBase {
-    encoding?: BufferEncoding;
+export interface ReadBufferOptions extends StreamBase, EncodingAction {
     cache?: boolean;
 }
 
@@ -137,4 +140,5 @@ export interface TempDirOptions {
 export type ReadTextOptions = ReadBufferOptions;
 export type ReadFileCallback<T extends Bufferable = Bufferable> = (err: NodeJS.ErrnoException | null, data?: T) => void;
 export type ProtocolType = "http" | "https" | "http/s" | "ftp" | "sftp" | "s/ftp" | "torrent" | "unc" | "file";
+export type PermissionType = "fs" | "memory" | "memory.user" | "worker";
 export type FileTypeFormat = Bufferable | Uint8Array | ArrayBuffer | Readable;

package/lib/object.d.ts

@@ -1,30 +1,37 @@
+/** @deprecated lib/image **/
 interface Point {
     x: number;
     y: number;
 }
 
+/** @deprecated lib/image **/
 interface Dimension {
     width: number;
     height: number;
 }
 
+/** @deprecated lib/squared **/
 interface KeyValue<T, U> {
     key: T;
     value: U;
 }
 
+/** @deprecated lib/node **/
 interface ErrorCode extends Error {
     code?: unknown;
 }
 
+/** @deprecated lib/http **/
 interface AuthValue {
     username?: string;
     password?: string;
 }
 
+/** @deprecated lib/settings **/
 interface MinMax<T = number> {
     min?: T;
     max?: T;
 }
 
+/** @deprecated lib/node **/
 type HighResolutionTime = bigint | [number, number];