@e-mc/types 0.13.10 → 0.14.0

package/lib/filemanager.d.ts

@@ -36,13 +36,13 @@ export interface InstallData<T extends IModule = IModule, U extends ModuleConstr
     params: unknown[];
 }
 
-export interface IHttpDiskCache<T extends ExternalAsset = ExternalAsset> {
+export interface IHttpDiskCache<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> {
     limit: number;
     expires: number;
-    readonly host: IFileManager<T>;
+    readonly host: T;
     has(uri: string | URL): boolean;
-    add<U extends HttpDiskCacheAddOptions>(uri: string | URL, etag: string, target: Bufferable, options?: U): void;
-    within(value: T | number): boolean;
+    add<V extends HttpDiskCacheAddOptions>(uri: string | URL, etag: string, target: Bufferable, options?: V): void;
+    within(value: U | number): boolean;
     clear(value?: unknown): void;
     set enabled(value);
     get enabled(): boolean;
@@ -52,10 +52,10 @@ export interface IHttpDiskCache<T extends ExternalAsset = ExternalAsset> {
     get include(): string[];
 }
 
-export interface IHttpMemoryCache<T extends ExternalAsset = ExternalAsset> extends IHttpDiskCache<T> {
+export interface IHttpMemoryCache<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> extends IHttpDiskCache<T, U> {
     toDisk: [number, number];
     purge(percent?: number, limit?: number): void;
-    withinDisk(value: T | number): boolean;
+    withinDisk(value: U | number): boolean;
     clear(uri?: string | URL): void;
 }
 

package/lib/index.d.ts

@@ -15,12 +15,12 @@ import type { ExecCommand, LOG_TYPE, LogArguments, LogComponent, LogDate, LogFai
 import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, DirectoryActionType, FileActionType, FileTypeFormat, GlobDirOptions, MoveFileOptions, PackageVersionOptions, ParseFunctionOptions, PermissionOptions, PermissionType, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, TempDirOptions, WriteFileOptions } from './module';
 import type { ErrorCode, HighResolutionTime, RequestData, Settings } from './node';
 import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostFileParts as PostFileParts, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from './request';
-import type { ClientModule, CloudAuthSettings, CloudModule, CloudServiceOptions, CompressModule, CompressSettings, DbCoerceSettings, DbModule, DbSourceOptions, DnsLookupSettings, DocumentComponent, DocumentComponentOption, DocumentModule, HandlerSettings, HttpConnectSettings, HttpMemorySettings, ImageModule, LoggerFormat, LoggerFormatSettings, PoolConfig, RequestModule, RequestSettings, TaskModule, WatchModule } from './settings';
+import type { ClientModule, CloudAuthSettings, CloudModule, CloudServiceOptions, CompressModule, CompressSettings, DbCoerceSettings, DbModule, DbSettings, DbSourceOptions, DnsLookupSettings, DocumentComponent, DocumentComponentOption, DocumentModule, HandlerSettings, HttpConnectSettings, HttpMemorySettings, ImageModule, ImportModule, LoggerFormat, LoggerFormatSettings, PoolConfig, RequestModule, RequestSettings, TaskModule, WatchModule } from './settings';
 import type { Command, SpawnResult } from './task';
 import type { IFileGroup, ModifiedPostFinalizeListener, SecureOptions, WatchInitResult } from './watch';
 
 import type { SpawnOptions } from 'node:child_process';
-import type { BinaryLike, BinaryToTextEncoding, HashOptions } from 'node:crypto';
+import type { BinaryLike, HashOptions } from 'node:crypto';
 import type { NoParamCallback, WriteStream } from 'node:fs';
 import type { ClientRequest, OutgoingHttpHeaders } from 'node:http';
 import type { LookupFunction } from 'node:net';
@@ -40,7 +40,6 @@ type BufferView = Bufferable | NodeJS.ArrayBufferView;
 type CpuUsage = NodeJS.CpuUsage;
 
 declare namespace functions {
-    type WatchInstance<T extends ExternalAsset, U extends WatchModule = WatchModule> = IWatch<IFileManager<T>, T, U, ModifiedPostFinalizeListener<T>>;
     type FormatMessageArgs = [type: LogType, title: string, value: LogValue, message: unknown, options: LogMessageOptions];
 
     interface IScopeOrigin<T extends IHost = IHost, U extends IModule = IModule> {
@@ -54,7 +53,7 @@ declare namespace functions {
         get settings(): U;
     }
 
-    interface IExternalFunction<T extends FunctionType<any, any>> {
+    interface IExternalFunction<T extends FunctionType<any>> {
         set extensions(values: unknown[]);
         get extensions(): T[];
     }
@@ -110,13 +109,13 @@ declare namespace functions {
         parseQuality(value: string): QualityData | null;
         parseOpacity(value: string): number;
         parseWorker(command: string | CommandData, outputType?: string): CommandData | null;
-        using?(data: IFileThread<V>, command: string): Promise<unknown>;
+        using?(data: IFileThread<T, V>, command: string): Promise<unknown>;
         get outputAs(): string;
         set host(value);
         get host(): T | null;
     }
 
-    interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ClientConstructor, IWorkerConstructor {
+    interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule, V extends ExternalAsset = ExternalAsset> extends ClientConstructor, IWorkerConstructor {
         readonly MIME_JPEG: string;
         readonly MIME_PNG: string;
         readonly MIME_WEBP: string;
@@ -124,16 +123,16 @@ declare namespace functions {
         readonly MIME_GIF: string;
         readonly MIME_BMP: string;
         readonly MIME_TIFF: string;
-        transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<V extends { tempFile: true } ? string : Buffer | null>;
+        transform<W extends TransformOptions>(file: string, command: string, options?: W): Promise<W extends { tempFile: true } ? string : Buffer | null>;
         clamp(value: unknown, min?: number, max?: number): number;
         isBinary(mime: unknown): mime is string;
         toABGR(buffer: Uint8Array | Buffer): Buffer;
-        readonly prototype: IImage<T, U>;
-        new(module?: U, ...args: unknown[]): IImage<T, U>;
+        readonly prototype: IImage<T, U, V>;
+        new(module?: U, ...args: unknown[]): IImage<T, U, V>;
     }
 
     interface ITask<T extends IHost = IHost, U extends TaskModule = TaskModule, V extends ExternalAsset = ExternalAsset> extends IClient<T, U> {
-        using?(data: IFileThread<V>): Promise<unknown>;
+        using?(data: IFileThread<T, V>): Promise<unknown>;
         collect?(items: unknown[], preceding?: boolean): Promise<SpawnResult>[];
         map?(tasks: Command[]): Promise<SpawnResult | void>[];
         series?(tasks: Command[]): Promise<unknown>;
@@ -144,10 +143,10 @@ declare namespace functions {
         get host(): T | null;
     }
 
-    interface TaskConstructor<T extends IHost = IHost, U extends TaskModule = TaskModule> extends ClientConstructor {
-        finalize<V extends ExternalAsset>(this: T, instance: ITask<T, U>, assets: V[]): Promise<unknown>;
-        readonly prototype: ITask<T, U>;
-        new(module?: U, ...args: unknown[]): ITask<T, U>;
+    interface TaskConstructor<T extends IHost = IHost, U extends TaskModule = TaskModule, V extends ExternalAsset = ExternalAsset> extends ClientConstructor {
+        finalize(this: T, instance: ITask<T, U, V>, assets: V[]): Promise<unknown>;
+        readonly prototype: ITask<T, U, V>;
+        new(module?: U, ...args: unknown[]): ITask<T, U, V>;
     }
 
     interface IDb<T extends IHost = IHost, U extends DbModule = DbModule, V extends DbDataSource = DbDataSource, W extends DbSourceOptions = DbSourceOptions, X extends DbCoerceSettings = DbCoerceSettings> extends IClientDb<T, U, V, W, X> {
@@ -221,6 +220,8 @@ declare namespace functions {
     }
 
     interface DbConstructor<T extends IHost = IHost, U extends DbModule = DbModule, V extends DbDataSource = DbDataSource> extends ClientDbConstructor<T> {
+        readonly HASH_ALGORITHM: string;
+        loadSettings(settings: Settings & { db?: DbSettings }, password?: string): boolean;
         setPoolConfig(value: ObjectMap<PoolConfig>): void;
         getPoolConfig(source: string): Required<PoolConfig> | undefined;
         readonly prototype: IDb<T, U, V>;
@@ -252,8 +253,8 @@ declare namespace functions {
         settingsOf(service: string, name: "cache"): unknown;
         settingsOf(service: string, name: "coerce", component: keyof DbCoerceSettings): unknown;
         settingsOf(service: string, name: "auth", component: keyof CloudAuthSettings): unknown;
-        getUploadHandler(service: string, credential: unknown): FunctionType<void>;
-        getDownloadHandler(service: string, credential: unknown): FunctionType<void>;
+        getUploadHandler(service: string, credential: unknown): FunctionReturn<void>;
+        getDownloadHandler(service: string, credential: unknown): FunctionReturn<void>;
         resolveService(service: string, folder?: string): string;
         set host(value);
         get host(): T | null;
@@ -279,7 +280,7 @@ declare namespace functions {
         new(module?: U, database?: CloudDatabase[], ...args: unknown[]): ICloud<T, U, V>;
     }
 
-    interface IDocument<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends IClient<T, V, TransformCallback<T, U>> {
+    interface IDocument<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>, Z extends FunctionReturn<any> = TransformCallback<T, U>> extends IClient<T, V, Z> {
         Db: IDb | null;
         assets: U[];
         config: StandardMap;
@@ -290,11 +291,11 @@ declare namespace functions {
         asSourceFile(value: string, cache: boolean): unknown;
         asSourceFile(value: string, options?: AsSourceFileOptions): unknown;
         findVersion(name: string | string[], fallback?: string): string;
-        findSourceScope(uri: string, imports: AnyObject): StringMap[];
-        findSourceRoot(uri: string, imports?: StringMap): string | undefined;
+        findSourceScope(uri: string, imports: ImportModule): StringMap[];
+        findSourceRoot(uri: string, imports?: ImportModule): string | undefined;
         resolveDir(name: string, ...paths: string[]): string | undefined;
-        locateSourceFiles(file: U, code?: string, bundleContent?: string[]): (imports?: StringMap) => SourceInput | undefined;
-        resolveSourceFile(file: U): (code?: string, imports?: StringMap) => SourceInput<string> | undefined;
+        locateSourceFiles(file: U, code?: string, bundleContent?: string[]): (imports?: ImportModule) => SourceInput | undefined;
+        resolveSourceFile(file: U): (code?: string, imports?: ImportModule) => SourceInput<string> | undefined;
         tryParse(source: string, format: string, options?: PlainObject): unknown;
         forDb(item: DataSource): boolean;
         hasEval(name: string): boolean;
@@ -304,7 +305,7 @@ declare namespace functions {
         abort(err: Error): void;
         abort(name?: keyof W, reason?: unknown): void;
         restart(): void;
-        using?(data: IFileThread<U>): Promise<unknown>;
+        using?(data: IFileThread<T, U>): Promise<unknown>;
         setLocalUri?(file: U, replace?: boolean): void;
         resolveUri?(file: U, source: string): string;
         resolveUri?(file: U, source: string, trailing: string): [string, string];
@@ -321,7 +322,7 @@ declare namespace functions {
         set dataSource(value: DataSource[]);
         get dataSource(): DataSource[];
         set imports(value);
-        get imports(): StringMap;
+        get imports(): ImportModule;
         get watching(): boolean;
         set host(value);
         get host(): T | null;
@@ -333,9 +334,9 @@ declare namespace functions {
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
         writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): string | undefined;
         /** @deprecated */
-        updateGradle(source: string, namespaces: string[], value: string, upgrade: boolean): string;
+        updateGradle(source: string, namespaces: (string | RegExp)[], value: string | string[], upgrade: boolean): string;
         /** @deprecated */
-        updateGradle(source: string, namespaces: string[], value: string, options?: UpdateGradleOptions): string;
+        updateGradle(source: string, namespaces: (string | RegExp)[], value: string | string[], options?: UpdateGradleOptions): string;
         generateLintTable(messages: LintMessage[], options: GenerateLintTableOptions): LogComponent[];
         cleanup?(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
         sanitizeAssets?(assets: U[], exclusions?: unknown[]): U[];
@@ -343,7 +344,7 @@ declare namespace functions {
         new(module?: V, ...args: unknown[]): IDocument<T, U, V, W, X, Y>;
     }
 
-    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> {
+    interface IWatch<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionReturn<PostFinalizeCallback> = ModifiedPostFinalizeListener<U>> extends IClient<T, V, W> {
         connectTimeout: number;
         init(config?: HostInitConfig): this;
         start(assets: U[], permission?: IPermission | null): void;
@@ -354,8 +355,8 @@ declare namespace functions {
         setSSLCert(value: string): boolean;
         hasSecureProtocol(): boolean;
         getRecursiveFiles(watch: IFileGroup<U>): [string, string[]][];
-        whenModified?(assets: U[], postFinalize: PostFinalizeCallback): IFileManager<U>;
-        whenModified?(assets: U[], sanitize?: boolean, postFinalize?: PostFinalizeCallback): IFileManager<U>;
+        whenModified?(assets: U[], postFinalize: PostFinalizeCallback): T;
+        whenModified?(assets: U[], sanitize?: boolean, postFinalize?: PostFinalizeCallback): T;
         set assets(value: U[]);
         get assets(): U[];
         set interval(value);
@@ -368,7 +369,7 @@ declare namespace functions {
         get host(): T | null;
     }
 
-    interface WatchConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionType<unknown, any> = ModifiedPostFinalizeListener<U>> extends ClientConstructor {
+    interface WatchConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionReturn<PostFinalizeCallback> = ModifiedPostFinalizeListener<U>> extends ClientConstructor {
         createServer(port: number, active: boolean): ws.Server | null;
         createServer(port: number, secure?: SecureOptions | null, active?: boolean): ws.Server | null;
         shutdown(): void;
@@ -448,11 +449,11 @@ declare namespace functions {
     interface IFileManager<T extends ExternalAsset = ExternalAsset> extends IHost, Set<string> {
         processTimeout: number;
         Request: IRequest;
-        Document: InstallData<IDocument<this, T>, DocumentConstructor<this, T>>[];
+        Document: InstallData<IDocument<IFileManager<T>, T>, DocumentConstructor<IFileManager<T>, T>>[];
         Task: InstallData<ITask, TaskConstructor>[];
         Image: ImageMimeMap | null;
         Cloud: ICloud | null;
-        Watch: WatchInstance<T> | null;
+        Watch: IWatch<this, T> | null;
         Compress: ICompress | null;
         readonly documentAssets: T[];
         readonly taskAssets: Array<T & Required<TaskAction>>;
@@ -463,12 +464,12 @@ declare namespace functions {
         readonly filesToCompare: Map<T, string[]>;
         readonly contentToAppend: Map<string, string[]>;
         readonly contentToReplace: Map<string, string[]>;
-        readonly processing: IFileThread<T>[];
+        readonly processing: IFileThread<IHost, T>[];
         readonly fetchedAssets: T[];
         readonly copiedAssets: T[];
         readonly emptyDir: Set<string>;
-        readonly cacheToDisk: IHttpDiskCache<T>;
-        readonly cacheToMemory: IHttpMemoryCache<T>;
+        readonly cacheToDisk: IHttpDiskCache<this, T>;
+        readonly cacheToMemory: IHttpMemoryCache<this, T>;
         install(name: "document", handler: string, module?: DocumentModule, ...args: unknown[]): IDocument<this, T> | undefined;
         install(name: "document", target: DocumentConstructor<this, T>, module?: DocumentModule, ...args: unknown[]): IDocument<this, T> | undefined;
         install(name: "task", handler: string, module?: TaskModule, ...args: unknown[]): ITask | undefined;
@@ -478,9 +479,9 @@ declare namespace functions {
         install(name: "image", handler: string, module?: ImageModule, ...args: unknown[]): IImage | undefined;
         install(name: "image", target: ImageConstructor, module?: ImageModule, ...args: unknown[]): IImage | undefined;
         install(name: "image", targets: Map<string, ImageConstructor>, module?: ImageModule): void;
-        install(name: "watch", handler: string, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
-        install(name: "watch", target: WatchConstructor<this, T>, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
-        install(name: "watch", module: WatchModule): WatchInstance<T> | undefined;
+        install(name: "watch", handler: string, module?: WatchModule, ...args: unknown[]): IWatch<this, T> | undefined;
+        install(name: "watch", target: WatchConstructor<this, T>, module?: WatchModule, ...args: unknown[]): IWatch<this, T> | undefined;
+        install(name: "watch", module: WatchModule): IWatch<this, T> | undefined;
         install(name: "compress", module?: CompressModule): ICompress | undefined;
         install<U extends IModule>(name: string, ...args: unknown[]): U | undefined;
         using(...items: FirstOf<T>): this;
@@ -502,14 +503,14 @@ declare namespace functions {
         setLocalUri(file: T, replace?: boolean): FileOutput;
         getLocalUri(data: FileData<T>): string;
         getMimeType(data: FileData<T>): string;
-        openThread(instance: IModule, data: IFileThread<T>, timeout?: number): boolean;
-        closeThread(instance: IModule | null, data: IFileThread<T>, callback?: FunctionType<void>): boolean;
+        openThread(instance: IModule, data: IFileThread<IHost, T>, timeout?: number): boolean;
+        closeThread(instance: IModule | null, data: IFileThread<IHost, T>, callback?: FunctionType<void>): boolean;
         addProcessTimeout(instance: IModule, file: T, timeout: number): void;
         removeProcessTimeout(instance: IModule, file: T): void;
         getProcessTimeout(handler: InstallData): number;
         clearProcessTimeout(): void;
         scheduleTask(uri: string | URL, data: unknown, priority: number): Promise<unknown>;
-        scheduleTask(uri: string | URL, data: unknown, thenCallback?: FunctionType, catchCallback?: FunctionType, priority?: number): Promise<unknown>;
+        scheduleTask(uri: string | URL, data: unknown, thenCallback?: FunctionReturn, catchCallback?: FunctionReturn, 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;
@@ -517,7 +518,7 @@ declare namespace functions {
         checkHash(checksum: ChecksumValue, options: CheckHashOptions): boolean;
         checkHash(checksum: ChecksumValue, data: Optional<Bufferable>, uri: string | URL | undefined): boolean;
         checkHash(checksum: ChecksumValue, data: Bufferable, options?: CheckHashOptions): boolean;
-        transformAsset(data: IFileThread<T>, parent?: T, override?: boolean): Promise<boolean>;
+        transformAsset(data: IFileThread<IHost, T>, parent?: T, override?: boolean): Promise<boolean>;
         addCopy(data: FileCommand<T>, saveAs?: string, replace?: boolean): string | undefined;
         handleFilePermission(file: T): void;
         findMime(file: T, rename?: boolean): Promise<string>;
@@ -614,24 +615,24 @@ declare namespace functions {
         emit(event: "asset:permission", file: T): boolean;
     }
 
-    interface FileManagerConstructor<T extends ExternalAsset> extends HostConstructor {
+    interface FileManagerConstructor<T extends IFileManager<U>, U 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[];
+        sanitizeAssets(assets: U[], exclusions?: string[]): U[];
         writeChecksum(root: string, options: ChecksumOptions): Promise<string[]>;
         writeChecksum(root: string, to?: string | ChecksumOptions, options?: ChecksumOptions): Promise<string[] | null>;
         verifyChecksum(root: string, options: ChecksumOptions): Promise<[string[], string[], number] | null>;
         verifyChecksum(root: string, from?: string | ChecksumOptions, options?: ChecksumOptions): Promise<[string[], string[], number] | null>;
-        createFileThread(host: IFileManager<T>, file: T): IFileThread<T>;
+        createFileThread(host: T, file: U): IFileThread<T, U>;
         setTimeout(options: ObjectMap<number | string>): void;
         defineHttpCache(options: HttpMemorySettings, disk?: boolean): void;
         defineHttpConnect(options: HttpConnectSettings): void;
         defineHttpAdapter(module: unknown): void;
         generateSessionId(): string;
-        readonly prototype: IFileManager<T>;
-        new(baseDirectory: string, config: RequestData<T>, postFinalize?: PostFinalizeCallback): IFileManager<T>;
-        new(baseDirectory: string, config: RequestData<T>, permission?: IPermission | null, postFinalize?: PostFinalizeCallback): IFileManager<T>;
+        readonly prototype: T;
+        new(baseDirectory: string, config: RequestData<U>, postFinalize?: PostFinalizeCallback): T;
+        new(baseDirectory: string, config: RequestData<U>, permission?: IPermission | null, postFinalize?: PostFinalizeCallback): T;
     }
 
     interface IHost extends IModule {
@@ -640,7 +641,7 @@ declare namespace functions {
         readonly subProcesses: Set<IModule>;
         readonly startTime: number;
         using(...items: FirstOf<unknown>): this;
-        contains(item: unknown, condition?: FunctionType<boolean, any>): boolean;
+        contains(item: unknown, condition?: FunctionReturn<boolean>): boolean;
         find(name: string): IModule | undefined;
         findAll(name: string): IModule[];
         willLog(name: string): boolean;
@@ -851,7 +852,7 @@ declare namespace functions {
         asString(value: unknown, cacheKey?: boolean | "throws"): string;
         asHash(data: BinaryLike, options?: AsHashOptions): string;
         asHash(data: BinaryLike, algorithm?: string, options?: HashOptions): string;
-        asHash(data: BinaryLike, algorithm?: string, encoding?: BinaryToTextEncoding): string;
+        asHash(data: BinaryLike, algorithm?: string, encoding?: BufferEncoding): string;
         readHash(value: string | URL, options?: ReadHashOptions): Promise<string>;
         toPosix(value: unknown, normalize: boolean): string;
         toPosix(value: unknown, filename?: string, normalize?: boolean): string;

package/lib/module.d.ts

@@ -132,7 +132,7 @@ export interface ReadBufferOptions extends StreamBase, EncodingAction {
     cache?: boolean;
 }
 
-export interface AsHashOptions extends HashOptions, ChecksumBase {}
+export interface AsHashOptions extends HashOptions, ChecksumBase<BufferEncoding> {}
 
 export interface TempDirOptions {
     pathname?: string;

package/lib/object.d.ts

@@ -1,41 +1,21 @@
-/** @deprecated lib/image **/
-interface Point {
-    x: number;
-    y: number;
+interface ErrorConstructor {
+    /**
+     * Indicates whether the argument provided is a built-in Error instance or not.
+     */
+    isError(error: unknown): error is Error;
 }
 
-/** @deprecated lib/image **/
-interface Dimension {
-    width: number;
-    height: number;
-}
-
-/** @deprecated lib/squared **/
-interface KeyValue<T, U> {
-    key: T;
-    value: U;
-}
-
-/** @deprecated lib/node **/
-interface ErrorCode extends Error {
-    code?: unknown;
-}
-
-/** @deprecated lib/http **/
-interface AuthValue {
-    username?: string;
-    password?: string;
-}
-
-/** @deprecated lib/settings **/
-interface MinMax<T = number> {
-    min?: T;
-    max?: T;
-}
-
-/** @deprecated lib/node **/
-type HighResolutionTime = bigint | [number, number];
-
 interface RegExpConstructor {
-    escape(value: string): string;
+    /**
+     * Escapes any RegExp syntax characters in the input string, returning a
+     * new string that can be safely interpolated into a RegExp as a literal
+     * string to match.
+     * @example
+     * ```ts
+     * const regExp = new RegExp(RegExp.escape("foo.bar"));
+     * regExp.test("foo.bar"); // true
+     * regExp.test("foo!bar"); // false
+     * ```
+     */
+    escape(string: string): string;
 }

package/lib/request.d.ts

@@ -38,16 +38,6 @@ export interface IHttpHost {
     success(version: HttpProtocolVersion, status?: boolean): number;
     failed(version: HttpProtocolVersion, status?: boolean): number;
     error(version: HttpProtocolVersion, status?: boolean): number;
-    /** @deprecated altSvc.did */
-    didAltSvc(version: HttpProtocolVersion): boolean;
-    /** @deprecated altSvc.next */
-    nextAltSvc(): boolean;
-    /** @deprecated altSvc.close */
-    closeAltSvc(error?: boolean): boolean;
-    /** @deprecated altSvc.clear */
-    clearAltSvc(version?: HttpProtocolVersion): void;
-    /** @deprecated altSvc.flag */
-    flagAltSvc(version: HttpProtocolVersion, value: number): void;
     reset(): void;
     v1(): boolean;
     v2(): boolean;

package/lib/settings.d.ts

@@ -4,6 +4,7 @@ import type { HashAlgorithm } from './asset';
 import type { CloudSource } from './cloud';
 import type { PermissionAction, PermissionReadWrite, PermittedDirectories } from './core';
 import type { DbSource, TimeoutAction } from './db';
+import type { ImportMap } from './document';
 import type { AuthValue, HttpOutgoingHeaders, SecureConfig, ServerPort } from './http';
 import type { BackgroundColor, BroadcastOutMethod, ErrorOutMethod, ForegroundColor, LoggerColor, LoggerStatus, TextAlign, TextWrapStyle } from './logger';
 import type { ExecAction, IncludeAction } from './module';
@@ -12,7 +13,7 @@ import type { SpawnOptions } from 'node:child_process';
 import type { BinaryLike, CipherGCMTypes } from 'node:crypto';
 import type { LookupAddress } from 'node:dns';
 import type { AgentOptions } from 'node:http';
-import type { BrotliOptions, ZlibOptions } from 'node:zlib';
+import type { BrotliOptions, ZlibOptions, ZstdOptions } from 'node:zlib';
 // @ts-ignore
 import type { BackgroundColor as IBackgroundColor } from 'chalk';
 // @ts-ignore
@@ -20,8 +21,6 @@ import type { Unit } from 'bytes';
 // @ts-ignore
 import type { MinimatchOptions } from 'minimatch';
 // @ts-ignore
-import type { Options as ZopfliOptions } from 'node-zopfli';
-// @ts-ignore
 import type { PicomatchOptions } from 'picomatch';
 
 export interface DownloadAction {
@@ -143,8 +142,11 @@ export interface DownloadModule<T = PlainObject> extends HandlerSettings<T>, Exp
         csv?: boolean;
         differ?: string;
         error?: string;
-        cutoff_mode?: "HARD" | "SOFT" | "CAUTIOUS";
+        format?: string;
+        separator?: string;
+        timeformat?: string;
         hash: "md5" | "SHA-1" | "DropboxHash";
+        cutoff_mode?: "HARD" | "SOFT" | "CAUTIOUS";
         ignore_case_sync?: boolean;
         ignore_checksum?: boolean;
         ignore_existing?: boolean;
@@ -165,6 +167,7 @@ export interface DownloadModule<T = PlainObject> extends HandlerSettings<T>, Exp
         no_traverse?: boolean;
         no_update_dir_modtime?: boolean;
         no_update_modtime?: boolean;
+        order_by?: string;
         refresh_times?: boolean;
         size_only?: boolean;
         streaming_upload_cutoff?: string;
@@ -183,7 +186,7 @@ export interface DownloadModule<T = PlainObject> extends HandlerSettings<T>, Exp
 
 export interface DocumentModule<T = DocumentSettings, U = DbSettings> extends ClientModule<T> {
     eval?: DocumentEval;
-    imports?: StringMap;
+    imports?: ImportModule;
     versions?: StringMap;
     format?: AnyObject;
     db?: DbModule<U>;
@@ -194,11 +197,11 @@ export interface DocumentEval {
     absolute?: boolean;
 }
 
-export interface DocumentGroup<T = { imports?: StringMap } & AnyObject, U = AnyObject> {
+export interface DocumentGroup<T = { imports?: ImportModule } & AnyObject, U = AnyObject> {
     transform?: T;
     view_engine?: U;
     pages?: ObjectMap<AnyObject>;
-    imports?: StringMap;
+    imports?: ImportModule;
 }
 
 export interface DocumentUserSettings<T = AnyObject, U = T> extends DocumentGroup<T, U>, PlainObject {
@@ -232,7 +235,8 @@ export type DocumentComponentOptions = DocumentComponent<DocumentComponentOption
 export interface ClientDbSettings<T = PlainObject> extends ClientSettings<T>, PurgeAction {
     session_expires?: number | string;
     user_key?: ObjectMap<DbSourceOptions>;
-    imports?: StringMap;
+    imports?: ImportModule;
+    cache?: { dir?: string; algorithm?: string };
 }
 
 export interface MemoryModule<T = MemorySettings> extends HandlerSettings<T>, Record<string, T | ObjectMap<PurgeBase> | undefined> {}
@@ -363,8 +367,7 @@ export interface WatchSettings<T = WatchUserSettings> extends ClientSettings<Obj
 export interface CompressModule<U = CompressSettings> extends HandlerSettings<U> {
     gzip?: ZlibOptions;
     brotli?: BrotliOptions;
-    /** @deprecated */
-    zopfli?: ZopfliOptions;
+    zstd?: ZstdOptions;
 }
 
 export interface CompressSettings extends PlainObject {
@@ -373,8 +376,7 @@ export interface CompressSettings extends PlainObject {
     cache_expires?: number | string;
     gzip_level?: number | string;
     brotli_quality?: number | string;
-    /** @deprecated */
-    zopfli_iterations?: number | string;
+    zstd_compression_level?: number | string;
     chunk_size?: number | string;
 }
 
@@ -403,8 +405,6 @@ export interface ErrorModule<T = ErrorSettings> extends HandlerModule<T, ErrorOu
     out?: string | ErrorOutMethod;
     abort?: string[];
     fatal?: boolean;
-    /** @deprecated retry_limit */
-    recursion_limit?: number | string;
     retry_limit?: number | string;
 }
 
@@ -446,6 +446,7 @@ export interface LoggerModule<T = number | string, U = boolean | T, V = LoggerFo
     file?: boolean | LoggerColor;
     cloud?: boolean | LoggerColor;
     db?: boolean | LoggerColor;
+    user?: boolean | LoggerColor;
     time_elapsed?: boolean | LoggerColor;
     time_process?: boolean | LoggerColor;
     exec?: boolean | LoggerColor;
@@ -580,6 +581,7 @@ export interface MinMax<T = number> {
     max?: T;
 }
 
+export type ImportModule = ImportMap & StringMap;
 export type WatchUserSettings = ObjectMap<WatchInterval>;
 export type DocumentTransform = boolean | "etag" | HashAlgorithm | HashConfig | null;
 

package/lib/squared.d.ts

@@ -332,8 +332,6 @@ export interface RequestObserve extends WebSocketClient, ExpiresAction {
 
 export interface ChecksumBase<T = BinaryToTextEncoding> {
     algorithm?: string;
-    /** @deprecated digestEncoding */
-    digest?: T;
     digestEncoding?: T;
 }
 

package/lib/type.d.ts

@@ -8,8 +8,9 @@ type MapOfType<T, U = any, V = any> = { [K in KeyOfType<T, U, V>]: K extends U ?
 type Constructor<out T> = new(...args: any[]) => T;
 type ConstructorDerived<T> = Pick<T, { [K in keyof T]: T[K] extends new() => any ? never : K }[keyof T]>;
 
-type FunctionType<T = unknown, U = unknown> = (...args: U[]) => T;
-type FunctionArgs<T extends unknown[], U = unknown> = (...args: T) => U;
+type FunctionType<out T = unknown, in U = unknown> = (...args: U[]) => T;
+type FunctionReturn<out T = unknown, in U = any> = (...args: U[]) => T;
+type FunctionArgs<in T extends unknown[], out U = unknown> = (...args: T) => U;
 
 type IntBool = boolean | 0 | 1;
 type ArrayOf<T> = T | T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/types",
-  "version": "0.13.10",
+  "version": "0.14.0",
   "description": "Type definitions for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -23,6 +23,13 @@
     "chalk": "4.1.2"
   },
   "devDependencies": {
-    "typescript": "5.9.3"
+    "typescript": "6.0.3"
+  },
+  "peerDependencies": {
+    "@types/bytes": "*",
+    "@types/picomatch": "*",
+    "@types/ws": "*",
+    "file-type": "*",
+    "minimatch": "*"
   }
 }