@e-mc/types 0.10.5 → 0.11.0

package/lib/index.d.ts

@@ -1,13 +1,10 @@
-/* eslint @typescript-eslint/no-explicit-any: "off" */
-
 /// <reference path="type.d.ts" />
-/// <reference path="object.d.ts" />
 
-import type { CompressLevel, DataSource, DbDataSource, IncrementalMatch, LogStatus, TaskAction, ViewEngine } from './squared';
+import type { 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, TryFileCompressor } from './compress';
+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 { 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';
@@ -15,25 +12,24 @@ 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, 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, PutOptions, ReadExpectType, RequestInit, StatusOnCallback } from './request';
+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 { 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 { 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 } 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 { SpawnOptions } from 'node:child_process';
+import type { BinaryLike, BinaryToTextEncoding, HashOptions } from 'node:crypto';
+import type { NoParamCallback, WriteStream } from 'node:fs';
+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 { FileTypeResult } from 'file-type';
 
-import type * as EventEmitter from 'events';
+import type * as EventEmitter from 'node:events';
 // @ts-ignore
 import type * as ws from 'ws';
 
@@ -42,6 +38,7 @@ 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;
@@ -59,13 +56,12 @@ declare namespace functions {
         get extensions(): T[];
     }
 
-    interface ICompress<T extends CompressModule<U>, U extends CompressSettings = CompressSettings> extends IModule, IExternalConfig<T, U> {
+    interface ICompress<T extends CompressModule = CompressModule, 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): Readable;
+        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;
         createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
@@ -76,38 +72,42 @@ 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: number | string | undefined);
+        get chunkSize(): number | undefined;
     }
 
