@e-mc/types 0.8.7 → 0.9.0

package/lib/index.d.ts

@@ -6,30 +6,30 @@
 import type { CompressLevel, DataSource, DbDataSource, IncrementalMatch, LogStatus, TaskAction, ViewEngine } from './squared';
 
 import type { ExternalAsset, FileCommand, FileData, IFileThread, OutputFinalize } from './asset';
-import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload } from './cloud';
-import type { BufferResult, CompressFormat, TryFileCompressor, TryFileResult, TryImageResult } from './compress';
+import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload, UploadAssetOptions } from './cloud';
+import type { BufferResult, CompressFormat, TryFileCompressor } from './compress';
 import type { ClientDbConstructor, HostInitConfig, IAbortComponent, IClient, IClientDb, IPermission, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, ThreadCountStat } from './core';
-import type { BatchQueryResult, DB_TYPE, ExecuteBatchQueryOptions, ExecuteQueryOptions, HandleFailOptions, PoolConfig, ProcessRowsOptions, QueryResult, SQL_COMMAND } from './db';
+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';
-import type { AssetContentOptions, ChecksumOptions, DeleteFileAddendum, FileOutput, FinalizeResult, FindAssetOptions, IHttpDiskCache, IHttpMemoryCache, InstallData, PostFinalizeCallback, ReplaceOptions } from './filemanager';
+import type { AssetContentOptions, ChecksumOptions, DeleteFileAddendum, FileOutput, FinalizeResult, FindAssetOptions, IHttpDiskCache, IHttpMemoryCache, ImageMimeMap, InstallData, PostFinalizeCallback, ReplaceOptions } from './filemanager';
 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, LogTime, LogType, LogValue, STATUS_TYPE, StatusType } from './logger';
+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 { 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, CloudModule, CloudServiceOptions, CompressModule, CompressSettings, DbCoerceSettings, DbModule, DbSourceOptions, DnsLookupSettings, DocumentComponent, DocumentComponentOption, DocumentModule, HttpConnectSettings, HttpMemorySettings, ImageModule, RequestModule, RequestSettings, TaskModule, WatchModule } from './settings';
+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 { NoParamCallback, WriteStream } from 'fs';
 import type { SpawnOptions } from 'child_process';
-import type { BrotliCompress, Gzip } from 'zlib';
-import type { Readable, Writable } from 'stream';
+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 { ClientRequest, OutgoingHttpHeaders } from 'http';
-import type { BinaryLike } from 'crypto';
+import type { BrotliCompress, Gzip } from 'zlib';
 
 import type * as EventEmitter from 'events';
 
@@ -37,7 +37,7 @@ import type * as EventEmitter from 'events';
 import type * as ws from 'ws';
 import type { FileTypeResult } from 'file-type';
 
