@e-mc/types 0.9.6 → 0.10.0

package/lib/asset.d.ts

@@ -15,7 +15,7 @@ export interface BinaryAction {
 }
 
 export interface StreamAction {
-    minStreamSize?: NumString;
+    minStreamSize?: number | string;
 }
 
 export interface FileData<T extends ExternalAsset> extends MimeTypeAction {
@@ -74,4 +74,4 @@ export interface ExternalAsset extends FileAsset, BundleAction, BinaryAction, St
     invalid?: boolean;
 }
 
-export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha224" | "sha384" | "sha512";
+export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha224" | "sha384" | "sha512" | "ripemd" | "ripemd-160";

package/lib/cloud.d.ts

@@ -43,7 +43,7 @@ export interface CloudStorageAdmin<T = unknown, U = string, V = unknown, W = unk
 export interface CloudStorageAction<T = unknown, U = string, V = unknown, W = unknown, X = unknown, Y = unknown> extends Partial<LocationUri>, StreamAction {
     active?: boolean;
     overwrite?: boolean;
-    chunkSize?: NumString;
+    chunkSize?: number | string;
     chunkLimit?: number;
     flags?: number;
     admin?: CloudStorageAdmin<T, U, V, W, X, Y>;

package/lib/compat-v4.d.ts

@@ -1,12 +1,13 @@
 import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IModule, ModuleConstructor, WatchConstructor } from './index';
 
+import type { CloneObjectOptions } from '../index.d';
 import type { ExternalAsset } from './asset';
 import type { CacheOptions } from './core';
 import type { QueryResult } from './db';
 import type { ITransformSeries, OutV3, TransformSeriesConstructor } from './document';
 import type { IHttpMemoryCache } from './filemanager';
 import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
-import type { CloneObjectOptions, GetFunctionsOptions } from './module';
+import type { ParseFunctionOptions } from './module';
 import type { LogFailOptions, LogType, LogValue } from './logger';
 import type { HostConfig, OpenOptions, ProxySettings } from './request';
 import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings } from './settings';
@@ -17,6 +18,10 @@ import type { Readable, Writable } from 'stream';
 
 type CpuUsage = NodeJS.CpuUsage;
 