-    interface CompressConstructor<T extends CompressModule<U> = CompressModule<any>, U extends CompressSettings = CompressSettings> extends ModuleConstructor {
-        singleton(): ICompress<CompressModule>;
+    interface CompressConstructor<T extends CompressModule = CompressModule, U extends CompressSettings = CompressSettings> extends ModuleConstructor {
+        singleton(): ICompress<T, U>;
         readonly prototype: ICompress<T, U>;
         new(module?: U): ICompress<T, U>;
     }
 
     interface IImage<T extends IHost = IHost, U extends ImageModule = ImageModule> extends IClient<T, U> {
-        resizeData?: ResizeData;
-        cropData?: CropData;
-        rotateData?: RotateData;
-        qualityData?: QualityData;
-        methodData?: [string, unknown[]?][];
+        resizeData?: ResizeData | null;
+        cropData?: CropData | null;
+        rotateData?: RotateData | null;
+        qualityData?: QualityData | null;
+        methodData?: [string, unknown[]?][] | null;
         opacityValue?: number;
         outputType?: string;
         setCommand(value: string | CommandData, outputAs?: string): void;
         getCommand(): string;
         parseCommand(value: string): CommandData;
-        parseMethod(value: string): Undef<[string, unknown[]?][]>;
-        parseResize(value: string): Undef<ResizeData>;
-        parseCrop(value: string): Undef<CropData>;
-        parseRotate(value: string): Undef<RotateData>;
-        parseQuality(value: string): Undef<QualityData>;
+        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>;
         parseOpacity(value: string): number;
         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 {
         readonly REGEXP_SIZERANGE: RegExp;
-        transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<V extends { tempFile: true } ? string : Null<Buffer>>;
+        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;
         toABGR(buffer: Uint8Array | Buffer): Buffer;
@@ -118,11 +118,13 @@ declare namespace functions {
     interface ITask<T extends IHost = IHost, U extends TaskModule = TaskModule> extends IClient<T, U> {
         using?<V extends ExternalAsset>(data: IFileThread<V>): Promise<unknown>;
         collect?(items: unknown[], preceding?: boolean): Promise<SpawnResult>[];
-        map?(tasks: Command[]): Promise<Void<SpawnResult>>[];
+        map?(tasks: Command[]): Promise<SpawnResult | void>[];
         series?(tasks: Command[]): Promise<unknown>;
         parallel?(tasks: Command[]): Promise<unknown>;
         spawn?(task: PlainObject, callback: (result?: SpawnResult) => void): void;
         execute?<V extends IFileManager<W>, W extends ExternalAsset>(manager: V, task: PlainObject, callback: (value?: unknown) => void): void;
+        set host(value);
+        get host(): T | null;
     }
 
     interface TaskConstructor<T extends IHost = IHost, U extends TaskModule = TaskModule> extends ModuleConstructor {
@@ -133,7 +135,7 @@ declare namespace functions {
 
     interface IDb<T extends IHost = IHost, U extends DbModule = DbModule, V extends DbDataSource = DbDataSource, W extends DbSourceOptions = DbSourceOptions, X extends DbCoerceSettings = DbCoerceSettings> extends IClientDb<T, U, V, W, X> {
         setCredential(item: V): Promise<void>;
-        getCredential<Y = PlainObject>(item: V): Undef<Y>;
+        getCredential<Y = PlainObject>(item: V): Y | undefined;
         hasSource(source: string, ...type: number[]): boolean;
         applyCommand(...items: V[]): void;
         executeQuery(item: V, callback: ErrorQueryCallback): Promise<QueryResult>;
@@ -142,8 +144,8 @@ declare namespace functions {
         executeBatchQuery(batch: V[], callback: ErrorQueryCallback, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
         executeBatchQuery(batch: V[], sessionKey: string, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
         executeBatchQuery(batch: V[], options?: ExecuteBatchQueryOptions | string, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
-        processRows(batch: V[], tasks: Promise<Null<QueryResult>>[], parallel: boolean): Promise<BatchQueryResult>;
-        processRows(batch: V[], tasks: Promise<Null<QueryResult>>[], options?: ProcessRowsOptions, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
+        processRows(batch: V[], tasks: Promise<QueryResult | null>[], parallel: boolean): Promise<BatchQueryResult>;
+        processRows(batch: V[], tasks: Promise<QueryResult | null>[], options?: ProcessRowsOptions, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
         handleFail(err: unknown, item: V, options?: HandleFailOptions): boolean;
         readTLSCert(value: unknown, cache?: boolean): string;
         readTLSConfig(options: SecureContextOptions, cache?: boolean): void;
@@ -151,14 +153,16 @@ declare namespace functions {
         settingsOf(source: string, name: "coerce", component: keyof X): unknown;
         settingsKey(source: string, name: keyof Omit<W, "coerce">): unknown;
         settingsKey(source: string, name: "coerce", component: keyof X): unknown;
-        getPoolConfig(source: string, uuidKey?: string): Undef<Required<PoolConfig>>;
+        getPoolConfig(source: string, uuidKey?: string): Required<PoolConfig> | undefined;
         get sourceType(): DB_TYPE;
         get commandType(): SQL_COMMAND;
+        set host(value);
+        get host(): T | null;
     }
 
     interface DbConstructor<T extends IHost = IHost, U extends DbModule = DbModule, V extends DbDataSource = DbDataSource> extends ClientDbConstructor<T> {
         setPoolConfig(value: ObjectMap<PoolConfig>): void;
-        getPoolConfig(source: string): Undef<Required<PoolConfig>>;
+        getPoolConfig(source: string): Required<PoolConfig> | undefined;
         readonly prototype: IDb<T, U, V>;
         new(module?: U, database?: V[], ...args: unknown[]): IDb<T, U, V>;
     }
@@ -171,10 +175,11 @@ declare namespace functions {
         setBucketPolicy(service: string, credential: unknown, bucket: string, options: unknown): Promise<boolean>;
         setBucketTagging(service: string, credential: unknown, bucket: string, options: unknown): Promise<boolean>;
         setBucketWebsite(service: string, credential: unknown, bucket: string, options: BucketWebsiteOptions): Promise<boolean>;
-        deleteObjects(service: string, credential: unknown, bucket: string, recursive?: boolean): Promise<void>;
-        uploadObject(service: string, credential: unknown, bucket: string, upload: CloudStorageUpload, localUri: string, beforeResolve?: (value: string) => Void<Promise<void>>): Promise<string>;
-        downloadObject(service: string, credential: unknown, bucket: string, download: CloudStorageDownload, beforeResolve?: (value: Null<Bufferable>) => Void<Promise<Undef<string>>>): Promise<Bufferable>;
-        getStorage(action: CloudFunctions, data: Undef<CloudStorage[]>): Undef<CloudStorage>;
+        deleteObjects(service: string, credential: unknown, bucket: string, options: DeleteObjectsOptions): Promise<void>;
+        deleteObjects(service: string, credential: unknown, bucket: string, recursive?: boolean | DeleteObjectsOptions): Promise<void>;
+        uploadObject(service: string, credential: unknown, bucket: string, upload: CloudStorageUpload, localUri: string, beforeResolve?: ((value: string) => Promise<void> | void)): Promise<string>;
+        downloadObject(service: string, credential: unknown, bucket: string, download: CloudStorageDownload, beforeResolve?: ((value: Bufferable | null) => Promise<string | undefined> | void)): Promise<Bufferable>;
+        getStorage(action: CloudFunctions, data: CloudStorage[] | undefined): CloudStorage | undefined;
         hasStorage(action: CloudFunctions, storage: CloudStorage): CloudStorageUpload | false;
         getDatabaseRows(item: V, ignoreErrors: boolean, sessionKey?: string): Promise<QueryResult>;
         getDatabaseRows(item: V, sessionKey?: string): Promise<QueryResult>;
@@ -182,13 +187,15 @@ declare namespace functions {
         getDatabaseBatchRows(batch: V[], sessionKey?: string): Promise<BatchQueryResult>;
         hasCredential(feature: CloudFeatures, data: CloudService, credential?: unknown): boolean;
         getCredential(item: CloudService, unused?: boolean): PlainObject;
-        getSettings(service: string): Undef<AnyObject>;
+        getSettings(service: string): AnyObject | undefined;
         settingsOf(service: string, name: "cache"): unknown;
         settingsOf(service: string, name: "coerce", component: keyof DbCoerceSettings): unknown;
         settingsOf(service: string, name: "auth", component: keyof CloudAuthSettings): unknown;
         getUploadHandler(service: string, credential: unknown): FunctionType<void>;
         getDownloadHandler(service: string, credential: unknown): FunctionType<void>;
         resolveService(service: string, folder?: string): string;
+        set host(value);
+        get host(): T | null;
     }
 
     interface CloudConstructor<T extends IHost = IHost, U extends CloudModule = CloudModule, V extends CloudDatabase = CloudDatabase> extends ClientDbConstructor<T> {
@@ -199,17 +206,17 @@ declare namespace functions {
         LOG_CLOUD_DOWNLOAD: LogMessageOptions;
         LOG_CLOUD_DELETE: LogMessageOptions;
         LOG_CLOUD_DELAYED: LogMessageOptions;
-        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>[];
+        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>[];
         sanitizeAssets<W extends ExternalAsset>(assets: W[]): W[];
         readonly prototype: ICloud<T, U, V>;
         new(module?: U, database?: CloudDatabase[], ...args: unknown[]): ICloud<T, U, V>;
     }
 
     interface IDocument<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends IClient<T, V, TransformCallback<T, U>> {
-        Db: Null<IDb>;
+        Db: IDb | null;
         assets: U[];
         config: StandardMap;
         init(assets: U[], config?: HostInitConfig): this;
@@ -218,40 +225,42 @@ declare namespace functions {
         loadConfig(data: object, name: string): Optional<ConfigOrTransformer>;
         asSourceFile(value: string, cache: boolean): unknown;
         asSourceFile(value: string, options?: AsSourceFileOptions): unknown;
-        findVersion(name: ArrayOf<string>, fallback?: string): string;
+        findVersion(name: string | string[], fallback?: string): string;
         findSourceScope(uri: string, imports: AnyObject): StringMap[];
-        findSourceRoot(uri: string, imports?: StringMap): Undef<string>;
-        resolveDir(name: string, ...paths: string[]): Undef<string>;
-        locateSourceFiles(file: U, code?: string, bundleContent?: string[]): (imports?: StringMap) => Undef<SourceInput>;
-        resolveSourceFile(file: U): (code?: string, imports?: StringMap) => Undef<SourceInput<string>>;
+        findSourceRoot(uri: string, imports?: StringMap): string | undefined;
+        resolveDir(name: string, ...paths: string[]): string | undefined;
+        locateSourceFiles(file: U, code?: string, bundleContent?: string[]): (imports?: StringMap) => SourceInput | undefined;
+        resolveSourceFile(file: U): (code?: string, imports?: StringMap) => SourceInput<string> | undefined;
         tryParse(source: string, format: string, options?: PlainObject): unknown;
         forDb(item: DataSource): boolean;
         hasEval(name: string): boolean;
         settingsOf(name: keyof W, option: keyof X): unknown;
-        parseTemplate(viewEngine: ViewEngine | string, template: string, data: unknown[]): Promise<Null<string>>;
-        transform(type: string, code: string, format: ArrayOf<string>, options?: TransformOutput & TransformAction): Promise<Void<TransformResult>>;
+        parseTemplate(viewEngine: ViewEngine | string, template: string, data: unknown[]): Promise<string | null>;
+        transform(type: string, code: string, format: string | string[], options?: TransformOutput & TransformAction): Promise<TransformResult | void>;
         abort(err: Error): void;
         abort(name?: keyof W, reason?: unknown): void;
         restart(): void;
         using?(data: IFileThread<U>): Promise<unknown>;
         setLocalUri?(file: U, replace?: boolean): void;
         resolveUri?(file: U, source: string): string;
-        resolveUri?(file: U, source: string, trailing: string): TupleOf<string>;
-        resolveImports?(file: U, code: string, baseFile?: string | U): Undef<string>;
-        replaceContent?(source: string, statement: RegExpExecArray | string, mimeType?: string): Undef<string>;
-        addCopy?(data: FileCommand<U>, saveAs: string, replace?: boolean): Undef<string>;
+        resolveUri?(file: U, source: string, trailing: string): [string, string];
+        resolveImports?(file: U, code: string, baseFile?: string | U): string | undefined;
+        replaceContent?(source: string, statement: RegExpExecArray | string, mimeType?: string): string | undefined;
+        addCopy?(data: FileCommand<U>, saveAs: string, replace?: boolean): string | undefined;
         writeImage?(output: OutputFinalize<U>): boolean;
         cloudInit?(state: IScopeOrigin<T, Y>): void;
         cloudObject?(state: IScopeOrigin<T, Y>, file: U): boolean;
         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): Undef<WatchInitResult>;
+        watchInit?(watch: IFileGroup<U>, assets: U[], sanitize?: boolean): WatchInitResult | undefined;
         watchModified?(watch: IFileGroup<U>, assets?: U[]): PostFinalizeCallback;
         set dataSource(value: DataSource[]);
         get dataSource(): DataSource[];
         set imports(value);
         get imports(): StringMap;
         get watching(): boolean;
+        set host(value);
+        get host(): T | null;
     }
 
     interface DocumentConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends ModuleConstructor {
@@ -260,12 +269,12 @@ declare namespace functions {
         createSourceMap(code: string, remove: boolean): SourceMap;
         /** @deprecated */
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
-        writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): Undef<string>;
+        writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): string | undefined;
         updateGradle(source: string, namespaces: string[], value: string, upgrade: boolean): string;
         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?: U[]): U[];
+        sanitizeAssets?(assets: U[], exclusions?: unknown[]): U[];
         readonly prototype: IDocument<T, U, V, W, X, Y>;
         new(module?: V, ...args: unknown[]): IDocument<T, U, V, W, X, Y>;
     }
@@ -273,8 +282,8 @@ declare namespace functions {
     interface IWatch<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionType<unknown, any> = ModifiedPostFinalizeListener<U>> extends IClient<T, V, W> {
         connectTimeout: number;
         init(config?: HostInitConfig): this;
-        start(assets: U[], permission?: Null<IPermission>): void;
-        modified(watch: IFileGroup<U>): Promise<Void<FinalizeResult>>;
+        start(assets: U[], permission?: IPermission | null): void;
+        modified(watch: IFileGroup<U>): Promise<FinalizeResult | void>;
         configureServer(options: SecureOptions): boolean;
         setCA(value: string): boolean;
         setSSLKey(value: string): boolean;
@@ -290,42 +299,45 @@ declare namespace functions {
         get port(): number;
         set securePort(value);
         get securePort(): number;
+        set host(value);
+        get host(): T | null;
     }
 
     interface WatchConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionType<unknown, any> = ModifiedPostFinalizeListener<U>> extends ModuleConstructor {
-        createServer(port: number, active: boolean): Null<ws.Server>;
-        createServer(port: number, secure?: Null<SecureOptions>, active?: boolean): Null<ws.Server>;
+        createServer(port: number, active: boolean): ws.Server | null;
+        createServer(port: number, secure?: SecureOptions | null, active?: boolean): ws.Server | null;
         shutdown(): void;
-        setTimeout(value: NumString): void;
+        setTimeout(value: number | string): void;
         checkTimeout(client: ws): boolean;
+        isConnectionError(err: unknown): 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<U>, U extends RequestSettings = RequestSettings> extends IModule, IExternalConfig<T, U> {
+    interface IRequest<T extends RequestModule = RequestModule, U extends RequestSettings = RequestSettings> extends IModule, IExternalConfig<T, U> {
         startTime: number;
         acceptEncoding: boolean;
-        keepAlive: Null<boolean>;
+        keepAlive: boolean | null;
         readTimeout: number;
         readExpect: ReadExpectType;
-        proxy: Null<ProxySettings>;
+        proxy: ProxySettings | null;
         init(config?: RequestInit): this;
         apply(options: ApplyOptions): this;
         addDns(hostname: string, address: string, timeout: number): void;
-        addDns(hostname: string, address: string, family?: NumString, timeout?: number): void;
+        addDns(hostname: string, address: string, family?: number | string, timeout?: number): void;
         lookupDns(hostname: string): LookupFunction;
-        proxyOf(uri: string, localhost?: boolean): Undef<ProxySettings>;
-        statusOn(name: ArrayOf<number>, callback: StatusOnCallback): void;
-        statusOn(name: ArrayOf<number>, globUrl: string, callback: StatusOnCallback): void;
-        headersOn(name: ArrayOf<string>, callback: HeadersOnCallback): void;
-        headersOn(name: ArrayOf<string>, globUrl: string, callback: HeadersOnCallback): void;
-        headersOf(uri: string): Undef<OutgoingHttpHeaders>;
+        proxyOf(uri: string, localhost?: boolean): ProxySettings | undefined;
+        statusOn(name: number | number[], callback: StatusOnCallback): void;
+        statusOn(name: number | number[], globUrl: string, callback: StatusOnCallback): void;
+        headersOn(name: string | string[], callback: HeadersOnCallback): void;
+        headersOn(name: string | string[], globUrl: string, callback: HeadersOnCallback): void;
+        headersOf(uri: string): OutgoingHttpHeaders | undefined;
         aria2c(uri: string | URL, pathname: string): Promise<string[]>;
         aria2c(uri: string | URL, options?: Aria2Options): Promise<string[]>;
-        json(uri: string | URL, options?: OpenOptions): Promise<Null<object>>;
+        json(uri: string | URL, options?: OpenOptions): Promise<object | null>;
         pipe(uri: string | URL, to: Writable, options?: OpenOptions): Promise<null>;
-        opts(url: string | URL, options?: OpenOptions): HostConfig;
+        opts<V extends OpenOptions>(url: string | URL, options?: V): HostConfig & V;
         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>>;
@@ -336,25 +348,28 @@ declare namespace functions {
         post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, form: AnyObject, parts: FormDataPart[]): Promise<DataObjectResult<V>>;
         post<V extends PostOptions>(uri: string | URL, data: unknown, options: V): Promise<DataObjectResult<V>>;
         post<V extends PostOptions>(uri: string | URL, data: unknown, contentType?: string | FormDataPart[] | V, options?: V): Promise<DataObjectResult<V>>;
-        get<V extends OpenOptions, W extends V | BufferFormat>(uri: string | URL, options?: W): Promise<W extends BufferFormat ? Null<object> : DataEncodedResult<V>>;
+        get<V extends OpenOptions, W extends V | BufferFormat>(uri: string | URL, options?: W): Promise<W extends BufferFormat ? object | null : DataEncodedResult<V>>;
         detach(singleton?: boolean): void;
-        reset(): void;
+        reset(adapter?: IHttpAdapter): void;
         close(): void;
+        set adapter(value: unknown);
         set agentTimeout(value);
         get agentTimeout(): number;
         set httpVersion(value);
-        get httpVersion(): Null<HttpProtocolVersion>;
+        get httpVersion(): HttpProtocolVersion | null;
         set ipVersion(value);
         get ipVersion(): InternetProtocolVersion;
     }
 
-    interface RequestConstructor<T extends RequestModule<U> = RequestModule<any>, U extends RequestSettings = RequestSettings> extends ModuleConstructor {
+    interface RequestConstructor<T extends RequestModule = RequestModule, 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;
+        /** @deprecated */
         fromURL(url: URL, value: string): string;
-        fromStatusCode(value: NumString): string;
+        /** @deprecated */
+        fromStatusCode(value: number | string): string;
         defineHttpAgent(options: HttpAgentSettings): void;
         defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
         getAria2Path(): string;
@@ -364,17 +379,15 @@ declare namespace functions {
 
     interface IFileManager<T extends ExternalAsset = ExternalAsset> extends IHost, Set<string> {
         processTimeout: number;
-        cacheToDisk: IHttpDiskCache<T>;
-        cacheToMemory: IHttpMemoryCache<T>;
-        Request: IRequest<RequestModule>;
+        Request: IRequest;
         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<CompressModule>>;
+        Image: ImageMimeMap | null;
+        Cloud: ICloud | null;
+        Watch: WatchInstance<T> | null;
+        Compress: ICompress | null;
         readonly documentAssets: T[];
-        readonly taskAssets: (T & Required<TaskAction>)[];
+        readonly taskAssets: Array<T & Required<TaskAction>>;
         readonly dataSourceItems: DataSource[];
         readonly files: Set<string>;
         readonly filesQueued: Set<string>;
@@ -386,39 +399,43 @@ declare namespace functions {
         readonly fetchedAssets: T[];
         readonly copiedAssets: T[];
         readonly emptyDir: Set<string>;
-        install(name: "document", handler: string, module?: DocumentModule, ...args: unknown[]): Undef<IDocument<IFileManager<T>, T>>;
-        install(name: "document", target: DocumentConstructor<IFileManager<T>, T>, module?: DocumentModule, ...args: unknown[]): Undef<IDocument<IFileManager<T>, T>>;
-        install(name: "task", handler: string, module?: TaskModule, ...args: unknown[]): Undef<ITask>;
-        install(name: "task", target: TaskConstructor, module?: TaskModule, ...args: unknown[]): Undef<ITask>;
-        install(name: "cloud", handler: string, module?: CloudModule, ...args: unknown[]): Undef<ICloud>;
-        install(name: "cloud", module?: CloudModule): Undef<ICloud>;
-        install(name: "image", handler: string, module?: ImageModule, ...args: unknown[]): Undef<IImage>;
-        install(name: "image", target: ImageConstructor, module?: ImageModule, ...args: unknown[]): Undef<IImage>;
+        readonly cacheToDisk: IHttpDiskCache<T>;
+        readonly cacheToMemory: IHttpMemoryCache<T>;
+        install(name: "document", handler: string, module?: DocumentModule, ...args: unknown[]): IDocument<IFileManager<T>, T> | undefined;
+        install(name: "document", target: DocumentConstructor<IFileManager<T>, T>, module?: DocumentModule, ...args: unknown[]): IDocument<IFileManager<T>, T> | undefined;
+        install(name: "task", handler: string, module?: TaskModule, ...args: unknown[]): ITask | undefined;
+        install(name: "task", target: TaskConstructor, module?: TaskModule, ...args: unknown[]): ITask | undefined;
+        install(name: "cloud", handler: string, module?: CloudModule, ...args: unknown[]): ICloud | undefined;
+        install(name: "cloud", module?: CloudModule): ICloud | undefined;
+        install(name: "image", handler: string, module?: ImageModule, ...args: unknown[]): IImage | undefined;
+        install(name: "image", target: ImageConstructor, module?: ImageModule, ...args: unknown[]): IImage | undefined;
         install(name: "image", targets: Map<string, ImageConstructor>, module?: ImageModule): void;
-        install(name: "watch", module: WatchModule): Undef<WatchInstance<T>>;
-        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>;
+        install(name: "watch", handler: string, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
+        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;
         using(...items: FirstOf<T>): this;
         contains(item: T, condition?: FunctionArgs<[T], boolean>): boolean;
         removeCwd(value: unknown): string;
-        findAsset(value: string | URL, instance?: IModule | FindAssetOptions<T>): Undef<T>;
+        findAsset(value: string | URL, instance?: IModule | FindAssetOptions<T>): T | undefined;
         removeAsset(file: T): boolean;
-        replace(file: T, replaceWith: string, mimeType: Undef<string>): boolean;
+        replace(file: T, replaceWith: string, mimeType: string | undefined): boolean;
         replace(file: T, replaceWith: string, options?: ReplaceOptions): boolean;
         rename(file: T, value: string): boolean;
         performAsyncTask(): void;
         removeAsyncTask(): void;
         completeAsyncTask(err?: unknown, uri?: string, parent?: T, type?: number): void;
         performFinalize(override?: boolean): void;
-        hasDocument(instance: IModule, document: Undef<ArrayOf<string>>): boolean;
+        hasDocument(instance: IModule, document: string | string[] | undefined): 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;
         openThread(instance: IModule, data: IFileThread<T>, timeout?: number): boolean;
-        closeThread(instance: Null<IModule>, data: IFileThread<T>, callback?: FunctionType<void>): boolean;
+        closeThread(instance: IModule | null, data: IFileThread<T>, callback?: FunctionType<void>): boolean;
         addProcessTimeout(instance: IModule, file: T, timeout: number): void;
         removeProcessTimeout(instance: IModule, file: T): void;
         getProcessTimeout(handler: InstallData): number;
@@ -428,24 +445,24 @@ declare namespace functions {
         setTaskLimit(value: number): void;
         addDownload(value: number | Bufferable, encoding: BufferEncoding): number;
         addDownload(value: number | Bufferable, type?: number | BufferEncoding, encoding?: BufferEncoding): number;
-        getDownload(type?: number): TupleOf<number>;
+        getDownload(type?: number): [number, number];
         transformAsset(data: IFileThread<T>, parent?: T, override?: boolean): Promise<boolean>;
-        addCopy(data: FileCommand<T>, saveAs?: string, replace?: boolean): Undef<string>;
+        addCopy(data: FileCommand<T>, saveAs?: string, replace?: boolean): string | undefined;
         findMime(file: T, rename?: boolean): Promise<string>;
         getUTF8String(file: T, uri?: string): string;
-        getBuffer<U>(file: T, minStreamSize?: U): U extends number ? Promise<Null<Buffer>> : Null<Buffer>;
+        getBuffer<U>(file: T, minStreamSize?: U): U extends number ? Promise<Buffer | null> : Buffer | null;
         getCacheDir(url: string | URL, createDir?: boolean): string;
         setAssetContent(file: T, content: string, options?: AssetContentOptions): string;
-        getAssetContent(file: T, content?: string): Undef<string>;
-        writeBuffer(file: T, options?: WriteFileOptions): Null<Buffer>;
-        writeImage(document: ArrayOf<string>, output: OutputFinalize<T>): boolean;
+        getAssetContent(file: T, content?: string): string | undefined;
+        writeBuffer(file: T, options?: WriteFileOptions): Buffer | null;
+        writeImage(document: string | string[], output: OutputFinalize<T>): boolean;
         compressFile(file: T, overwrite?: boolean): Promise<unknown>;
-        fetchObject(uri: string | URL, format: BufferFormat): Promise<Null<object>>;
-        fetchObject(uri: string | URL, options?: OpenOptions | BufferFormat): Promise<Null<object>>;
+        fetchObject(uri: string | URL, format: BufferFormat): Promise<object | null>;
+        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[]>;
-        updateProgress(name: "request", id: NumString, receivedBytes: number, totalBytes: number, dataTime?: HighResolutionTime): void;
+        updateProgress(name: "request", id: number | string, 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;
@@ -454,11 +471,12 @@ 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<unknown>;
-        finalizeDocument(): Promise<unknown>;
-        finalizeTask(assets: (T & Required<TaskAction>)[]): Promise<unknown>;
-        finalizeCloud(): Promise<unknown>;
-        finalizeCleanup(): Promise<unknown>;
+        finalizeCompress(assets: T[]): Promise<void>;
+        finalizeDocument(): Promise<void>;
+        finalizeTask(assets: Array<T & Required<TaskAction>>): Promise<void>;
+        finalizeCloud(): Promise<void>;
+        finalizeChecksum(): Promise<void>;
+        finalizeCleanup(): Promise<void>;
         finalize(): Promise<void>;
         close(): void;
         reset(): boolean;
@@ -518,16 +536,17 @@ declare namespace functions {
         loadSettings(settings: Settings, permission?: PermissionReadWrite, password?: string): boolean;
         sanitizeAssets(assets: T[], exclusions?: string[]): T[];
         writeChecksum(root: string, options: ChecksumOptions): Promise<string[]>;
-        writeChecksum(root: string, to?: string | ChecksumOptions, options?: ChecksumOptions): Promise<Null<string[]>>;
-        verifyChecksum(root: string, options: ChecksumOptions): Promise<Null<[string[], string[], number]>>;
-        verifyChecksum(root: string, from?: string | ChecksumOptions, options?: ChecksumOptions): Promise<Null<[string[], string[], number]>>;
+        writeChecksum(root: string, to?: string | ChecksumOptions, options?: ChecksumOptions): Promise<string[] | null>;
+        verifyChecksum(root: string, options: ChecksumOptions): Promise<[string[], string[], number] | null>;
+        verifyChecksum(root: string, from?: string | ChecksumOptions, options?: ChecksumOptions): Promise<[string[], string[], number] | null>;
         createFileThread(host: IFileManager<T>, file: T): IFileThread<T>;
-        setTimeout(options: ObjectMap<NumString>): void;
+        setTimeout(options: ObjectMap<number | string>): void;
         defineHttpCache(options: HttpMemorySettings, disk?: boolean): void;
         defineHttpConnect(options: HttpConnectSettings): void;
+        defineHttpAdapter(module: unknown): void;
         readonly prototype: IFileManager<T>;
         new(baseDirectory: string, config: RequestData<T>, postFinalize?: PostFinalizeCallback): IFileManager<T>;
-        new(baseDirectory: string, config: RequestData<T>, permission?: Null<IPermission>, postFinalize?: PostFinalizeCallback): IFileManager<T>;
+        new(baseDirectory: string, config: RequestData<T>, permission?: IPermission | null, postFinalize?: PostFinalizeCallback): IFileManager<T>;
     }
 
     interface IHost extends IModule {
@@ -537,17 +556,17 @@ declare namespace functions {
         readonly startTime: number;
         using(...items: FirstOf<unknown>): this;
         contains(item: unknown, condition?: FunctionType<boolean, any>): boolean;
-        find(name: string): Undef<IModule>;
+        find(name: string): IModule | undefined;
         findAll(name: string): IModule[];
         willLog(name: string): boolean;
-        ignoreLog(values: boolean | ArrayOf<string>): void;
+        ignoreLog(values: boolean | string | string[]): void;
         collectLog(level?: boolean): LogStatus<StatusType>[];
-        pauseLog(): void;
-        resumeLog(): void;
+        pauseLog(type?: string): void;
+        resumeLog(type?: string): void;
         hasLog(type: string): boolean;
         delayMessage(...args: unknown[]): void;
         willAbort(value: string | IModule): boolean;
-        loadModule(name: string, ...args: any[]): Null<IModule>;
+        loadModule(name: string, ...args: any[]): IModule | null;
         retain(process: IModule): void;
         release(process: IModule, log?: boolean): boolean;
         restart(...args: unknown[]): void;
@@ -558,6 +577,8 @@ declare namespace functions {
         get host(): null;
         get config(): Readonly<HostInitConfig>;
         get username(): string;
+        get ipV4(): string;
+        get ipV6(): string;
         set done(value);
         get done(): boolean;
         get queued(): boolean;
@@ -571,10 +592,11 @@ declare namespace functions {
         isPermission(value: unknown): value is IPermission;
         createPermission(all?: boolean, freeze?: boolean): IPermission;
         kill(username: string, iv: BinaryLike, all: true): number;
-        kill(username: string, iv: BinaryLike, pid: ArrayOf<number>): number;
+        kill(username: string, iv: BinaryLike, pid: number | number[]): number;
         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;
@@ -583,22 +605,21 @@ 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: GetTempDirOptions): string;
+        getTempDir(options: TempDirOptions): string;
         getTempDir(uuidDir: boolean, createDir: boolean): string;
         getTempDir(pathname: string, createDir: boolean): string;
         getTempDir(uuidDir: boolean, filename?: string, createDir?: boolean): string;
         getTempDir(pathname?: string, filename?: string, createDir?: boolean): string;
         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: 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>;
-        readFile<U extends ReadFileCallback, V extends ReadFileOptions>(src: string | URL, options: V, callback: U): Undef<V extends { encoding: string } ? string : U extends ReadFileCallback<infer W> ? W : Bufferable>;
+        readFile(src: string | URL): Buffer | undefined;
+        readFile<U extends ReadFileOptions>(src: string | URL, options?: U): (U extends { encoding: string } ? U extends { minStreamSize: number | string } ? Promise<string> : string : U extends { minStreamSize: number | string } ? Promise<Buffer> : Buffer) | undefined;
+        readFile<U extends Buffer>(src: string | URL, promises: true): Promise<U> | undefined;
+        readFile<U extends Bufferable, V extends ReadFileOptions>(src: string | URL, options: V, promises: true): Promise<(V extends { encoding: string } ? string : U) | undefined>;
+        readFile<U extends ReadFileCallback>(src: string | URL, callback: U): (U extends ReadFileCallback<infer W> ? W : Bufferable) | undefined;
+        readFile<U extends ReadFileCallback, V extends ReadFileOptions>(src: string | URL, options: V, callback: U): (V extends { encoding: string } ? string : U extends ReadFileCallback<infer W> ? W : Bufferable) | undefined;
         writeFile<U extends boolean>(src: string | URL, data: BufferView, options?: WriteFileOptions): U;
         writeFile<U extends Promise<boolean>>(src: string | URL, data: BufferView, promises: true): U;
         writeFile<U extends Promise<boolean>>(src: string | URL, data: BufferView, options: WriteFileOptions, promises: true): U;
@@ -637,10 +658,10 @@ declare namespace functions {
         writeFail(value: LogValue, message?: unknown, options?: 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: Undef<string>, type: LogType): boolean;
-        checkPackage(err: unknown, name: Undef<string>, options: LogFailOptions): boolean;
-        checkPackage(err: unknown, name: Undef<string>, value?: LogValue, options?: LogFailOptions | LogType): boolean;
-        checkFail(message: unknown, options: LogFailOptions): Undef<LogArguments | false>;
+        checkPackage(err: unknown, name: string | undefined, type: LogType): boolean;
+        checkPackage(err: unknown, name: string | undefined, options: LogFailOptions): boolean;
+        checkPackage(err: unknown, name: string | undefined, value?: LogValue, options?: LogFailOptions | LogType): boolean;
+        checkFail(message: unknown, options: LogFailOptions): LogArguments | false | undefined;
         writeLog(component: LogComponent, queue?: boolean): void;
         writeLog(type: StatusType, value: unknown, options: LogOptions): void;
         writeLog(type: StatusType, value: unknown, timeStamp?: LogDate, duration?: number): void;
@@ -658,9 +679,9 @@ declare namespace functions {
         reset(): void;
         get moduleName(): string;
         set host(value);
-        get host(): Null<T>;
+        get host(): T | null;
         set permission(value);
-        get permission(): Null<IPermission>;
+        get permission(): IPermission | null;
         get aborted(): boolean;
         set abortable(value);
         get abortable(): boolean;
@@ -668,9 +689,11 @@ declare namespace functions {
         set sessionId(value);
         get sessionId(): string;
         set broadcastId(value);
-        get broadcastId(): ArrayOf<string>;
+        get broadcastId(): string | string[];
+        set silent(value);
+        get silent(): boolean;
         get logType(): LOG_TYPE;
-        set logLevel(value: NumString);
+        set logLevel(value: number | string);
         get logLevel(): number;
         get statusType(): STATUS_TYPE;
         set tempDir(value);
@@ -718,17 +741,20 @@ 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, 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>>;
+        parseFunction<U = unknown, V = unknown>(value: unknown, options?: ParseFunctionOptions): FunctionType<Promise<U> | U, V> | null;
+        parseFunction<U = unknown, V = unknown>(value: unknown, absolute: boolean, sync?: boolean): FunctionType<Promise<U> | U, V> | null;
         asString(value: unknown, cacheKey?: boolean | "throws"): string;
-        asHash(data: BinaryLike, options: AsHashOptions): string;
-        asHash(data: BinaryLike, algorithm?: unknown, digest?: unknown): string;
+        asHash(data: BinaryLike, options?: AsHashOptions): string;
+        asHash(data: BinaryLike, algorithm?: string, options?: HashOptions): string;
+        asHash(data: BinaryLike, algorithm?: string, digest?: BinaryToTextEncoding): string;
         readHash(value: string | URL, options?: ReadHashOptions): Promise<string>;
         toPosix(value: unknown, normalize: boolean): string;
         toPosix(value: unknown, filename?: string, normalize?: boolean): string;
@@ -744,24 +770,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 | NormalizeFlags): string;
+        normalizePath(value: unknown, flags?: boolean | number): 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[]>;
+        globDir(src: string | URL, pattern: string | string[], recursive: boolean | number): Promise<string[]>;
+        globDir(src: string | URL, pattern: string | 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: NumString } ? Promise<string> : string;
+        readText<U extends ReadTextOptions>(value: string | URL, options: U): U extends { minStreamSize: number | string } ? 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: NumString } ? Promise<Null<Buffer>> : Null<Buffer>;
-        readBuffer(value: string | URL, cache?: boolean | ReadBufferOptions): Null<Buffer>;
-        resolveMime(data: string | Buffer | Uint8Array | ArrayBuffer): Promise<Undef<FileTypeResult>>;
+        readBuffer<U extends ReadBufferOptions>(value: string | URL, options: U): U extends { minStreamSize: number | string } ? Promise<Buffer | null> : Buffer | null;
+        readBuffer(value: string | URL, cache?: boolean | ReadBufferOptions): Buffer | null;
+        resolveMime(data: FileTypeFormat): Promise<FileTypeResult | undefined>;
         lookupMime(value: string, extension?: boolean): string;
         initCpuUsage(instance?: IModule): CpuUsage;
         getCpuUsage(start: CpuUsage, format: true): string;
@@ -769,12 +795,11 @@ declare namespace functions {
         getMemUsage(format: true): string;
         getMemUsage(format?: boolean): number;
         formatCpuMem(start: CpuUsage, all?: boolean): string;
-        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: NumString, max: NumString, options?: CheckSemVerOptions): boolean;
+        getPackageVersion(name: string | [string, string], startDir: string, baseDir?: string): string;
+        getPackageVersion(name: string | [string, string], unstable?: boolean, startDir?: string, baseDir?: string): string;
+        checkSemVer(name: string | [string, string], options: CheckSemVerOptions): boolean;
+        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, options?: Omit<CheckSemVerOptions, "min" | "max" | "equals">): boolean;
         sanitizeCmd(value: string): string;
         sanitizeArgs(value: string, doubleQuote?: boolean): string;
         sanitizeArgs(values: string[], doubleQuote?: boolean): string[];