-type BufferView = BufferContent | NodeJS.ArrayBufferView;
+type BufferView = Bufferable | NodeJS.ArrayBufferView;
 type CpuUsage = NodeJS.CpuUsage;
 
 declare namespace functions {
@@ -48,13 +48,13 @@ declare namespace functions {
         instance?: U;
     }
 
-    interface IExternalConfig<T = unknown, U = unknown> {
+    interface IExternalConfig<T extends HandlerSettings, U extends PlainObject = PlainObject> {
         module: T;
         init(...args: unknown[]): this;
         get settings(): U;
     }
 
-    interface IExternalFunction<T = FunctionType> {
+    interface IExternalFunction<T extends FunctionType<any, any>> {
         set extensions(values: unknown[]);
         get extensions(): T[];
     }
@@ -70,10 +70,12 @@ declare namespace functions {
         createBrotliCompress(file: string | Buffer, options?: CompressLevel): BrotliCompress;
         createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
         createWriteStreamAsBrotli(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
-        tryFile(file: string | Buffer, config: CompressFormat, callback?: TryFileResult): Promise<BufferResult>;
-        tryFile(file: string | Buffer, output: string, config: CompressFormat, callback?: TryFileResult): Promise<BufferResult>;
-        tryImage(file: string, config: CompressFormat, callback?: TryImageResult): Promise<BufferResult>;
-        tryImage(file: string | Buffer, output: string, config: CompressFormat, callback?: TryImageResult): Promise<BufferResult>;
+        writeGzip(file: string | Buffer, output: string, options?: CompressLevel): Promise<void>;
+        writeBrotli(file: string | Buffer, output: string, options?: CompressLevel): Promise<void>;
+        tryFile(file: string | Buffer, options: CompressFormat): Promise<BufferResult>;
+        tryFile(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
+        tryImage(file: string, options: CompressFormat): Promise<BufferResult>;
+        tryImage(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
     }
 
     interface CompressConstructor<T extends CompressModule<U> = CompressModule<any>, U extends CompressSettings = CompressSettings> extends ModuleConstructor {
@@ -104,20 +106,18 @@ declare namespace functions {
 
     interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ModuleConstructor {
         readonly REGEXP_SIZERANGE: RegExp;
-        transform(file: string, command: string, options?: TransformOptions): Promise<Null<Buffer> | string>;
+        transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<U extends { tempFile: true } ? string : Null<Buffer>>;
         clamp(value: unknown, min?: number, max?: number): number;
         isBinary(mime: unknown): mime is string;
         toABGR(buffer: Uint8Array | Buffer): Buffer;
-        /* @deprecated - IImage.using */
-        using?<V extends ExternalAsset>(this: T, instance: IImage<T, U>, data: IFileThread<V>, command: string): Promise<unknown>;
         readonly prototype: IImage<T, U>;
-        new(module?: U): IImage<T, U>;
+        new(module?: U, ...args: unknown[]): IImage<T, U>;
     }
 
     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<Undef<SpawnResult>>[];
+        map?(tasks: Command[]): Promise<Void<SpawnResult>>[];
         series?(tasks: Command[]): Promise<unknown>;
         parallel?(tasks: Command[]): Promise<unknown>;
         spawn?(task: PlainObject, callback: (result?: SpawnResult) => void): void;
@@ -126,8 +126,6 @@ declare namespace functions {
 
     interface TaskConstructor<T extends IHost = IHost, U extends TaskModule = TaskModule> extends ModuleConstructor {
         finalize<V extends ExternalAsset>(this: T, instance: ITask<T, U>, assets: V[]): Promise<unknown>;
-        /* @deprecated - ITask.using */
-        using?<V extends ExternalAsset>(this: T, instance: ITask<T, U>, assets: V[], preceding?: boolean): Promise<unknown>;
         readonly prototype: ITask<T, U>;
         new(module?: U, ...args: unknown[]): ITask<T, U>;
     }
@@ -137,8 +135,10 @@ declare namespace functions {
         getCredential<Y = PlainObject>(item: V): Undef<Y>;
         hasSource(source: string, ...type: number[]): boolean;
         applyCommand(...items: V[]): void;
+        executeQuery(item: V, callback: ErrorQueryCallback): Promise<QueryResult>;
         executeQuery(item: V, sessionKey: string): Promise<QueryResult>;
         executeQuery(item: V, options?: ExecuteQueryOptions | string): Promise<QueryResult>;
+        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>;
@@ -162,16 +162,17 @@ declare namespace functions {
         new(module?: U, database?: V[], ...args: unknown[]): IDb<T, U, V>;
     }
 
-    interface ICloud<T extends IHost = IHost, U extends CloudModule = CloudModule, V extends CloudDatabase = CloudDatabase, W extends CloudServiceOptions = CloudServiceOptions, X extends DbCoerceSettings = DbCoerceSettings> extends IClientDb<T, U, V, W, X> {
+    interface ICloud<T extends IHost = IHost, U extends CloudModule = CloudModule, V extends CloudDatabase = CloudDatabase, W extends CloudServiceOptions = CloudServiceOptions, X extends DbCoerceSettings = DbCoerceSettings & CloudAuthSettings> extends IClientDb<T, U, V, W, X> {
         readonly uploaded: string[];
         readonly downloaded: string[];
         createBucket(service: string, credential: unknown, bucket: string, acl?: unknown, options?: unknown): Promise<boolean>;
         createBucket(service: string, credential: unknown, bucket: string, publicRead?: boolean): Promise<boolean>;
         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<BufferContent>) => Void<Promise<Undef<string>>>): Promise<BufferContent>;
+        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>;
         hasStorage(action: CloudFunctions, storage: CloudStorage): CloudStorageUpload | false;
         getDatabaseRows(item: V, ignoreErrors: boolean, sessionKey?: string): Promise<QueryResult>;
@@ -182,7 +183,8 @@ declare namespace functions {
         getCredential(item: CloudService, unused?: boolean): PlainObject;
         getSettings(service: string): Undef<AnyObject>;
         settingsOf(service: string, name: "cache"): unknown;
-        settingsOf(service: string, name: "coerce", component: keyof X): 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;
@@ -197,8 +199,9 @@ declare namespace functions {
         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, ignoreProcess?: boolean): Promise<unknown>[];
+        uploadAsset<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, contentType?: string | boolean | UploadAssetOptions, ignoreProcess?: boolean): Promise<unknown>[];
         sanitizeAssets<W extends ExternalAsset>(assets: W[]): W[];
         readonly prototype: ICloud<T, U, V>;
         new(module?: U, database?: CloudDatabase[], ...args: unknown[]): ICloud<T, U, V>;
@@ -212,8 +215,9 @@ declare namespace functions {
         customize(options?: CustomizeDocument): void;
         findConfig(data: object, name: string, type?: string): PluginConfig;
         loadConfig(data: object, name: string): Optional<ConfigOrTransformer>;
-        asSourceFile(value: string, options?: AsSourceFileOptions | boolean): unknown;
-        findVersion(name: StringOfArray, fallback?: string): string;
+        asSourceFile(value: string, cache: boolean): unknown;
+        asSourceFile(value: string, options?: AsSourceFileOptions): unknown;
+        findVersion(name: ArrayOf<string>, fallback?: string): string;
         findSourceScope(uri: string, imports: AnyObject): StringMap[];
         findSourceRoot(uri: string, imports?: StringMap): Undef<string>;
         resolveDir(name: string, ...paths: string[]): Undef<string>;
@@ -224,8 +228,9 @@ declare namespace functions {
         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: StringOfArray, options?: TransformOutput & TransformAction): Promise<Void<TransformResult>>;
-        abort(name?: keyof W | Error, reason?: unknown): void;
+        transform(type: string, code: string, format: ArrayOf<string>, options?: TransformOutput & TransformAction): Promise<Void<TransformResult>>;
+        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;
@@ -253,10 +258,9 @@ declare namespace functions {
         createSourceMap(code: string, remove: boolean): SourceMap;
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
         writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): Undef<string>;
-        updateGradle(source: string, namespaces: string[], value: string, options?: UpdateGradleOptions | boolean): string;
+        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[];
-        /* @deprecated - IDocument.using */
-        using?(this: T, instance: IDocument<T, U, V, W, X, Y>, file: U): Promise<unknown>;
         cleanup?(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
         sanitizeAssets?(assets: U[], exclusions?: U[]): U[];
         readonly prototype: IDocument<T, U, V, W, X, Y>;
@@ -265,6 +269,7 @@ 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>>;
         configureServer(options: SecureOptions): boolean;
@@ -273,7 +278,7 @@ declare namespace functions {
         setSSLCert(value: string): boolean;
         hasSecureProtocol(): boolean;
         whenModified?(assets: U[], postFinalize: PostFinalizeCallback): IFileManager<U>;
-        whenModified?(assets: U[], sanitize?: boolean | PostFinalizeCallback, postFinalize?: PostFinalizeCallback): IFileManager<U>;
+        whenModified?(assets: U[], sanitize?: boolean, postFinalize?: PostFinalizeCallback): IFileManager<U>;
         set assets(value: U[]);
         get assets(): U[];
         set interval(value);
@@ -292,7 +297,6 @@ declare namespace functions {
         checkTimeout(client: ws): boolean;
         readonly prototype: IWatch<T, U, V, W>;
         new(module?: V): IWatch<T, U, V, W>;
-        /* @deprecated */
         new(interval?: number, port?: number, securePort?: number, extensions?: unknown[]): IWatch<T, U, V, W>;
     }
 
@@ -311,8 +315,8 @@ declare namespace functions {
         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: StringOfArray, callback: HeadersOnCallback): void;
-        headersOn(name: StringOfArray, globUrl: string, callback: HeadersOnCallback): void;
+        headersOn(name: ArrayOf<string>, callback: HeadersOnCallback): void;
+        headersOn(name: ArrayOf<string>, globUrl: string, callback: HeadersOnCallback): void;
         headersOf(uri: string): Undef<OutgoingHttpHeaders>;
         aria2c(uri: string | URL, pathname: string): Promise<string[]>;
         aria2c(uri: string | URL, options?: Aria2Options): Promise<string[]>;
@@ -353,14 +357,13 @@ declare namespace functions {
     }
 
     interface IFileManager<T extends ExternalAsset = ExternalAsset> extends IHost, Set<string> {
-        finalizeState: number;
         processTimeout: number;
         cacheToDisk: IHttpDiskCache<T>;
         cacheToMemory: IHttpMemoryCache<T>;
         Request: IRequest<RequestModule>;
         Document: InstallData<IDocument<IFileManager<T>, T>, DocumentConstructor<IFileManager<T>, T>>[];
         Task: InstallData<ITask, TaskConstructor>[];
-        Image: Null<Map<string, InstallData<IImage, ImageConstructor>>>;
+        Image: Null<ImageMimeMap>;
         Cloud: Null<ICloud>;
         Watch: Null<WatchInstance<T>>;
         Compress: Null<ICompress<CompressModule>>;
@@ -377,11 +380,14 @@ declare namespace functions {
         readonly fetchedAssets: T[];
         readonly copiedAssets: T[];
         readonly emptyDir: Set<string>;
-        install(name: "document", target: DocumentConstructor<IFileManager<T>, T>, module?: DocumentModule): Undef<IDocument<IFileManager<T>, T>>;
-        install(name: "task", target: TaskConstructor, module?: TaskModule): Undef<ITask>;
-        install(name: "cloud", handler: string, module?: CloudModule): Undef<ICloud>;
+        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: "db", module?: DbModule): Undef<IDb>;
+        install(name: "image", handler: string, module?: ImageModule, ...args: unknown[]): Undef<IImage>;
+        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>>;
@@ -392,14 +398,14 @@ declare namespace functions {
         removeCwd(value: unknown): string;
         findAsset(value: string | URL, instance?: IModule | FindAssetOptions<T>): Undef<T>;
         removeAsset(file: T): boolean;
-        replace(file: T, replaceWith: string, options: ReplaceOptions): boolean;
-        replace(file: T, replaceWith: string, mimeType?: string | ReplaceOptions): boolean;
+        replace(file: T, replaceWith: string, mimeType: Undef<string>): 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<StringOfArray>): boolean;
+        hasDocument(instance: IModule, document: Undef<ArrayOf<string>>): boolean;
         getDocumentAssets(instance: IModule, condition?: FunctionArgs<[T], boolean>): T[];
         getDataSourceItems(instance: IModule, condition?: FunctionArgs<[DataSource], boolean>): DataSource[];
         setLocalUri(file: T, replace?: boolean): FileOutput;
@@ -411,25 +417,29 @@ declare namespace functions {
         removeProcessTimeout(instance: IModule, file: T): void;
         getProcessTimeout(handler: InstallData): number;
         clearProcessTimeout(): void;
-        addDownload(value: number | BufferContent, encoding: BufferEncoding): number;
-        addDownload(value: number | BufferContent, type?: number, encoding?: BufferEncoding): number;
+        scheduleTask(url: string | URL, data: unknown, priority: number): Promise<unknown>;
+        scheduleTask(url: string | URL, data: unknown, thenCallback?: FunctionType, catchCallback?: FunctionType, priority?: number): Promise<unknown>;
+        setTaskLimit(value: number): void;
+        addDownload(value: number | Bufferable, encoding: BufferEncoding): number;
+        addDownload(value: number | Bufferable, type?: number | BufferEncoding, encoding?: BufferEncoding): number;
         getDownload(type?: number): TupleOf<number>;
-        transformAsset(data: IFileThread<T>, parent?: T): Promise<void>;
+        transformAsset(data: IFileThread<T>, parent?: T, override?: boolean): Promise<boolean>;
         addCopy(data: FileCommand<T>, saveAs?: string, replace?: boolean): Undef<string>;
         findMime(file: T, rename?: boolean): Promise<string>;
         getUTF8String(file: T, uri?: string): string;
-        getBuffer<U>(file: T, minStreamSize?: U): U extends number ? Promise<Buffer> : Null<Buffer>;
+        getBuffer<U>(file: T, minStreamSize?: U): U extends number ? Promise<Null<Buffer>> : Null<Buffer>;
         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: StringOfArray, output: OutputFinalize<T>): boolean;
+        writeImage(document: ArrayOf<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>>;
         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 | string): Promise<string[]>;
+        fetchFiles(uri: string | URL, options?: Aria2Options): Promise<string[]>;
+        updateProgress(name: "request", id: NumString, receivedBytes: number, totalBytes: number, dataTime?: HighResolutionTime): void;
         start(emptyDir?: boolean): Promise<FinalizeResult>;
         processAssets(emptyDir?: boolean, using?: T[]): void;
         deleteFile<U extends Promise<void>>(src: string, promises: boolean): U;
@@ -455,6 +465,8 @@ declare namespace functions {
         get delayed(): number;
         set cleared(value);
         get cleared(): boolean;
+        set finalizeState(value);
+        get finalizeState(): number;
 
         /* Set */
         add(value: string, parent?: T, type?: number): this;
@@ -465,7 +477,7 @@ declare namespace functions {
         on(event: "end", listener: PostFinalizeCallback): this;
         on(event: "exec", listener: (command: ExecCommand, options?: SpawnOptions) => void): this;
         on(event: "error", listener: (err: Error) => void): this;
-        on(event: "file:read", listener: (src: string, data: BufferContent, options?: ReadFileOptions) => void): this;
+        on(event: "file:read", listener: (src: string, data: Bufferable, options?: ReadFileOptions) => void): this;
         on(event: "file:write", listener: (src: string, options?: WriteFileOptions) => void): this;
         on(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         on(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
@@ -475,7 +487,7 @@ declare namespace functions {
         once(event: "end", listener: PostFinalizeCallback): this;
         once(event: "exec", listener: (command: ExecCommand, options?: SpawnOptions) => void): this;
         once(event: "error", listener: (err: Error) => void): this;
-        once(event: "file:read", listener: (src: string, data: BufferContent, options?: ReadFileOptions) => void): this;
+        once(event: "file:read", listener: (src: string, data: Bufferable, options?: ReadFileOptions) => void): this;
         once(event: "file:write", listener: (src: string, options?: WriteFileOptions) => void): this;
         once(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         once(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
@@ -485,7 +497,7 @@ declare namespace functions {
         emit(event: "end", result: FinalizeResult): boolean;
         emit(event: "exec", command: ExecCommand, options?: SpawnOptions): boolean;
         emit(event: "error", err: Error): boolean;
-        emit(event: "file:read", src: string, data: BufferContent, options?: ReadFileOptions): boolean;
+        emit(event: "file:read", src: string, data: Bufferable, options?: ReadFileOptions): boolean;
         emit(event: "file:write", src: string, options?: WriteFileOptions): boolean;
         emit(event: "file:delete", src: string, options?: DeleteFileOptions): boolean;
         emit(event: "file:copy", dest: string, options?: CopyFileOptions): boolean;
@@ -495,22 +507,21 @@ declare namespace functions {
     }
 
     interface FileManagerConstructor<T extends ExternalAsset> extends HostConstructor {
+        purgeMemory(percent?: number, limit?: number | boolean, parent?: number | boolean): Promise<number>;
         loadSettings(settings: Settings, password?: string): boolean;
         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: Undef<string>, options?: ChecksumOptions): Promise<Null<string[]>>;
+        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[]]>>;
-        verifyChecksum(root: string, from: Undef<string>, options?: ChecksumOptions): Promise<Null<[string[], string[]]>>;
-        verifyChecksum(root: string, from?: string | ChecksumOptions, options?: ChecksumOptions): Promise<Null<[string[], string[]]>>;
+        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;
         defineHttpCache(options: HttpMemorySettings, disk?: boolean): void;
         defineHttpConnect(options: HttpConnectSettings): void;
         readonly prototype: IFileManager<T>;
         new(baseDirectory: string, config: RequestData<T>, postFinalize?: PostFinalizeCallback): IFileManager<T>;
-        new(baseDirectory: string, config: RequestData<T>, permission?: IPermission, postFinalize?: PostFinalizeCallback): IFileManager<T>;
+        new(baseDirectory: string, config: RequestData<T>, permission?: Null<IPermission>, postFinalize?: PostFinalizeCallback): IFileManager<T>;
     }
 
     interface IHost extends IModule {
@@ -523,23 +534,29 @@ declare namespace functions {
         find(name: string): Undef<IModule>;
         findAll(name: string): IModule[];
         willLog(name: string): boolean;
-        ignoreLog(values: boolean | StringOfArray): void;
+        ignoreLog(values: boolean | ArrayOf<string>): void;
         collectLog(level?: boolean): LogStatus<StatusType>[];
+        pauseLog(): void;
+        resumeLog(): void;
+        hasLog(type: string): boolean;
+        delayMessage(...args: unknown[]): void;
         willAbort(value: string | IModule): boolean;
         loadModule(name: string, ...args: any[]): Null<IModule>;
         retain(process: IModule): void;
         release(process: IModule, log?: boolean): boolean;
         restart(...args: unknown[]): void;
         joinQueue(options?: JoinQueueOptions): boolean;
+        updateProgress(name: string, ...args: unknown[]): void;
         resumeThread?(options: ResumeThreadOptions): void;
         set host(value);
         get host(): null;
         get config(): Readonly<HostInitConfig>;
-        get errorCount(): number;
         get username(): string;
         set done(value);
         get done(): boolean;
         get queued(): boolean;
+        get logState(): LogState;
+        get errorCount(): number;
     }
 
     interface HostConstructor extends ModuleConstructor {
@@ -548,7 +565,7 @@ 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> | boolean): number;
+        kill(username: string, iv: BinaryLike, pid: ArrayOf<number>): number;
         getThreadCount(full: true): ThreadCountStat;
         getThreadCount(username: string, iv?: BinaryLike): ThreadCountStat;
         getThreadCount(username?: string | boolean, iv?: BinaryLike): number;
@@ -563,63 +580,66 @@ declare namespace functions {
         supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
         supports(name: string, value?: boolean): boolean;
         getTempDir(options: GetTempDirOptions): string;
-        getTempDir(uuidDir: boolean, createDir?: boolean): string;
-        getTempDir(pathname: string, createDir?: boolean): string;
-        getTempDir(uuidDir: boolean, filename: string, createDir?: boolean): 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, options?: PermissionOptions): boolean;
-        canWrite(uri: string, options?: PermissionOptions): boolean;
-        readFile(src: string): Undef<Buffer>;
-        readFile<U extends ReadFileOptions>(src: string, 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, promises: true): Promise<Undef<U>>;
-        readFile<U extends BufferContent, V extends ReadFileOptions>(src: string, options: V, promises: true): Promise<Undef<V extends { encoding: string } ? string : U>>;
-        readFile<U extends ReadFileCallback>(src: string, callback: U): Undef<U extends ReadFileCallback<infer W> ? W : BufferContent>;
-        readFile<U extends ReadFileCallback, V extends ReadFileOptions>(src: string, options: V, callback: U): Undef<V extends { encoding: string } ? string : U extends ReadFileCallback<infer W> ? W : BufferContent>;
-        writeFile<U extends boolean>(src: string, data: BufferView, options?: WriteFileOptions): U;
-        writeFile<U extends Promise<boolean>>(src: string, data: BufferView, promises: true): U;
-        writeFile<U extends Promise<boolean>>(src: string, data: BufferView, options: WriteFileOptions, promises: true): U;
-        writeFile<U extends NoParamCallback>(src: string, data: BufferView, callback: U): void;
-        writeFile<U extends NoParamCallback>(src: string, data: BufferView, options: WriteFileOptions, callback: U): void;
-        deleteFile<U extends boolean>(src: string, options?: DeleteFileOptions): U;
-        deleteFile<U extends Promise<boolean>>(src: string, promises: true): U;
-        deleteFile<U extends Promise<boolean>>(src: string, options: DeleteFileOptions, promises: true): U;
-        deleteFile<U extends NoParamCallback>(src: string, callback: U): void;
-        deleteFile<U extends NoParamCallback>(src: string, options: DeleteFileOptions, callback: U): void;
-        copyFile<U extends boolean>(src: string, dest: string, options?: CopyFileOptions): U;
-        copyFile<U extends Promise<boolean>>(src: string, dest: string, promises: true): U;
-        copyFile<U extends Promise<boolean>>(src: string, dest: string, options: CopyFileOptions, promises: true): U;
-        copyFile<U extends NoParamCallback>(src: string, dest: string, callback: U): void;
-        copyFile<U extends NoParamCallback>(src: string, dest: string, options: CopyFileOptions, callback: U): void;
-        moveFile<U extends boolean>(src: string, dest: string, options?: MoveFileOptions): U;
-        moveFile<U extends Promise<boolean>>(src: string, dest: string, promises: true): U;
-        moveFile<U extends Promise<boolean>>(src: string, dest: string, options: MoveFileOptions, promises: true): U;
-        moveFile<U extends NoParamCallback>(src: string, dest: string, callback: U): void;
-        moveFile<U extends NoParamCallback>(src: string, dest: string, options: MoveFileOptions, callback: U): void;
-        createDir<U extends boolean>(src: string, options?: CreateDirOptions): U;
-        createDir<U extends Promise<boolean>>(src: string, promises: true): U;
-        createDir<U extends Promise<boolean>>(src: string, options: CreateDirOptions, promises: true): U;
-        createDir<U extends NoParamCallback>(src: string, callback: U): void;
-        createDir<U extends NoParamCallback>(src: string, options: CreateDirOptions, callback: U): void;
-        removeDir<U extends boolean>(src: string, options?: RemoveDirOptions): U;
-        removeDir<U extends Promise<boolean>>(src: string, promises: true): U;
-        removeDir<U extends Promise<boolean>>(src: string, options: RemoveDirOptions, promises: true): U;
-        removeDir<U extends NoParamCallback>(src: string, callback: U): void;
-        removeDir<U extends NoParamCallback>(src: string, options: RemoveDirOptions, callback: U): void;
-        allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseFulfilledResult<U>[]>;
+        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>;
+        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;
+        writeFile<U extends NoParamCallback>(src: string | URL, data: BufferView, callback: U): void;
+        writeFile<U extends NoParamCallback>(src: string | URL, data: BufferView, options: WriteFileOptions, callback: U): void;
+        deleteFile<U extends boolean>(src: string | URL, options?: DeleteFileOptions): U;
+        deleteFile<U extends Promise<boolean>>(src: string | URL, promises: true): U;
+        deleteFile<U extends Promise<boolean>>(src: string | URL, options: DeleteFileOptions, promises: true): U;
+        deleteFile<U extends NoParamCallback>(src: string | URL, callback: U): void;
+        deleteFile<U extends NoParamCallback>(src: string | URL, options: DeleteFileOptions, callback: U): void;
+        copyFile<U extends boolean>(src: string | URL, dest: string | URL, options?: CopyFileOptions): U;
+        copyFile<U extends Promise<boolean>>(src: string | URL, dest: string | URL, promises: true): U;
+        copyFile<U extends Promise<boolean>>(src: string | URL, dest: string | URL, options: CopyFileOptions, promises: true): U;
+        copyFile<U extends NoParamCallback>(src: string | URL, dest: string | URL, callback: U): void;
+        copyFile<U extends NoParamCallback>(src: string | URL, dest: string | URL, options: CopyFileOptions, callback: U): void;
+        moveFile<U extends boolean>(src: string | URL, dest: string | URL, options?: MoveFileOptions): U;
+        moveFile<U extends Promise<boolean>>(src: string | URL, dest: string | URL, promises: true): U;
+        moveFile<U extends Promise<boolean>>(src: string | URL, dest: string | URL, options: MoveFileOptions, promises: true): U;
+        moveFile<U extends NoParamCallback>(src: string | URL, dest: string | URL, callback: U): void;
+        moveFile<U extends NoParamCallback>(src: string | URL, dest: string | URL, options: MoveFileOptions, callback: U): void;
+        createDir<U extends boolean>(src: string | URL, options?: CreateDirOptions): U;
+        createDir<U extends Promise<boolean>>(src: string | URL, promises: true): U;
+        createDir<U extends Promise<boolean>>(src: string | URL, options: CreateDirOptions, promises: true): U;
+        createDir<U extends NoParamCallback>(src: string | URL, callback: U): void;
+        createDir<U extends NoParamCallback>(src: string | URL, options: CreateDirOptions, callback: U): void;
+        removeDir<U extends boolean>(src: string | URL, options?: RemoveDirOptions): U;
+        removeDir<U extends Promise<boolean>>(src: string | URL, promises: true): U;
+        removeDir<U extends Promise<boolean>>(src: string | URL, options: RemoveDirOptions, promises: true): U;
+        removeDir<U extends NoParamCallback>(src: string | URL, callback: U): void;
+        removeDir<U extends NoParamCallback>(src: string | URL, options: RemoveDirOptions, callback: U): void;
+        allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, type?: LogType): Promise<PromiseFulfilledResult<U>[]>;
+        allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions): Promise<PromiseFulfilledResult<U>[]>;
         formatMessage(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions): void;
         formatFail(type: LogType, title: string, value: LogValue, message?: unknown, options?: LogFailOptions): void;
-        writeFail(value: LogValue, message?: unknown, options?: LogFailOptions | LogType): void;
+        writeFail(value: LogValue, message?: unknown, type?: LogType): void;
+        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>, options?: LogFailOptions | LogType): boolean;
+        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>;
         writeLog(component: LogComponent, queue?: boolean): void;
-        writeLog(type: StatusType, value: unknown, options?: LogOptions): void;
+        writeLog(type: StatusType, value: unknown, options: LogOptions): void;
         writeLog(type: StatusType, value: unknown, timeStamp?: LogDate, duration?: number): void;
         addLog(component: LogComponent, queue?: boolean): void;
+        addLog(type: StatusType, value: unknown, options: LogOptions): void;
         addLog(type: StatusType, value: unknown, from: string, source?: string): void;
-        addLog(type: StatusType, value: unknown, options?: LogOptions): void;
         addLog(type: StatusType, value: unknown, timeStamp?: LogDate, from?: string, source?: string): void;
         addLog(type: StatusType, value: unknown, timeStamp?: LogDate, duration?: number, from?: string, source?: string): void;
         getLog(...type: StatusType[]): LogStatus<StatusType>[];
@@ -641,7 +661,7 @@ declare namespace functions {
         set sessionId(value);
         get sessionId(): string;
         set broadcastId(value);
-        get broadcastId(): StringOfArray;
+        get broadcastId(): ArrayOf<string>;
         get logType(): LOG_TYPE;
         set logLevel(value: NumString);
         get logLevel(): number;
@@ -652,7 +672,7 @@ declare namespace functions {
         /* EventEmitter */
         on(event: "exec", listener: (command: ExecCommand, options?: SpawnOptions) => void): this;
         on(event: "error", listener: (err: Error) => void): this;
-        on(event: "file:read", listener: (src: string, data: BufferContent, options?: ReadFileOptions) => void): this;
+        on(event: "file:read", listener: (src: string, data: Bufferable, options?: ReadFileOptions) => void): this;
         on(event: "file:write", listener: (src: string, options?: WriteFileOptions) => void): this;
         on(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         on(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
@@ -661,7 +681,7 @@ declare namespace functions {
         on(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
         once(event: "exec", listener: (command: ExecCommand, options?: SpawnOptions) => void): this;
         once(event: "error", listener: (err: Error) => void): this;
-        once(event: "file:read", listener: (src: string, data: BufferContent, options?: ReadFileOptions) => void): this;
+        once(event: "file:read", listener: (src: string, data: Bufferable, options?: ReadFileOptions) => void): this;
         once(event: "file:write", listener: (src: string, options?: WriteFileOptions) => void): this;
         once(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         once(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
@@ -670,7 +690,7 @@ declare namespace functions {
         once(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
         emit(event: "exec", command: ExecCommand, options?: SpawnOptions): boolean;
         emit(event: "error", err: Error): boolean;
-        emit(event: "file:read", src: string, data: BufferContent, options?: ReadFileOptions): boolean;
+        emit(event: "file:read", src: string, data: Bufferable, options?: ReadFileOptions): boolean;
         emit(event: "file:write", src: string, options?: WriteFileOptions): boolean;
         emit(event: "file:delete", src: string, options?: DeleteFileOptions): boolean;
         emit(event: "file:copy", dest: string, options?: CopyFileOptions): boolean;
@@ -689,6 +709,7 @@ declare namespace functions {
         LOG_STYLE_REVERSE: LogMessageOptions;
         readonly VERSION: string;
         readonly LOG_TYPE: LOG_TYPE;
+        readonly LOG_FORMAT: LoggerFormatSettings<LoggerFormat<number>>;
         readonly STATUS_TYPE: STATUS_TYPE;
         readonly MAX_TIMEOUT: number;
         readonly TEMP_DIR: string;
@@ -699,9 +720,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, options: AsHashOptions): string;
-        asHash(data: BinaryLike, minLength: number): string;
-        asHash(data: BinaryLike, algorithm?: NumString | AsHashOptions, minLength?: number | AsHashOptions): string;
+        asHash(data: BinaryLike, algorithm: string, minLength?: number): string;
+        asHash(data: BinaryLike, algorithm?: string, options?: AsHashOptions): string;
+        asHash(data: BinaryLike, options?: AsHashOptions): string;
         readHash(value: string | URL, options?: ReadHashOptions): Promise<string>;
         toPosix(value: unknown, normalize: boolean): string;
         toPosix(value: unknown, filename?: string, normalize?: boolean): string;
@@ -721,17 +742,17 @@ declare namespace functions {
         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, options: CopyDirOptions): Promise<CopyDirResult>;
         copyDir(src: string | URL, dest: string | URL, move?: boolean, recursive?: boolean): Promise<CopyDirResult>;
+        copyDir(src: string | URL, dest: string | URL, options?: CopyDirOptions): Promise<CopyDirResult>;
         renameFile(src: string | URL, dest: string | URL, throws?: boolean): boolean;
-        streamFile<U extends BufferContent>(src: string, cache: boolean): Promise<U>;
-        streamFile<U extends ReadBufferOptions>(src: string, options: U): Promise<U extends { encoding: string } ? string : Buffer>;
-        streamFile<U extends ReadBufferOptions>(src: string, cache?: boolean | U, options?: U): Promise<U extends { encoding: string } ? string : Buffer>;
+        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(value: string | URL, encoding?: BufferEncoding | boolean | ReadTextOptions, cache?: boolean): 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): Null<Buffer>;
+        readBuffer(value: string | URL, cache?: boolean | ReadBufferOptions): Null<Buffer>;
         resolveMime(data: string | Buffer | Uint8Array | ArrayBuffer): Promise<Undef<FileTypeResult>>;
         lookupMime(value: string, extension?: boolean): string;
         initCpuUsage(instance?: IModule): CpuUsage;
@@ -743,13 +764,13 @@ 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, 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;
         sanitizeCmd(value: string): string;
         sanitizeArgs(value: string, doubleQuote?: boolean): string;
         sanitizeArgs(values: string[], doubleQuote?: boolean): string[];
-        purgeMemory(percent: number, parent: boolean | number): Promise<number>;
-        purgeMemory(percent?: number, limit?: number, parent?: boolean | number): Promise<number>;
+        purgeMemory(percent: number, limit: number, parent?: boolean): Promise<number>;
+        purgeMemory(percent?: number, limit?: number | boolean, parent?: unknown): Promise<number>;
         canWrite(name: "temp" | "home"): boolean;
         loadSettings(settings: Settings, password?: string): boolean;
         readonly prototype: IModule<T>;
@@ -757,4 +778,4 @@ declare namespace functions {
     }
 }
 
-export = functions;
+export = functions;