+export interface GetFunctionsOptions extends ParseFunctionOptions {
+    outFailed?: string[];
+}
+
 export interface IModuleLibV4 {
     isString(value: unknown): value is string;
     isObject<T = object>(value: unknown): value is T;
@@ -30,12 +35,12 @@ export interface IModuleLibV4 {
     isFileHTTP(value: string | URL): boolean;
     isFileUNC(value: string | URL): boolean;
     isPathUNC(value: string | URL): boolean;
-    toTimeMs(hrtime: HighResolutionTime, format?: boolean): NumString;
+    toTimeMs(hrtime: HighResolutionTime, format?: boolean): number | string;
     renameExt(value: string, ext: string, when?: string): string;
     existsSafe(value: string, isFile?: boolean): boolean;
     readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<Bufferable>;
     getFunctions<T extends FunctionType>(values: unknown[], absolute?: boolean | GetFunctionsOptions, sync?: boolean, outFailed?: string[]): T[];
-    formatSize(value: NumString, options?: PlainObject): NumString;
+    formatSize(value: number | string, options?: PlainObject): number | string;
     hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
     hasSize(value: string, keepEmpty?: boolean): boolean;
     getSize(value: string, diskUsed?: boolean): number;
@@ -62,7 +67,7 @@ export interface IFileManagerCompatV4<T extends ExternalAsset = ExternalAsset> e
     httpProxy: Null<ProxySettings>;
     acceptEncoding: boolean;
     keepAliveTimeout: number;
-    addDns(hostname: string, address: string, family?: NumString): void;
+    addDns(hostname: string, address: string, family?: number | string): void;
     lookupDns(hostname: string): LookupFunction;
     getHttpProxy(uri: string, localhost?: boolean): Null<ProxySettings>;
     getHttpHeaders(uri: string): Undef<OutgoingHttpHeaders>;
@@ -75,7 +80,7 @@ export interface IFileManagerCompatV4<T extends ExternalAsset = ExternalAsset> e
 }
 
 export interface FileManagerCompatV4Constructor<T extends ExternalAsset = ExternalAsset> extends FileManagerConstructor<T> {
-    fromHttpStatusCode(value: NumString): string;
+    fromHttpStatusCode(value: number | string): string;
     resetHttpHost(version?: HttpProtocolVersion): void;
     defineHttpBuffer(options: HttpMemorySettings): void;
     defineHttpSettings(options: HttpSettings): void;
@@ -105,7 +110,7 @@ export interface WatchCompatV4Constructor<T extends IFileManager<U>, U extends E
     readTLSKey(value: string, cache?: boolean): string;
     readTLSCert(value: string, cache?: boolean): string;
     isCert(value: string): boolean;
-    parseExpires(value: NumString, start?: number): number;
+    parseExpires(value: number | string, start?: number): number;
 }
 
 export interface ITransformSeriesCompatV4<T = AnyObject, U = T> extends ITransformSeries<T, U>, PropertyAction<OutV3, "out"> {}

package/lib/compress.d.ts

@@ -1,25 +1,26 @@
-import type { CompressFormat as ICompressFormat } from './squared';
+import type { CompressFormat as ICompressFormat, CompressLevel as ICompressLevel } from './squared';
 
 import type { LogBaseOptions, LogTime } from './logger';
+import type { ThrowsAction } from './module';
 
 type ResultCallback<T = Null<Buffer | Uint8Array>> = (err: unknown, data?: T, ext?: string) => void;
 type ResultData = Null<Buffer | Uint8Array> | string;
 
-export interface CompressFormat extends ICompressFormat, LogBaseOptions {
+export interface CompressFormat extends ICompressFormat, LogBaseOptions, ReadableOptions {
     filename?: string;
+    mimeType?: string;
     startTime?: LogTime;
     etag?: string;
-    proxyUrl?: string | ((uri: string) => Undef<string>);
     outExt?: string;
     outFile?: string;
 }
 
-export interface Woff {
-    toWoff(this: void, data: BufferLike): Buffer;
-    toSfnt(this: void, data: BufferLike): Buffer;
-}
+export interface CompressLevel extends ICompressLevel, ReadableOptions {}
+
+export interface ReadableOptions extends ThrowsAction {}
 
 export type BufferLike = Buffer | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly number[];
 export type TryFileCompressor = (data: string | Buffer, output: string, config: CompressFormat, callback?: ResultCallback<ResultData>) => Void<Promise<ResultData>>;
 export type TryFileCompressorAsync = (data: string | Buffer, output: string, config: CompressFormat) => Promise<ResultData>;
-export type BufferResult = Null<Buffer | Uint8Array>;
+export type BufferResult = Null<Buffer | Uint8Array>;
+export type PluginCompressor = FunctionArgs<[CompressFormat['options'], string?], FunctionArgs<[Buffer], Promise<Buffer | Uint8Array>>>;

package/lib/core.d.ts

@@ -1,5 +1,3 @@
-/* eslint @typescript-eslint/no-explicit-any: "off" */
-
 import type { DataSource, RequestBase } from './squared';
 
 import type { IExternalConfig, IExternalFunction, IHost, IModule, ModuleConstructor } from './index';
@@ -42,6 +40,7 @@ export interface IClientDb<T extends IHost, U extends ClientModule<ClientDbSetti
     getQueryResult(source: string, credential: unknown, queryString: string, options?: CacheOptions | string, renewCache?: boolean): Undef<QueryResult>;
     setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, sessionKey?: string): QueryResult;
     setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
+    getCacheResult(source: string, credential: unknown, queryString: string, cacheValue: CacheOptions, ignoreCache?: IntBool | FirstOf<number, number>): Undef<QueryResult>;
     applyState(items: ArrayOf<V>, value: number, as?: boolean): void;
     commit(items?: V[]): Promise<boolean>;
     valueOfKey(credential: unknown, name: keyof W, component?: keyof X): unknown;
@@ -62,8 +61,8 @@ export interface ClientDbConstructor<T extends IHost = IHost, U extends ClientMo
     readonly TRANSACTION_ABORT: number;
     readonly TRANSACTION_FAIL: number;
     loadSettings(settings: Pick<Settings, "process" | "memory">, password?: string): boolean;
-    getTimeout(value: Undef<NumString | TimeoutAction>): number;
-    convertTime(value: NumString): number;
+    getTimeout(value: Undef<number | string | TimeoutAction>): number;
+    convertTime(value: number | string): number;
     findResult(source: string, credential: unknown, queryString: string, timeout: number, sessionKey?: string | boolean, renewCache?: boolean): Undef<QueryResult>;
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, options: StoreResultOptions): QueryResult;
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, sessionKey: string, sessionExpires: number): QueryResult;
@@ -131,16 +130,17 @@ export interface PermissionAction {
     permission?: PermittedDirectories;
 }
 
