@e-mc/types 0.10.2 → 0.10.4

package/lib/index.d.ts

@@ -1,11 +1,13 @@
+/* eslint @typescript-eslint/no-explicit-any: "off" */
+
 /// <reference path="type.d.ts" />
 /// <reference path="object.d.ts" />
 
-import type { DataSource, DbDataSource, IncrementalMatch, LogStatus, TaskAction, ViewEngine } from './squared';
+import type { CompressLevel, DataSource, DbDataSource, IncrementalMatch, LogStatus, TaskAction, ViewEngine } from './squared';
 
 import type { ExternalAsset, FileCommand, FileData, IFileThread, OutputFinalize } from './asset';
 import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload, UploadAssetOptions } from './cloud';
-import type { BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from './compress';
+import type { BufferResult, CompressFormat, 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';
@@ -13,34 +15,33 @@ 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, MoveFileOptions, ParseFunctionOptions, PermissionOptions, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, TempDirOptions, WriteFileOptions } from './module';
+import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, GetTempDirOptions, GlobDirOptions, MoveFileOptions, NormalizeFlags, ParseFunctionOptions, PermissionOptions, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, WriteFileOptions } from './module';
 import type { RequestData, Settings } from './node';
-import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HeadersOnCallback, HostConfig, OpenOptions, PostOptions, ProxySettings, ReadExpectType, RequestInit, StatusOnCallback } from './request';
+import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HeadersOnCallback, HostConfig, OpenOptions, PostOptions, ProxySettings, PutOptions, 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';
 
 import type { SpawnOptions } from 'child_process';
-import type { BinaryLike, BinaryToTextEncoding, HashOptions } from 'crypto';
+import type { BinaryLike } from 'crypto';
 import type { NoParamCallback, WriteStream } from 'fs';
 import type { ClientRequest, OutgoingHttpHeaders } from 'http';
 import type { LookupFunction } from 'net';
 import type { Readable, Writable } from 'stream';
 import type { SecureContextOptions } from 'tls';
 import type { BrotliCompress, Gzip } from 'zlib';
+// @ts-ignore
+import type { FileTypeResult } from 'file-type';
 
 import type * as EventEmitter from 'events';
-
 // @ts-ignore
 import type * as ws from 'ws';