-export interface HostInitConfig extends PlainObject, RequestBase<HostInitLog> {
+export interface HostInitConfig<T extends HostInitLog = HostInitLog> extends PlainObject, RequestBase<T> {
     username?: string;
     ignoreModules?: string[];
 }
 
 export interface HostInitLog {
     enabled?: boolean;
-    level?: NumString;
+    level?: number | string;
     exclude?: ArrayOf<string>;
     useColor?: boolean;
+    silent?: boolean;
     showProgress?: boolean;
 }
 
@@ -158,7 +158,7 @@ export interface StoreResultOptions {
 export interface CacheOptions {
     value?: DbCacheValue;
     renewCache?: boolean;
-    exclusiveOf?: [number, number?, number?];
+    exclusiveOf?: FirstOf<number, number>;
     sessionKey?: string;
 }
 

package/lib/db.d.ts

@@ -56,7 +56,7 @@ export interface ServerAuth<T = number> extends AuthValue, IdentifierAction {
     database?: string;
 }
 
-export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V = unknown> {
+export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V = unknown, W = unknown> {
     client: U;
     lastAccessed: number;
     success: number;
@@ -65,7 +65,7 @@ export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V =
     uuidKey: Null<AuthValue>;
     add(item: T, uuidKey?: string): this;
     has(item: T): boolean;
-    getConnection(): Promise<V>;
+    getConnection(credential?: W): Promise<V>;
     remove(): void;
     detach(force?: boolean): Promise<void>;
     close(): Promise<void>;
@@ -78,16 +78,20 @@ export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V =
     set parent(value: ObjectMap<IDbPool<T>>);
 }
 
-export interface DbPoolConstructor<T extends DbDataSource = DbDataSource, U = unknown, V = unknown> {
-    findKey<W extends IDbPool, X extends DbDataSource>(pools: ObjectMap<W>, uuidKey: unknown, poolKey: Undef<string>, ...items: X[]): Null<W>;
-    validateKey<W extends IDbPool>(pools: ObjectMap<W>, username: string, uuidKey: unknown): [string, Null<W>];
-    checkTimeout<W extends IDbPool>(pools: ObjectMap<W>, value: number, limit?: number): Promise<number>;
-    readonly prototype: IDbPool<T, U, V>;
-    new(pool: U, poolKey: string, uuidKey?: Null<AuthValue>): IDbPool<T, U, V>;
+export interface DbPoolConstructor<T extends DbDataSource = DbDataSource, U = unknown, V = unknown, W = unknown> {
+    CACHE_UNUSED: readonly string[];
+    asString(credential: unknown): string;
+    sanitize(credential: unknown): unknown;
+    removeUUIDKey<X>(credential: X & IdentifierAction): X;
+    findKey<X extends IDbPool, Y extends DbDataSource>(pools: ObjectMap<X>, uuidKey: unknown, poolKey: Undef<string>, ...items: Y[]): Null<X>;
+    validateKey<X extends IDbPool>(pools: ObjectMap<X>, username: string, uuidKey: unknown): [string, Null<X>];
+    checkTimeout<X extends IDbPool>(pools: ObjectMap<X>, value: number, limit?: number): Promise<number>;
+    readonly prototype: IDbPool<T, U, V, W>;
+    new(pool: U, poolKey: string, uuidKey?: Null<AuthValue>): IDbPool<T, U, V, W>;
 }
 
 export interface TimeoutAction {
-    timeout?: NumString;
+    timeout?: number | string;
 }
 
 export type DbSource = "mariadb" | "mongodb" | "mssql" | "mysql" | "oracle" | "postgres" | "redis";

package/lib/document.d.ts

@@ -7,6 +7,7 @@ import type { LogComponent, LogDate } from './logger';
 import type { DocumentTransform } from './settings';
 
 export interface DocumentAsset extends ExternalAsset, StorageAction<CloudStorage> {
+    inlineFilename?: string;
     initialValue?: InitialValue & { inlineFilename?: string };
 }
 
@@ -15,7 +16,7 @@ export interface StartOfSourceMap {
     sourceRoot?: string;
 }
 
-export interface RawSourceMap<T = NumString> extends StartOfSourceMap {
+export interface RawSourceMap<T = number | string> extends StartOfSourceMap {
     version: T;
     sources: string[];
     names: string[];
@@ -88,7 +89,8 @@ export interface ITransformSeries<T = AnyObject, U = T> extends IModule, Transfo
     getMainFile(code?: string, imports?: StringMap): Undef<SourceInput<string>>;
     getSourceFiles(imports?: StringMap): Undef<SourceInput>;
     toBaseConfig(all?: boolean): T;
-    upgrade<V = unknown>(context: V, dirname?: string, name?: string): V;
+    upgrade<V = unknown>(context: V, dirname?: string, pkgname?: string): V;
+    upgradeESM<V = unknown>(context: V, dirname?: string, pkgname?: string): Promise<V>;
     set code(value);
     get code(): string;
     get out(): IOut;
@@ -174,8 +176,8 @@ export interface LintMessage {
 export interface GenerateLintTableOptions extends Partial<LocationUri> {
     leadingText?: string;
     trailingText?: string;
-    errorCount?: number;
-    warningCount?: number;
+    errorCount?: number | TupleOf<number>;
+    warningCount?: number | TupleOf<number>;
     fatalErrorCount?: number;
     timeStamp?: LogDate;
     ruleWidth?: number;

package/lib/filemanager.d.ts

@@ -10,13 +10,13 @@ import type { RequestInit } from './request';
 import type { FETCH_TYPE } from '../index.d';
 
 export const enum FINALIZE_STATE {
-    READY = 0,
-    COMMIT = 1,
-    END = 2,
-    RESTART = 3,
-    QUEUED = 4,
-    RESTARTED = 5,
-    ABORTED = 6
+    READY,
+    COMMIT,
+    END,
+    RESTART,
+    QUEUED,
+    RESTARTED,
+    ABORTED
 }
 
 export const enum INCREMENTAL {
@@ -26,8 +26,8 @@ export const enum INCREMENTAL {
     EXISTS = 'exists'
 }
 
-export interface RequestData<T extends ExternalAsset = ExternalAsset> extends IRequestData<T>, RequestInit {
-    timeout?: ObjectMap<NumString>;
+export interface RequestData<T extends ExternalAsset = ExternalAsset, U extends HostInitLog = HostInitLog> extends IRequestData<T, U>, RequestInit {
+    timeout?: ObjectMap<number | string>;
 }
 
 export interface InstallData<T extends IModule = IModule, U extends ModuleConstructor = ModuleConstructor> {
@@ -99,6 +99,7 @@ export interface DeleteFileAddendum {
 export interface HostInitLog extends IHostInitLog {
     useNumeric: boolean;
     showSize?: boolean;
+    showDiff?: string[];
 }
 
 export interface FindAssetOptions<T extends ExternalAsset = ExternalAsset> {

package/lib/http.d.ts

@@ -93,10 +93,11 @@ export interface SecureConfig<T = string, U = T> {
     key?: U;
     cert?: T;
     passphrase?: U;
+    ciphers?: string;
     version?: SecureVersion;
 }
 
-export interface ServerPort<T = NumString> {
+export interface ServerPort<T = number | string> {
     port?: T;
 }
 

package/lib/index.d.ts

@@ -1,13 +1,11 @@
-/* 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 { 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,7 +13,7 @@ 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, MoveFileOptions, NormalizeFlags, ParseFunctionOptions, PermissionOptions, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, WriteFileOptions } from './module';
+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 { RequestData, Settings } from './node';
 import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HeadersOnCallback, HostConfig, OpenOptions, PostOptions, ProxySettings, 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';
@@ -23,7 +21,7 @@ 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 { BinaryLike, BinaryToTextEncoding, HashOptions } from 'crypto';
 import type { NoParamCallback, WriteStream } from 'fs';
 import type { ClientRequest, OutgoingHttpHeaders } from 'http';
 import type { LookupFunction } from 'net';
@@ -42,6 +40,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 +58,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;
+        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,10 +74,12 @@ 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<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>;
     }
@@ -198,10 +198,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<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>;
@@ -264,7 +264,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?: 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>;
     }
@@ -295,14 +295,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: NumString): void;
+        setTimeout(value: number | string): 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<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>;
@@ -312,7 +312,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?: 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;
@@ -344,13 +344,13 @@ declare namespace functions {
         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;
         fromURL(url: URL, value: string): string;
-        fromStatusCode(value: NumString): string;
+        fromStatusCode(value: number | string): string;
         defineHttpAgent(options: HttpAgentSettings): void;
         defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
         getAria2Path(): string;
@@ -362,13 +362,13 @@ declare namespace functions {
         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>>;
+        Compress: Null<ICompress>;
         readonly documentAssets: T[];
         readonly taskAssets: (T & Required<TaskAction>)[];
         readonly dataSourceItems: DataSource[];
@@ -392,8 +392,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?: NumString, port?: NumString, securePort?: NumString, extensions?: unknown[]): Undef<WatchInstance<T>>;
-        install(name: "compress", module?: CompressModule): Undef<ICompress<CompressModule>>;
+        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: string, ...args: unknown[]): Undef<IModule>;
         using(...items: FirstOf<T>): this;
         contains(item: T, condition?: FunctionArgs<[T], boolean>): boolean;
@@ -410,6 +410,7 @@ 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;
@@ -441,7 +442,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: 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;
@@ -450,11 +451,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: (T & Required<TaskAction>)[]): Promise<void>;
+        finalizeCloud(): Promise<void>;
+        finalizeChecksum(): Promise<void>;
+        finalizeCleanup(): Promise<void>;
         finalize(): Promise<void>;
         close(): void;
         reset(): boolean;
@@ -518,7 +520,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<NumString>): void;
+        setTimeout(options: ObjectMap<number | string>): void;
         defineHttpCache(options: HttpMemorySettings, disk?: boolean): void;
         defineHttpConnect(options: HttpConnectSettings): void;
         readonly prototype: IFileManager<T>;
@@ -538,8 +540,8 @@ declare namespace functions {
         willLog(name: string): boolean;
         ignoreLog(values: boolean | ArrayOf<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;
@@ -571,6 +573,7 @@ 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;
@@ -579,10 +582,9 @@ 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;
@@ -590,7 +592,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: NumString } ? Promise<string> : string : U extends { minStreamSize: NumString } ? Promise<Buffer> : 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 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>;
@@ -665,8 +667,10 @@ 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: NumString);
+        set logLevel(value: number | string);
         get logLevel(): number;
         get statusType(): STATUS_TYPE;
         set tempDir(value);
@@ -714,8 +718,10 @@ 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;
@@ -723,9 +729,9 @@ declare namespace functions {
         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>>;
         asString(value: unknown, cacheKey?: boolean | "throws"): string;
-        asHash(data: BinaryLike, algorithm: string, minLength?: number): string;
-        asHash(data: BinaryLike, algorithm?: string, options?: AsHashOptions): 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;
@@ -741,7 +747,7 @@ 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;
@@ -752,11 +758,11 @@ declare namespace functions {
         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<U extends ReadBufferOptions>(value: string | URL, options: U): U extends { minStreamSize: number | string } ? Promise<Null<Buffer>> : Null<Buffer>;
         readBuffer(value: string | URL, cache?: boolean | ReadBufferOptions): Null<Buffer>;
-        resolveMime(data: string | Buffer | Uint8Array | ArrayBuffer): Promise<Undef<FileTypeResult>>;
+        resolveMime(data: FileTypeFormat): Promise<Undef<FileTypeResult>>;
         lookupMime(value: string, extension?: boolean): string;
         initCpuUsage(instance?: IModule): CpuUsage;
         getCpuUsage(start: CpuUsage, format: true): string;
@@ -767,8 +773,8 @@ 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;
-        checkSemVer(name: string | TupleOf<string>, min: NumString, max: NumString, options?: CheckSemVerOptions): boolean;
+        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?: CheckSemVerOptions): boolean;
         sanitizeCmd(value: string): string;
         sanitizeArgs(value: string, doubleQuote?: boolean): string;
         sanitizeArgs(values: string[], doubleQuote?: boolean): string[];