-import type { FileTypeResult } from 'file-type';
 
 type BufferView = Bufferable | NodeJS.ArrayBufferView;
 type CpuUsage = NodeJS.CpuUsage;
 
 declare namespace functions {
     type WatchInstance<T extends ExternalAsset, U extends WatchModule = WatchModule> = IWatch<IFileManager<T>, T, U, ModifiedPostFinalizeListener<T>>;
-    type FormatMessageArgs = [type: LogType, title: string, value: LogValue, message: unknown, options: LogMessageOptions];
 
     interface IScopeOrigin<T extends IHost = IHost, U extends IModule = IModule> {
         host?: T;
@@ -58,12 +59,13 @@ declare namespace functions {
         get extensions(): T[];
     }
 
-    interface ICompress<T extends CompressModule = CompressModule, U extends CompressSettings = CompressSettings> extends IModule, IExternalConfig<T, U> {
+    interface ICompress<T extends CompressModule<U>, U extends CompressSettings = CompressSettings> extends IModule, IExternalConfig<T, U> {
         level: ObjectMap<number>;
         compressors: ObjectMap<TryFileCompressor>;
+        chunkSize?: number;
         register(format: string, callback: TryFileCompressor): void;
         getLevel(value: string, fallback?: number): Undef<number>;
-        getReadable(file: string | URL | Buffer, options?: ReadableOptions): Readable;
+        getReadable(file: string | URL | Buffer): Readable;
         createGzip(file: string | Buffer, options?: CompressLevel): Gzip;
         createBrotliCompress(file: string | Buffer, options?: CompressLevel): BrotliCompress;
         createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
@@ -74,12 +76,10 @@ declare namespace functions {
         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>;
-        set chunkSize(value: Undef<number | string>);
-        get chunkSize(): Undef<number>;
     }
 
-    interface CompressConstructor<T extends CompressModule = CompressModule, U extends CompressSettings = CompressSettings> extends ModuleConstructor {
-        singleton(): ICompress<T, U>;
+    interface CompressConstructor<T extends CompressModule<U> = CompressModule<any>, U extends CompressSettings = CompressSettings> extends ModuleConstructor {
+        singleton(): ICompress<CompressModule>;
         readonly prototype: ICompress<T, U>;
         new(module?: U): ICompress<T, U>;
     }
@@ -91,6 +91,7 @@ declare namespace functions {
         qualityData?: QualityData;
         methodData?: [string, unknown[]?][];
         opacityValue?: number;
+        outputType?: string;
         setCommand(value: string | CommandData, outputAs?: string): void;
         getCommand(): string;
         parseCommand(value: string): CommandData;
@@ -198,10 +199,10 @@ declare namespace functions {
         LOG_CLOUD_DOWNLOAD: LogMessageOptions;
         LOG_CLOUD_DELETE: LogMessageOptions;
         LOG_CLOUD_DELAYED: LogMessageOptions;
-        finalize(this: T, instance: ICloud<T, U, V>): Promise<void>;
-        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, options: UploadAssetOptions): Promise<void>[];
-        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, ignoreProcess: boolean): Promise<void>[];
-        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, contentType?: string | boolean | UploadAssetOptions, ignoreProcess?: boolean): Promise<void>[];
+        finalize(this: T, instance: ICloud<T, U, V>): Promise<unknown>;
+        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, options: UploadAssetOptions): Promise<unknown>[];
+        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, ignoreProcess: boolean): Promise<unknown>[];
+        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, contentType?: string | boolean | UploadAssetOptions, ignoreProcess?: boolean): Promise<unknown>[];
         sanitizeAssets<W extends ExternalAsset>(assets: W[]): W[];
         readonly prototype: ICloud<T, U, V>;
         new(module?: U, database?: CloudDatabase[], ...args: unknown[]): ICloud<T, U, V>;
@@ -264,7 +265,7 @@ declare namespace functions {
         updateGradle(source: string, namespaces: string[], value: string, options?: UpdateGradleOptions): string;
         generateLintTable(messages: LintMessage[], options: GenerateLintTableOptions): LogComponent[];
         cleanup?(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
-        sanitizeAssets?(assets: U[], exclusions?: unknown[]): U[];
+        sanitizeAssets?(assets: U[], exclusions?: U[]): U[];
         readonly prototype: IDocument<T, U, V, W, X, Y>;
         new(module?: V, ...args: unknown[]): IDocument<T, U, V, W, X, Y>;
     }
@@ -295,14 +296,14 @@ declare namespace functions {
         createServer(port: number, active: boolean): Null<ws.Server>;
         createServer(port: number, secure?: Null<SecureOptions>, active?: boolean): Null<ws.Server>;
         shutdown(): void;
-        setTimeout(value: number | string): void;
+        setTimeout(value: NumString): void;
         checkTimeout(client: ws): boolean;
         readonly prototype: IWatch<T, U, V, W>;
         new(module?: V): IWatch<T, U, V, W>;
         new(interval?: number, port?: number, securePort?: number, extensions?: unknown[]): IWatch<T, U, V, W>;
     }
 
-    interface IRequest<T extends RequestModule = RequestModule, U extends RequestSettings = RequestSettings> extends IModule, IExternalConfig<T, U> {
+    interface IRequest<T extends RequestModule<U>, U extends RequestSettings = RequestSettings> extends IModule, IExternalConfig<T, U> {
         startTime: number;
         acceptEncoding: boolean;
         keepAlive: Null<boolean>;
@@ -312,7 +313,7 @@ declare namespace functions {
         init(config?: RequestInit): this;
         apply(options: ApplyOptions): this;
         addDns(hostname: string, address: string, timeout: number): void;
-        addDns(hostname: string, address: string, family?: number | string, timeout?: number): void;
+        addDns(hostname: string, address: string, family?: NumString, timeout?: number): void;
         lookupDns(hostname: string): LookupFunction;
         proxyOf(uri: string, localhost?: boolean): Undef<ProxySettings>;
         statusOn(name: ArrayOf<number>, callback: StatusOnCallback): void;
@@ -327,6 +328,9 @@ declare namespace functions {
         opts(url: string | URL, options?: OpenOptions): HostConfig;
         open(uri: string | URL, options: OpenOptions): HttpRequestClient;
         head(uri: string | URL, options?: OpenOptions): ClientRequest;
+        put<V extends { format: undefined; encoding: undefined }>(uri: string | URL, data: unknown, contentType: string): Promise<DataObjectResult<V>>;
+        put<V extends PutOptions>(uri: string | URL, data: unknown, options: V): Promise<DataObjectResult<V>>;
+        put<V extends PutOptions>(uri: string | URL, data: unknown, contentType?: string | V, options?: V): Promise<DataObjectResult<V>>;
         post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, data: unknown, contentType: string): Promise<DataObjectResult<V>>;
         post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, parts: FormDataPart[]): Promise<DataObjectResult<V>>;
         post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, form: AnyObject, parts: FormDataPart[]): Promise<DataObjectResult<V>>;
@@ -344,13 +348,13 @@ declare namespace functions {
         get ipVersion(): InternetProtocolVersion;
     }
 
-    interface RequestConstructor<T extends RequestModule = RequestModule, U extends RequestSettings = RequestSettings> extends ModuleConstructor {
+    interface RequestConstructor<T extends RequestModule<U> = RequestModule<any>, U extends RequestSettings = RequestSettings> extends ModuleConstructor {
         readCACert(value: string, cache?: boolean): string;
         readTLSKey(value: string, cache?: boolean): string;
         readTLSCert(value: string, cache?: boolean): string;
         isCert(value: string): boolean;
         fromURL(url: URL, value: string): string;
-        fromStatusCode(value: number | string): string;
+        fromStatusCode(value: NumString): string;
         defineHttpAgent(options: HttpAgentSettings): void;
         defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
         getAria2Path(): string;
@@ -362,13 +366,13 @@ declare namespace functions {
         processTimeout: number;
         cacheToDisk: IHttpDiskCache<T>;
         cacheToMemory: IHttpMemoryCache<T>;
-        Request: IRequest;
+        Request: IRequest<RequestModule>;
         Document: InstallData<IDocument<IFileManager<T>, T>, DocumentConstructor<IFileManager<T>, T>>[];
         Task: InstallData<ITask, TaskConstructor>[];
         Image: Null<ImageMimeMap>;
         Cloud: Null<ICloud>;
         Watch: Null<WatchInstance<T>>;
-        Compress: Null<ICompress>;
+        Compress: Null<ICompress<CompressModule>>;
         readonly documentAssets: T[];
         readonly taskAssets: (T & Required<TaskAction>)[];
         readonly dataSourceItems: DataSource[];
@@ -392,8 +396,8 @@ declare namespace functions {
         install(name: "image", target: ImageConstructor, module?: ImageModule, ...args: unknown[]): Undef<IImage>;
         install(name: "image", targets: Map<string, ImageConstructor>, module?: ImageModule): void;
         install(name: "watch", module: WatchModule): Undef<WatchInstance<T>>;
-        install(name: "watch", interval?: number | string, port?: number | string, securePort?: number | string, extensions?: unknown[]): Undef<WatchInstance<T>>;
-        install(name: "compress", module?: CompressModule): Undef<ICompress>;
+        install(name: "watch", interval?: NumString, port?: NumString, securePort?: NumString, extensions?: unknown[]): Undef<WatchInstance<T>>;
+        install(name: "compress", module?: CompressModule): Undef<ICompress<CompressModule>>;
         install(name: string, ...args: unknown[]): Undef<IModule>;
         using(...items: FirstOf<T>): this;
         contains(item: T, condition?: FunctionArgs<[T], boolean>): boolean;
@@ -410,7 +414,6 @@ declare namespace functions {
         hasDocument(instance: IModule, document: Undef<ArrayOf<string>>): boolean;
         getDocumentAssets(instance: IModule, condition?: FunctionArgs<[T], boolean>): T[];
         getDataSourceItems(instance: IModule, condition?: FunctionArgs<[DataSource], boolean>): DataSource[];
-        checkFilename(file: T, pathname?: string): string;
         setLocalUri(file: T, replace?: boolean): FileOutput;
         getLocalUri(data: FileData<T>): string;
         getMimeType(data: FileData<T>): string;
@@ -442,7 +445,7 @@ declare namespace functions {
         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[]>;
-        updateProgress(name: "request", id: number | string, receivedBytes: number, totalBytes: number, dataTime?: HighResolutionTime): void;
+        updateProgress(name: "request", id: NumString, receivedBytes: number, totalBytes: number, dataTime?: HighResolutionTime): void;
         start(emptyDir?: boolean): Promise<FinalizeResult>;
         processAssets(emptyDir?: boolean, using?: T[]): void;
         deleteFile<U extends Promise<void>>(src: string, promises: boolean): U;
@@ -451,12 +454,11 @@ declare namespace functions {
         deleteFile<U extends NoParamCallback>(src: string, options: DeleteFileOptions & DeleteFileAddendum, callback?: U): unknown;
         restart(recursive?: boolean | "abort", emptyDir?: boolean): void;
         restart(recursive?: boolean | "abort", exclusions?: string[], emptyDir?: boolean): void;
-        finalizeCompress(assets: T[]): Promise<void>;
-        finalizeDocument(): Promise<void>;
-        finalizeTask(assets: (T & Required<TaskAction>)[]): Promise<void>;
-        finalizeCloud(): Promise<void>;
-        finalizeChecksum(): Promise<void>;
-        finalizeCleanup(): Promise<void>;
+        finalizeCompress(assets: T[]): Promise<unknown>;
+        finalizeDocument(): Promise<unknown>;
+        finalizeTask(assets: (T & Required<TaskAction>)[]): Promise<unknown>;
+        finalizeCloud(): Promise<unknown>;
+        finalizeCleanup(): Promise<unknown>;
         finalize(): Promise<void>;
         close(): void;
         reset(): boolean;
@@ -520,7 +522,7 @@ declare namespace functions {
         verifyChecksum(root: string, options: ChecksumOptions): Promise<Null<[string[], string[], number]>>;
         verifyChecksum(root: string, from?: string | ChecksumOptions, options?: ChecksumOptions): Promise<Null<[string[], string[], number]>>;
         createFileThread(host: IFileManager<T>, file: T): IFileThread<T>;
-        setTimeout(options: ObjectMap<number | string>): void;
+        setTimeout(options: ObjectMap<NumString>): void;
         defineHttpCache(options: HttpMemorySettings, disk?: boolean): void;
         defineHttpConnect(options: HttpConnectSettings): void;
         readonly prototype: IFileManager<T>;
@@ -540,8 +542,8 @@ declare namespace functions {
         willLog(name: string): boolean;
         ignoreLog(values: boolean | ArrayOf<string>): void;
         collectLog(level?: boolean): LogStatus<StatusType>[];
-        pauseLog(type?: string): void;
-        resumeLog(type?: string): void;
+        pauseLog(): void;
+        resumeLog(): void;
         hasLog(type: string): boolean;
         delayMessage(...args: unknown[]): void;
         willAbort(value: string | IModule): boolean;
@@ -573,7 +575,6 @@ declare namespace functions {
         getThreadCount(full: true): ThreadCountStat;
         getThreadCount(username: string, iv?: BinaryLike): ThreadCountStat;
         getThreadCount(username?: string | boolean, iv?: BinaryLike): number;
-        getLogDelayed(): FormatMessageArgs[];
         getPermissionFromSettings(): IPermission;
         readonly prototype: IHost;
         new(config?: HostInitConfig): IHost;
@@ -582,9 +583,10 @@ declare namespace functions {
     interface IModule<T extends IHost = IHost> extends EventEmitter, IAbortComponent {
         readonly status: LogStatus<StatusType>[];
         readonly errors: unknown[];
+        /** @deprecated */
         supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
         supports(name: string, value?: boolean): boolean;
-        getTempDir(options: TempDirOptions): string;
+        getTempDir(options: GetTempDirOptions): string;
         getTempDir(uuidDir: boolean, createDir: boolean): string;
         getTempDir(pathname: string, createDir: boolean): string;
         getTempDir(uuidDir: boolean, filename?: string, createDir?: boolean): string;
@@ -592,7 +594,7 @@ declare namespace functions {
         canRead(uri: string | URL, options?: PermissionOptions): boolean;
         canWrite(uri: string | URL, options?: PermissionOptions): boolean;
         readFile(src: string | URL): Undef<Buffer>;
-        readFile<U extends ReadFileOptions>(src: string | URL, options?: U): Undef<U extends { encoding: string } ? U extends { minStreamSize: number | string } ? Promise<string> : string : U extends { minStreamSize: number | string } ? Promise<Buffer> : Buffer>;
+        readFile<U extends ReadFileOptions>(src: string | URL, options?: U): Undef<U extends { encoding: string } ? U extends { minStreamSize: NumString } ? Promise<string> : string : U extends { minStreamSize: NumString } ? Promise<Buffer> : Buffer>;
         readFile<U extends Buffer>(src: string | URL, promises: true): Promise<Undef<U>>;
         readFile<U extends Bufferable, V extends ReadFileOptions>(src: string | URL, options: V, promises: true): Promise<Undef<V extends { encoding: string } ? string : U>>;
         readFile<U extends ReadFileCallback>(src: string | URL, callback: U): Undef<U extends ReadFileCallback<infer W> ? W : Bufferable>;
@@ -667,10 +669,8 @@ declare namespace functions {
         get sessionId(): string;
         set broadcastId(value);
         get broadcastId(): ArrayOf<string>;
-        set silent(value);
-        get silent(): boolean;
         get logType(): LOG_TYPE;
-        set logLevel(value: number | string);
+        set logLevel(value: NumString);
         get logLevel(): number;
         get statusType(): STATUS_TYPE;
         set tempDir(value);
@@ -718,20 +718,17 @@ declare namespace functions {
         readonly LOG_TYPE: LOG_TYPE;
         readonly LOG_FORMAT: LoggerFormatSettings<LoggerFormat<number>>;
         readonly STATUS_TYPE: STATUS_TYPE;
-        readonly PLATFORM_WIN32: boolean;
         readonly MAX_TIMEOUT: number;
         readonly TEMP_DIR: string;
-        /** @deprecated Types.supported */
         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;
         enabled(key: string, username?: string): boolean;
-        parseFunction<U = unknown>(value: unknown, options?: ParseFunctionOptions): Null<FunctionType<Promise<U> | U>>;
-        parseFunction<U = unknown>(value: unknown, absolute: boolean, sync?: boolean): Null<FunctionType<Promise<U> | U>>;
+        parseFunction<U = unknown, V = unknown>(value: unknown, options?: ParseFunctionOptions): Null<FunctionType<Promise<U> | U, V>>;
+        parseFunction<U = unknown, V = unknown>(value: unknown, absolute: boolean, sync?: boolean): Null<FunctionType<Promise<U> | U, V>>;
         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, options: AsHashOptions): string;
+        asHash(data: BinaryLike, algorithm?: unknown, digest?: unknown): string;
         readHash(value: string | URL, options?: ReadHashOptions): Promise<string>;
         toPosix(value: unknown, normalize: boolean): string;
         toPosix(value: unknown, filename?: string, normalize?: boolean): string;
@@ -747,22 +744,24 @@ declare namespace functions {
         resolvePath(value: string, base: string | URL): string;
         joinPath(...values: [...paths: unknown[], normalize: boolean][]): string;
         joinPath(...values: unknown[]): string;
-        normalizePath(value: unknown, flags?: boolean | number): string;
+        normalizePath(value: unknown, flags?: boolean | NormalizeFlags): string;
         createDir(value: string | URL, overwrite?: boolean): boolean;
         removeDir(value: string | URL, sinceCreated: number, recursive?: boolean): boolean;
         removeDir(value: string | URL, empty?: boolean, recursive?: boolean): boolean;
         copyDir(src: string | URL, dest: string | URL, move?: boolean, recursive?: boolean): Promise<CopyDirResult>;
         copyDir(src: string | URL, dest: string | URL, options?: CopyDirOptions): Promise<CopyDirResult>;
+        globDir(src: string | URL, pattern: ArrayOf<string>, recursive: boolean | number): Promise<string[]>;
+        globDir(src: string | URL, pattern: ArrayOf<string>, options?: GlobDirOptions): Promise<string[]>;
         renameFile(src: string | URL, dest: string | URL, throws?: boolean): boolean;
         streamFile<U extends Bufferable>(value: string | URL, cache: boolean): Promise<U>;
         streamFile<U extends ReadBufferOptions>(value: string | URL, options: U): Promise<U extends { encoding: string } ? string : Buffer>;
         streamFile<U extends ReadBufferOptions>(value: string | URL, cache?: boolean | U, options?: U): Promise<U extends { encoding: string } ? string : Buffer>;
         readText(value: string | URL, cache: boolean): string;
-        readText<U extends ReadTextOptions>(value: string | URL, options: U): U extends { minStreamSize: number | string } ? Promise<string> : string;
+        readText<U extends ReadTextOptions>(value: string | URL, options: U): U extends { minStreamSize: NumString } ? Promise<string> : string;
         readText(value: string | URL, encoding?: BufferEncoding | ReadTextOptions, cache?: boolean): string;
-        readBuffer<U extends ReadBufferOptions>(value: string | URL, options: U): U extends { minStreamSize: number | string } ? Promise<Null<Buffer>> : Null<Buffer>;
+        readBuffer<U extends ReadBufferOptions>(value: string | URL, options: U): U extends { minStreamSize: NumString } ? Promise<Null<Buffer>> : Null<Buffer>;
         readBuffer(value: string | URL, cache?: boolean | ReadBufferOptions): Null<Buffer>;
-        resolveMime(data: FileTypeFormat): Promise<Undef<FileTypeResult>>;
+        resolveMime(data: string | Buffer | Uint8Array | ArrayBuffer): Promise<Undef<FileTypeResult>>;
         lookupMime(value: string, extension?: boolean): string;
         initCpuUsage(instance?: IModule): CpuUsage;
         getCpuUsage(start: CpuUsage, format: true): string;
@@ -773,9 +772,9 @@ declare namespace functions {
         getPackageVersion(name: string | TupleOf<string>, startDir: string, baseDir?: string): string;
         getPackageVersion(name: string | TupleOf<string>, unstable?: boolean, startDir?: string, baseDir?: string): string;
         checkSemVer(name: string | TupleOf<string>, options: CheckSemVerOptions): boolean;
+        checkSemVer(name: string | TupleOf<string>, min: NumString, max?: NumString, unstable?: boolean, startDir?: string): boolean;
         /** @deprecated options */
-        checkSemVer(name: string | TupleOf<string>, min: number | string, max?: number | string, unstable?: boolean, startDir?: string): boolean;
-        checkSemVer(name: string | TupleOf<string>, min: number | string, max: number | string, options?: Omit<CheckSemVerOptions, "min" | "max" | "equals">): boolean;
+        checkSemVer(name: string | TupleOf<string>, min: NumString, max: NumString, options?: CheckSemVerOptions): boolean;
         sanitizeCmd(value: string): string;
         sanitizeArgs(value: string, doubleQuote?: boolean): string;
         sanitizeArgs(values: string[], doubleQuote?: boolean): string[];

package/lib/logger.d.ts

@@ -12,7 +12,6 @@ export interface LogBaseOptions extends LoggerColor, Pick<LogOptions, "queue" |
     sessionId?: string;
     abortable?: boolean;
     titleJustify?: TextAlign;
-    rawOutput?: boolean;
     broadcastId?: BroadcastValue;
     newline?: boolean | number;
 }
@@ -53,7 +52,6 @@ export interface LogMessageOptions extends LogBaseOptions {
     messageUnit?: string;
     messageUnitMinWidth?: number;
     messageUnitIndent?: number | [number, string];
-    messageTextWrap?: boolean | TextWrapStyle;
     progressBar?: boolean;
     alwaysVisible?: boolean;
     titleIndent?: boolean | number;
@@ -108,7 +106,6 @@ export type LogComponent = Partial<Pick<LogStatus<StatusType>, "type" | "value"
 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 BroadcastValue = ArrayOf<string> | { value: ArrayOf<string>; stripAnsi?: boolean };

package/lib/module.d.ts

@@ -3,9 +3,8 @@ import type { ChecksumBase } from './squared';
 import type { StreamAction } from './asset';
 
 import type { HashOptions } from 'crypto';
-import type { Readable } from 'stream';
 
-export const enum NORMALIZE_FLAGS {
+declare enum NORMALIZE_FLAGS {
     NONE = 0,
     RESOLVE = 1,
     ENSURE_DIR = 2,
@@ -16,29 +15,16 @@ export interface RequireAction {
     requireExt?: ArrayOf<string> | boolean;
 }
 
-export interface ThrowsAction {
-    throwsPermission?: boolean;
-    throwsDoesNotExist?: boolean;
-}
-
-export interface ExecAction {
-    uid?: number | string;
-    gid?: number | string;
-}
-
-export interface IncludeAction<T = string[]> {
-    include?: T;
-    exclude?: T;
-}
-
 export interface PermissionOptions {
     ownPermissionOnly?: boolean;
     hostPermissionOnly?: boolean;
 }
 
-export interface FileSystemOptions extends PermissionOptions, ThrowsAction {
+export interface FileSystemOptions extends PermissionOptions {
     absolutePath?: boolean;
     ignorePermission?: boolean;
+    throwsPermission?: boolean;
+    throwsDoesNotExist?: boolean;
 }
 
 export interface ReadFileOptions extends FileSystemOptions, StreamBase, RequireAction {
@@ -69,6 +55,10 @@ export interface RemoveDirOptions extends FileSystemOptions {
 export type MoveFileOptions = CopyFileOptions;
 export type CreateDirOptions = FileSystemOptions;
 
+export interface GetFunctionsOptions extends ParseFunctionOptions {
+    outFailed?: string[];
+}
+
 export interface ParseFunctionOptions extends RequireAction {
     absolute?: boolean;
     sync?: boolean;
@@ -76,9 +66,20 @@ export interface ParseFunctionOptions extends RequireAction {
     context?: unknown;
 }
 
+export interface CloneObjectOptions<T = unknown> {
+    target?: T;
+    deep?: boolean;
+    deepIgnore?: WeakSet<object>;
+    typedArray?: boolean;
+    mergeArray?: MergeArrayMethod;
+    mergeDepth?: number;
+    symbol?: boolean;
+    inherited?: boolean;
+    nonenumerable?: boolean;
+    preserve?: boolean;
+}
+
 export interface CheckSemVerOptions extends MinMax {
-    equals?: string;
-    includes?: boolean;
     startDir?: string;
     unstable?: boolean;
 }
@@ -100,6 +101,14 @@ export interface CopyDirResult {
     ignored: string[];
 }
 
+export interface GlobDirOptions {
+    exclude?: ArrayOf<string>;
+    recursive?: boolean | number;
+    matchBase?: boolean;
+    dot?: boolean;
+    contains?: boolean;
+}
+
 export interface StreamBase extends StreamAction {
     signal?: AbortSignal;
 }
@@ -113,9 +122,12 @@ export interface ReadBufferOptions extends StreamBase {
     cache?: boolean;
 }
 
-export interface AsHashOptions extends HashOptions, ChecksumBase {}
+export interface AsHashOptions extends HashOptions, ChecksumBase {
+    /** @deprecated */
+    minLength?: number;
+}
 
-export interface TempDirOptions {
+export interface GetTempDirOptions {
     pathname?: string;
     filename?: string;
     moduleDir?: boolean;
@@ -124,7 +136,18 @@ export interface TempDirOptions {
     increment?: number;
 }
 
+export interface ExecAction {
+    uid?: NumString;
+    gid?: NumString;
+}
+
+export interface IncludeAction<T = string[]> {
+    include?: T;
+    exclude?: T;
+}
+
+export type NormalizeFlags = typeof NORMALIZE_FLAGS[keyof typeof NORMALIZE_FLAGS];
 export type ReadTextOptions = ReadBufferOptions;
 export type ReadFileCallback<T extends Bufferable = Bufferable> = (err: Null<NodeJS.ErrnoException>, data?: T) => void;
 export type ProtocolType = "http" | "https" | "http/s" | "ftp" | "sftp" | "s/ftp" | "torrent" | "unc" | "file";
-export type FileTypeFormat = Bufferable | Uint8Array | ArrayBuffer | Readable;
+export type MergeArrayMethod = "concat" | "concat-pre" | "includes" | "unshift" | "push" | "flat" | "join" | "slice" | "reverse" | ["flat", number] | ["join", string] | ["slice", number, number?];

package/lib/node.d.ts

@@ -1,10 +1,10 @@
 import type { RequestData as IRequestData } from './squared';
 
 import type { ExternalAsset } from './asset';
-import type { HostInitConfig, HostInitLog } from './core';
+import type { HostInitConfig } from './core';
 import type { DownloadModule, ErrorModule, LoggerModule, MemoryModule, NodeModule, PermissionModule, ProcessModule, RequestModule, TempModule } from './settings';
 
-export interface RequestData<T extends ExternalAsset = ExternalAsset, U extends HostInitLog = HostInitLog> extends Readonly<Omit<IRequestData, "log">>, Readonly<HostInitConfig<U>> {
+export interface RequestData<T extends ExternalAsset = ExternalAsset> extends Readonly<Omit<IRequestData, "log">>, Readonly<HostInitConfig> {
     readonly assets?: T[];
 }
 

package/lib/object.d.ts

@@ -1,3 +1,5 @@
+/* eslint @typescript-eslint/no-redeclare: "off" */
+
 interface Point {
     x: number;
     y: number;

package/lib/request.d.ts

@@ -1,6 +1,5 @@
 import type { BinaryAction } from './asset';
 import type { HttpProtocolVersion, InternetProtocolVersion } from './http';
-import type { HttpHostSettings } from './settings';
 
 import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
 import type { Readable, Writable } from 'stream';
@@ -40,16 +39,14 @@ export interface IHttpHost {
     get hostname(): string;
     get port(): string;
     get origin(): string;
-    get streamSize(): number;
 }
 
 export interface HttpHostConstructor {
     normalizeOrigin(value: string): string;
     formatBasicAuth(url: URL): string;
     getBasicAuth(url: URL): Undef<OutgoingHttpHeaders>;
-    defineLocalHost(values: string[]): void;
-    defineProtocolNegotiation(data: ObjectMap<string[]>): void;
-    defineHostConfig(settings: HttpHostSettings): void;
+    defineLocalHost(value: string[]): void;
+    defineProtocolNegotiation(value: ObjectMap<string[]>): void;
     readonly prototype: IHttpHost;
     new(url: URL, httpVersion?: HttpProtocolVersion): IHttpHost;
 }
@@ -57,24 +54,24 @@ export interface HttpHostConstructor {
 export interface OpenOptions extends KeepAliveAction, SilentAction {
     host?: IHttpHost;
     url?: URL;
-    base?: boolean;
     socketPath?: string;
     httpVersion?: HttpProtocolVersion;
-    method?: "GET" | "POST" | "HEAD";
+    method?: HttpMethod | Lowercase<HttpMethod>;
     search?: StringMap;
     /** @deprecated followRedirect */
     follow_redirect?: boolean;
     followRedirect?: boolean;
     encoding?: BufferEncoding;
-    maxBufferSize?: number | string;
+    maxBufferSize?: NumString;
     format?: BufferFormat | { out?: BufferFormat; parser?: PlainObject };
-    headers?: OutgoingHttpHeaders;
+    headers?: OutgoingHttpHeaders | Headers;
+    signal?: AbortSignal;
     timeout?: number;
     pipeTo?: string | Writable;
     postData?: unknown;
     connected?: (headers: IncomingHttpHeaders) => Void<boolean>;
     statusMessage?: string;
-    progressId?: number | string;
+    progressId?: NumString;
     outFormat?: { out: BufferFormat; parser?: PlainObject };
     outFilename?: Null<string>;
     outHeaders?: Null<IncomingHttpHeaders>;
@@ -82,12 +79,15 @@ export interface OpenOptions extends KeepAliveAction, SilentAction {
     outAbort?: AbortController;
 }
 
-export interface PostOptions extends OpenOptions {
+export interface PutOptions extends OpenOptions {
     contentType?: string;
-    formData?: ArrayOf<FormDataPart>;
     dataEncoding?: BufferEncoding;
 }
 
+export interface PostOptions extends PutOptions {
+    formData?: ArrayOf<FormDataPart>;
+}
+
 export interface FormDataPart {
     name?: string;
     data?: Buffer | Readable | string;
@@ -98,7 +98,8 @@ export interface FormDataPart {
 
 export interface Aria2Options extends BinaryAction, SilentAction {
     pathname?: string;
-    headers?: OutgoingHttpHeaders;
+    headers?: OutgoingHttpHeaders | Headers;
+    signal?: AbortSignal;
 }
 
 export interface HostConfig extends OpenOptions {
@@ -133,6 +134,7 @@ export interface ApplyOptions extends ProtocolAction, PlainObject {
     keepAlive?: boolean;
 }
 
+export type HttpMethod = "GET" | "POST" | "PUT" | "HEAD" | "DELETE";
 export type BufferFormat = "json" | "yaml" | "json5" | "xml" | "toml";
 export type ReadExpectType = "always" | "string" | "none";
 export type DataEncodedResult<T extends { encoding?: BufferEncoding }> = T extends { encoding: BufferEncoding } ? string : Null<Bufferable>;