@e-mc/types 0.12.9 → 0.13.1

package/README.md

@@ -1,6 +1,6 @@
 # @e-mc/types
 
-* NodeJS 18
+* NodeJS 18.20.5 LTS
 * ES2022
 
 ## General Usage
@@ -9,11 +9,11 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.12.9/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.13.1/index.d.ts)
 
 ```typescript
 import type { LogArguments } from "./lib/logger";
-import type { HighResolutionTime } from "./lib/node";
+import type { ErrorCode, HighResolutionTime } from "./lib/node";
 
 import type { BinaryLike, CipherGCMTypes, Encoding } from "node:crypto";
 import type { BytesOptions } from "bytes";
@@ -39,10 +39,14 @@ function isObject(value: unknown): value is object;
 function isPlainObject(value: unknown): value is Record<string | number | symbol, unknown>;
 function isString(value: unknown): value is string;
 function isEmpty(value: unknown): boolean;
-function isFunction<T extends Function>(value: unknown, cjs?: boolean): value is T;
+function isFunction(value: unknown, cjs?: boolean): value is Function;
+function isErrorCode(err: unknown, ...code: unknown[]): err is Required<ErrorCode>;
 function asFunction(value: unknown, sync?: boolean): ((...args: unknown[]) => unknown) | null;
+function parseTime(value: number | string, epoch: true): number;
+function parseTime(value: number | string, negative: false): number;
 function parseTime(value: number | string, start?: number): number;
-function parseExpires(value: number | string, start?: number): number;
+function parseExpires(value: number | string, epoch: true): number;
+function parseExpires(value: number | string, start?: number | boolean): number;
 function formatTime(value: number, char: string): string;
 function formatTime(value: number, elapsed?: boolean, char?: string): string;
 function convertTime(value: number | string): number;
@@ -203,10 +207,10 @@ const IMPORT_MAP: Record<string, string | undefined>;
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.12.9/index.d.ts
-- https://www.unpkg.com/@e-mc/types@0.12.9/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.12.9/lib/module.d.ts
-- https://www.unpkg.com/@e-mc/types@0.12.9/lib/node.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.1/index.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.1/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.1/lib/module.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.1/lib/node.d.ts
 
 * https://developer.mozilla.org/en-US/docs/Web/API/DOMException
 * https://www.npmjs.com/package/@types/bytes

package/constant.d.ts

@@ -1,5 +1,5 @@
 export const enum INTERNAL {
-    VERSION = '0.12.9',
+    VERSION = '0.13.1',
     TEMP_DIR = 'tmp',
     CJS = '__cjs__'
 }
@@ -20,6 +20,7 @@ export const enum VAL_DB {
 export const enum VAL_CLOUD {
     UPLOAD_FILE = 'Upload success',
     DOWNLOAD_FILE = 'Download success',
+    COPY_FILE = 'Copy success',
     DELETE_FILE = 'Delete success',
     RENAME_FILE = 'File renamed',
     CREATE_TAG = 'Tags created',
@@ -163,6 +164,7 @@ export const enum ERR_CLOUD {
     BUCKET_POLICY_SUPPORT = 'Bucket policy not supported',
     BUCKET_TAGGING_SUPPORT = 'Bucket tagging not supported',
     DELETE_OBJECTS_SUPPORT = 'Delete objects not supported',
+    COPY_OBJECT_SUPPORT = 'Copy object not supported',
     BUCKET_WEBSITE_SUPPORT = 'Set bucket website not supported',
     EXECUTE_QUERY_SUPPORT = 'Execute query not supported',
     UPLOAD_SUPPORT = 'Upload function not supported',
@@ -170,6 +172,7 @@ export const enum ERR_CLOUD {
     UPLOAD_FAIL = 'Upload failed',
     DOWNLOAD_FAIL = 'Download failed',
     DELETE_FAIL = 'Delete failed',
+    COPY_FAIL = 'Copy failed',
     METADATA_FAIL = 'Metadata failed'
 }
 

package/index.d.ts

@@ -2,7 +2,7 @@
 /// <reference path="./lib/type.d.ts" />
 
 import type { LogArguments } from './lib/logger';
-import type { HighResolutionTime } from './lib/node';
+import type { ErrorCode, HighResolutionTime } from './lib/node';
 
 import type { BinaryLike, BinaryToTextEncoding, CipherGCMTypes, Encoding } from 'node:crypto';
 
@@ -308,9 +308,13 @@ declare namespace types {
     function isString<T extends string>(value: unknown): value is T;
     function isEmpty(value: unknown): boolean;
     function isFunction<T extends Function>(value: unknown, cjs?: boolean): value is T;
+    function isErrorCode<T extends unknown[]>(err: unknown, ...code: T): err is Required<ErrorCode<T[number]>>;
     function asFunction<U = unknown, V = unknown>(value: unknown, sync?: boolean): FunctionType<U, V> | null;
+    function parseTime(value: number | string, epoch: true): number;
+    function parseTime(value: number | string, negative: false): number;
     function parseTime(value: number | string, start?: number): number;
-    function parseExpires(value: number | string, start?: number): number;
+    function parseExpires(value: number | string, epoch: true): number;
+    function parseExpires(value: number | string, start?: number | boolean): number;
     function formatTime(value: number, char: string): string;
     function formatTime(value: number, elapsed?: boolean, char?: string): string;
     function convertTime(value: number | string): number;

package/index.js

@@ -20,6 +20,7 @@ exports.isObject = isObject;
 exports.isString = isString;
 exports.isEmpty = isEmpty;
 exports.isFunction = isFunction;
+exports.isErrorCode = isErrorCode;
 exports.parseTime = parseTime;
 exports.parseExpires = parseExpires;
 exports.formatTime = formatTime;
@@ -537,9 +538,9 @@ exports.IMPORT_MAP = {
     "sass": "@pi-r/sass",
     "stylelint": "@pi-r/stylelint",
     "terser": "@pi-r/terser",
+    "imagemin": "@pi-r/imagemin",
     "ibm": "@pi-r2/ibm",
     "minio": "@pi-r2/minio",
-    "imagemin": "@pi-r2/imagemin",
     "clean-css": "@pi-r2/clean-css",
     "csso": "@pi-r2/csso",
     "html-minifier": "@pi-r2/html-minifier",
@@ -622,16 +623,25 @@ function isEmpty(value) {
 function isFunction(value, cjs = false) {
     return typeof value === 'function' && (!cjs || Object.hasOwn(value, "__cjs__"));
 }
+function isErrorCode(err, ...code) {
+    return err instanceof Error && code.some(value => value === err.code);
+}
 function parseTime(value, start = 0) {
+    if (start === true) {
+        start = Date.now();
+    }
     const seconds = +value;
     if (isNaN(seconds) && isString(value)) {
         let result = 0;
-        for (const match of value.matchAll(/\b([\d.]+)\s*(y|w|d|h|ms?|s)\b/gi)) {
-            const n = +match[1];
+        for (const match of value.matchAll(/([+-]|\b)([\d.]+)\s*(y|w|d|h|ms?|s)\b/gi)) {
+            let n = +match[2];
             if (isNaN(n)) {
                 continue;
             }
-            switch (match[2].toLowerCase()) {
+            if (match[1] === '-' && start === false) {
+                n *= -1;
+            }
+            switch (match[3].toLowerCase()) {
                 case 'y':
                     result += n * 31449600000;
                     break;
@@ -651,15 +661,18 @@ function parseTime(value, start = 0) {
                     result += Math.ceil(n);
                     break;
                 default:
-                    result += n * (match[2] === 'M' ? 2592000000 : 60000);
+                    result += n * (match[3] === 'M' ? 2592000000 : 60000);
                     break;
             }
         }
+        if (start === false) {
+            return result;
+        }
         if (result > 0) {
             return Math.ceil(result) + start;
         }
     }
-    else if (seconds > 0) {
+    else if (seconds > 0 && typeof start === 'number') {
         return Math.ceil(seconds * 1000) + start;
     }
     return 0;
@@ -668,14 +681,24 @@ function parseExpires(value, start = 0) {
     if (+value < 0 || value === 'never') {
         return Infinity;
     }
+    if (start === false) {
+        start = 0;
+    }
     return parseTime(value, start);
 }
 function formatTime(value, elapsed, char = ' ') {
+    let sign = '';
     if (elapsed === true) {
         value = Date.now() - value;
     }
-    else if (isString(elapsed)) {
-        char = elapsed;
+    else {
+        if (value < 0) {
+            sign = '-';
+            value = Math.abs(value);
+        }
+        if (isString(elapsed)) {
+            char = elapsed;
+        }
     }
     if (char === ':') {
         let result = '';
@@ -699,7 +722,7 @@ function formatTime(value, elapsed, char = ' ') {
         else {
             result += '00';
         }
-        return result;
+        return sign + result;
     }
     const result = [];
     if (value < 1000) {
@@ -718,7 +741,7 @@ function formatTime(value, elapsed, char = ' ') {
     if (value > 0) {
         result.push(value < 100 ? value + 'ms' : (value / 1000).toPrecision(value <= 9950 ? 2 : 3).replace(/\.?0+$/, '') + 's');
     }
-    return result.join(char);
+    return (sign ? result.map(item => sign + item) : result).join(char);
 }
 function convertTime(value, format) {
     let result = 0;

package/lib/cloud.d.ts

@@ -54,7 +54,7 @@ export interface CloudStorageAction<T = unknown, U = string, V = unknown, W = un
     admin?: CloudStorageAdmin<T, U, V, W, X, Y>;
 }
 
-export interface CloudStorageUpload<T = unknown, U = string, V = unknown, W = string, X = unknown, Y = unknown, Z = unknown> extends CloudStorageACL<U>, CloudStorageAction<V, W, unknown, X, Y, Z> {
+export interface CloudStorageUpload<T = unknown, U = string, V = unknown, W = string, X = unknown, Y = unknown, Z = unknown, A = unknown> extends CloudStorageACL<U>, CloudStorageAction<V, W, unknown, X, Y, Z>, CopyObjectAction<A> {
     buffer?: Buffer | null;
     contentType?: string;
     metadata?: Record<string, string>;
@@ -71,7 +71,7 @@ export interface CloudStorageACL<T = string> {
     acl?: T;
 }
 
-export interface CloudStorageDownload<T = unknown, U = unknown> extends CloudStorageAction {
+export interface CloudStorageDownload<T = unknown, U = unknown, V = unknown> extends CloudStorageAction, CopyObjectAction<V> {
     keyname?: string;
     versionId?: string;
     options?: U;
@@ -88,20 +88,26 @@ export interface BucketWebsiteOptions {
 
 export interface DeleteObjectsOptions extends RecursiveAction, PlainObject {}
 
-export interface UploadData<T = unknown, U = string, V = unknown, W = string, X = unknown, Y = unknown, Z = unknown> extends BucketAction {
-    upload: CloudStorageUpload<T, U, V, W, X, Y, Z>;
+export interface CopyObjectOptions extends PlainObject {}
+
+export interface UploadData<T = unknown, U = string, V = unknown, W = string, X = unknown, Y = unknown, Z = unknown, A = unknown> extends BucketAction {
+    upload: CloudStorageUpload<T, U, V, W, X, Y, Z, A>;
     localUri: string;
     buffer: Buffer;
 }
 
-export interface DownloadData<T = unknown, U = unknown> extends BucketAction {
-    download: CloudStorageDownload<T, U>;
+export interface DownloadData<T = unknown, U = unknown, V = unknown> extends BucketAction {
+    download: CloudStorageDownload<T, U, V>;
 }
 
 export interface BucketAction {
     bucket: string;
 }
 
+export interface CopyObjectAction<T = PlainObject> {
+    copyObject?: ArrayOf<BucketAction & Partial<LocationUri> & { options?: T }>;
+}
+
 export interface UploadAssetOptions {
     contentType?: string;
     ignoreProcess?: boolean;
@@ -111,4 +117,5 @@ export interface UploadAssetOptions {
 export type UploadContent = [Bufferable, string, string?];
 export type CloudSource = "atlas" | "aws" | "aws-v3" | "az" | "azure" | "gcp" | "gcloud" | "oci";
 export type CloudFeatures = "storage" | "database";
-export type CloudFunctions = "upload" | "download";
+export type CloudFunctions = "upload" | "download";
+export type CloudLogMessageType = "SUCCESS" | "FAIL" | "COMMAND" | "WARN" | "UPLOAD" | "DOWNLOAD" | "DELETE" | "DELAYED";

package/lib/compress.d.ts

@@ -3,6 +3,8 @@ import type { CompressFormat as ICompressFormat, CompressLevel as ICompressLevel
 import type { LogBaseOptions, LogTime } from './logger';
 import type { ThrowsAction } from './module';
 
+import type { BrotliOptions, ZlibOptions } from 'node:zlib';
+
 type ResultCallback<T = Buffer | Uint8Array | null> = (err: unknown, data?: T, ext?: string) => void;
 type ResultData = Buffer | Uint8Array | string | null;
 
@@ -14,14 +16,14 @@ export interface CompressFormat extends ICompressFormat, LogBaseOptions, Readabl
     outFile?: string;
 }
 
-export interface CompressLevel extends ICompressLevel, ReadableOptions {}
+export interface CompressLevel extends ICompressLevel, ReadableOptions, ZlibOptions {}
 
-export interface BrotliCompressLevel extends CompressLevel, MimeTypeAction {}
+export interface BrotliCompressLevel extends CompressLevel, BrotliOptions, MimeTypeAction {}
 
 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>) => Promise<ResultData | void>;
-export type TryFileCompressorAsync = (data: string | Buffer, output: string, config: CompressFormat) => Promise<ResultData>;
+export type TryFileCompressor = (data: Bufferable, output: string, config: CompressFormat, callback?: ResultCallback<ResultData>) => Promise<ResultData | void>;
+export type TryFileCompressorAsync = (data: Bufferable, output: string, config: CompressFormat) => Promise<ResultData>;
 export type BufferResult = Buffer | Uint8Array | null;
 export type PluginCompressor = FunctionArgs<[CompressFormat["options"], CompressFormat["metadata"]?], FunctionArgs<[Buffer], Promise<Buffer | Uint8Array>>>;

package/lib/document.d.ts

@@ -88,8 +88,11 @@ export interface ITransformSeries<T = AnyObject, U = T, V = object> extends IMod
     getMainFile(code?: string, imports?: StringMap): SourceInput<string> | undefined;
     getSourceFiles(imports?: StringMap): SourceInput | undefined;
     toBaseConfig(all?: boolean): T;
-    upgrade<W = unknown>(context: W, dirname?: string, pkgname?: string): W;
-    upgradeESM<W = unknown>(context: W, dirname?: string, pkgname?: string): Promise<W>;
+    upgrade<W = unknown>(context: W, options: FindModuleOptions): W;
+    upgrade<W = unknown>(context: W, startDir?: string, packageName?: string, version?: string): W;
+    upgradeESM<W = unknown>(context: W, options: FindModuleOptions): Promise<W>;
+    upgradeESM<W = unknown>(context: W, startDir?: string, packageName?: string, version?: string): Promise<W>;
+    findModule(startDir: string, packageName?: string, version?: string): string;
     set code(value);
     get code(): string;
     get out(): IOut;
@@ -151,6 +154,12 @@ export interface SourceMapConstructor {
     new(code: string, uri?: string, remove?: boolean): SourceMap;
 }
 
+export interface FindModuleOptions {
+    startDir?: string;
+    packageName?: string;
+    version?: string;
+}
+
 export interface ImportMap {
     imports?: StringMap;
     scopes?: ObjectMap<StringMap>;
@@ -196,4 +205,4 @@ export interface AsSourceFileOptions extends EncodingAction {
 export type Transformer = FunctionType<Promise<string> | string>;
 export type ConfigOrTransformer = AnyObject | Transformer;
 export type PluginConfig<T = ConfigOrTransformer> = [string, T | undefined, AnyObject | undefined, boolean?] | [];
-export type TransformCallback<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> = (this: T, instance: IDocument<T, U>, requireOrDocumentDir?: NodeJS.Require | string) => Promise<void >;
+export type TransformCallback<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> = (this: T, instance: IDocument<T, U>, requireOrDocumentDir?: NodeJS.Require | string) => Promise<void>;

package/lib/filemanager.d.ts

@@ -41,7 +41,7 @@ export interface IHttpDiskCache<T extends ExternalAsset = ExternalAsset> {
     expires: number;
     readonly host: IFileManager<T>;
     has(uri: string | URL): boolean;
-    add<U extends HttpDiskCacheAddOptions>(uri: string | URL, etag: string, target: string | Buffer, options?: U): void;
+    add<U extends HttpDiskCacheAddOptions>(uri: string | URL, etag: string, target: Bufferable, options?: U): void;
     within(value: T | number): boolean;
     clear(value?: unknown): void;
     set enabled(value);
@@ -113,11 +113,18 @@ export interface ChecksumOptions extends ReadHashOptions, Pick<ChecksumOutput, "
     sortBy?: number;
     verbose?: boolean;
     ignore?: string[];
+    ignoreRoot?: string[];
     joinRoot?: boolean;
     outPath?: string;
     throwsEmpty?: boolean;
 }
 
+export interface CheckHashOptions {
+    data?: Bufferable | null;
+    uri?: string | URL;
+    output?: boolean;
+}
+
 export type ImageMimeMap = Map<string, InstallData<IImage, ImageConstructor>>;
 export type FetchType = FETCH_TYPE[keyof FETCH_TYPE];
 export type PostFinalizeCallback = (files: FileInfo[] | string[], errors: string[], status?: LogStatus[]) => void;

package/lib/index.d.ts

@@ -1,19 +1,19 @@
 /// <reference path="type.d.ts" />
 
-import type { DataSource, DbDataSource, IncrementalMatch, LogStatus, TaskAction, ViewEngine } from './squared';
+import type { ChecksumValue, 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, DeleteObjectsOptions, UploadAssetOptions } from './cloud';
+import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudLogMessageType, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload, CopyObjectOptions, DeleteObjectsOptions, UploadAssetOptions } from './cloud';
 import type { BrotliCompressLevel, 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';
-import type { AssetContentOptions, ChecksumOptions, DeleteFileAddendum, FileOutput, FinalizeResult, FindAssetOptions, IHttpDiskCache, IHttpMemoryCache, ImageMimeMap, InstallData, PostFinalizeCallback, ReplaceOptions } from './filemanager';
+import type { AssetContentOptions, CheckHashOptions, 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, LogState, LogTime, LogType, LogValue, STATUS_TYPE, StatusType } from './logger';
-import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, FileTypeFormat, GlobDirOptions, MoveFileOptions, PackageVersionOptions, ParseFunctionOptions, PermissionOptions, PermissionType, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, TempDirOptions, WriteFileOptions } from './module';
-import type { HighResolutionTime, RequestData, Settings } from './node';
+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, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, 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 { Command, SpawnResult } from './task';
@@ -69,18 +69,18 @@ declare namespace functions {
         register(format: string, callback: TryFileCompressor): void;
         getLevel(value: string, fallback?: number): number | undefined;
         getReadable(file: string | URL | Buffer, options?: ReadableOptions): Readable;
-        createGzip(file: string | Buffer, options?: CompressLevel): Gzip;
-        createBrotliCompress(file: string | Buffer, options?: BrotliCompressLevel): BrotliCompress;
-        createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
-        createWriteStreamAsBrotli(file: string | Buffer, output: string, options?: BrotliCompressLevel): WriteStream;
+        createGzip(file: Bufferable, options?: CompressLevel): Gzip;
+        createBrotliCompress(file: Bufferable, options?: BrotliCompressLevel): BrotliCompress;
+        createWriteStreamAsGzip(file: Bufferable, output: string, options?: CompressLevel): WriteStream;
+        createWriteStreamAsBrotli(file: Bufferable, output: string, options?: BrotliCompressLevel): WriteStream;
         intoGzipStream(output: string, options?: ZlibOptions): WriteStream;
         intoBrotliStream(output: string, options?: BrotliOptions): WriteStream;
-        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>;
+        writeGzip(file: Bufferable, output: string, options?: CompressLevel): Promise<void>;
+        writeBrotli(file: Bufferable, output: string, options?: CompressLevel): Promise<void>;
+        tryFile(file: Bufferable, options: CompressFormat): Promise<BufferResult>;
+        tryFile(file: Bufferable, output: string, options?: CompressFormat): Promise<BufferResult>;
         tryImage(file: string, options: CompressFormat): Promise<BufferResult>;
-        tryImage(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
+        tryImage(file: Bufferable, output: string, options?: CompressFormat): Promise<BufferResult>;
         hasPermission(type: string, options?: unknown): boolean;
         set chunkSize(value: number | string | undefined);
         get chunkSize(): number | undefined;
@@ -175,6 +175,49 @@ declare namespace functions {
         get commandType(): SQL_COMMAND;
         set host(value);
         get host(): T | null;
+
+        /* 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: 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;
+        on(event: "file:move", listener: (dest: string, options?: MoveFileOptions) => void): this;
+        on(event: "file:permission", listener: (src: string, type?: FileActionType) => void): this;
+        on(event: "dir:create", listener: (src: string, options?: CreateDirOptions) => void): this;
+        on(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
+        on(event: "dir:permission", listener: (src: string, type?: DirectoryActionType) => 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: 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;
+        once(event: "file:move", listener: (dest: string, options?: MoveFileOptions) => void): this;
+        once(event: "file:permission", listener: (src: string, type?: FileActionType) => void): this;
+        once(event: "dir:create", listener: (src: string, options?: CreateDirOptions) => void): this;
+        once(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
+        once(event: "dir:permission", listener: (src: string, type?: DirectoryActionType) => void): this;
+        emit(event: "exec", command: ExecCommand, options?: SpawnOptions): boolean;
+        emit(event: "error", err: Error): 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;
+        emit(event: "file:move", dest: string, options?: MoveFileOptions): boolean;
+        emit(event: "file:permission", src: string, type?: FileActionType): boolean;
+        emit(event: "dir:create", src: string, options?: CreateDirOptions): boolean;
+        emit(event: "dir:remove", src: string, options?: RemoveDirOptions): boolean;
+        emit(event: "dir:permission", src: string, type?: DirectoryActionType): boolean;
+
+        /* EventEmitter */
+        on(event: "db:result", listener: (batch: V[], result: BatchQueryResult) => void): this;
+        on(event: "db:fail", listener: (err: unknown, item: V) => void): this;
+        once(event: "db:result", listener: (batch: V[], result: BatchQueryResult) => void): this;
+        once(event: "db:fail", listener: (err: unknown, item: V) => void): this;
+        emit(event: "db:result", batch: V[], result: BatchQueryResult): boolean;
+        emit(event: "db:fail", err: unknown, item: V): boolean;
     }
 
     interface DbConstructor<T extends IHost = IHost, U extends DbModule = DbModule, V extends DbDataSource = DbDataSource> extends ClientDbConstructor<T> {
@@ -194,8 +237,9 @@ declare namespace functions {
         setBucketWebsite(service: string, credential: unknown, bucket: string, options: BucketWebsiteOptions): Promise<boolean>;
         deleteObjects(service: string, credential: unknown, bucket: string, options: DeleteObjectsOptions): Promise<void>;
         deleteObjects(service: string, credential: unknown, bucket: string, recursive?: boolean | DeleteObjectsOptions): Promise<void>;
-        uploadObject(service: string, credential: unknown, bucket: string, upload: CloudStorageUpload, localUri: string, beforeResolve?: ((value: string) => Promise<void> | void)): Promise<string>;
-        downloadObject(service: string, credential: unknown, bucket: string, download: CloudStorageDownload, beforeResolve?: ((value: Bufferable | null) => Promise<string | undefined> | void)): Promise<Bufferable>;
+        copyObject(service: string, credential: unknown, bucketSource: string, keySource: string, bucket: string, key: string, options?: CopyObjectOptions): Promise<void>;
+        uploadObject(service: string, credential: unknown, bucket: string, upload: CloudStorageUpload, localUri: string, beforeResolve?: (value: string) => Promise<void> | void): Promise<string>;
+        downloadObject(service: string, credential: unknown, bucket: string, download: CloudStorageDownload, beforeResolve?: (value: Bufferable | null) => Promise<string | undefined> | void): Promise<Bufferable>;
         getStorage(action: CloudFunctions, data: CloudStorage[] | undefined): CloudStorage | undefined;
         hasStorage(action: CloudFunctions, storage: CloudStorage): CloudStorageUpload | false;
         getDatabaseRows(item: V, ignoreErrors: boolean, sessionKey?: string): Promise<QueryResult>;
@@ -216,6 +260,7 @@ declare namespace functions {
     }
 
     interface CloudConstructor<T extends IHost = IHost, U extends CloudModule = CloudModule, V extends CloudDatabase = CloudDatabase> extends ClientDbConstructor<T> {
+        LOG_CLOUD_SUCCESS: LogMessageOptions;
         LOG_CLOUD_FAIL: LogMessageOptions;
         LOG_CLOUD_COMMAND: LogMessageOptions;
         LOG_CLOUD_WARN: LogMessageOptions;
@@ -227,7 +272,9 @@ declare namespace functions {
         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>[];
+        uploadAssetSuccess<W extends IFileManager<X>, X extends ExternalAsset>(state: IScopeOrigin<W, ICloud<W>>, file: X, active?: boolean): (value: string) => Promise<void> | void;
         sanitizeAssets<W extends ExternalAsset>(assets: W[]): W[];
+        optionsLogMessage<W extends LogMessageOptions & LogFailOptions>(type: CloudLogMessageType, options?: W): W;
         readonly prototype: ICloud<T, U, V>;
         new(module?: U, database?: CloudDatabase[], ...args: unknown[]): ICloud<T, U, V>;
     }
@@ -239,7 +286,7 @@ declare namespace functions {
         init(assets: U[], config?: HostInitConfig): this;
         customize(options?: CustomizeDocument): void;
         findConfig(data: object, name: string, type?: string): PluginConfig;
-        loadConfig(data: object, name: string): Optional<ConfigOrTransformer>;
+        loadConfig(data: object, name: string): ConfigOrTransformer | undefined;
         asSourceFile(value: string, cache: boolean): unknown;
         asSourceFile(value: string, options?: AsSourceFileOptions): unknown;
         findVersion(name: string | string[], fallback?: string): string;
@@ -267,7 +314,7 @@ declare namespace functions {
         writeImage?(output: OutputFinalize<U>): boolean;
         cloudInit?(state: IScopeOrigin<T, Y>): void;
         cloudObject?(state: IScopeOrigin<T, Y>, file: U): boolean;
-        cloudUpload?(state: IScopeOrigin<T, Y>, file: U, url: string, active: boolean): Promise<boolean>;
+        cloudUpload?(state: IScopeOrigin<T, Y>, file: U, url: string, active?: boolean): Promise<boolean>;
         cloudFinalize?(state: IScopeOrigin<T, Y>): Promise<unknown[]>;
         watchInit?(watch: IFileGroup<U>, assets: U[], sanitize?: boolean): WatchInitResult | undefined;
         watchModified?(watch: IFileGroup<U>, assets?: U[], recursive?: [string, string[]][]): PostFinalizeCallback;
@@ -366,6 +413,8 @@ declare namespace functions {
         post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, form: AnyObject, parts: FormDataPart[]): Promise<DataObjectResult<V>>;
         post<V extends PostOptions>(uri: string | URL, data: unknown, options: V): Promise<DataObjectResult<V>>;
         post<V extends PostOptions>(uri: string | URL, data: unknown, contentType?: string | FormDataPart[] | V, options?: V): Promise<DataObjectResult<V>>;
+        get<V extends OpenOptions & { encoding: BufferEncoding }>(uri: string | URL, options: V): Promise<string>;
+        get<V extends BufferFormat>(uri: string | URL, format: V): Promise<object | null>;
         get<V extends OpenOptions, W extends V | BufferFormat>(uri: string | URL, options?: W): Promise<W extends BufferFormat ? object | null : DataEncodedResult<V>>;
         detach(singleton?: boolean): void;
         reset(adapter?: IHttpAdapter): void;
@@ -384,10 +433,6 @@ declare namespace functions {
         readTLSKey(value: string, cache?: boolean): string;
         readTLSCert(value: string, cache?: boolean): string;
         isCert(value: string): boolean;
-        /** @deprecated */
-        fromURL(url: URL, value: string): string;
-        /** @deprecated */
-        fromStatusCode(value: number | string): string;
         defineHttpAgent(options: HttpAgentSettings): void;
         defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
         isRclone(value: string | URL): boolean;
@@ -466,8 +511,12 @@ declare namespace functions {
         addDownload(value: number | Bufferable, encoding: BufferEncoding): number;
         addDownload(value: number | Bufferable, type?: number | BufferEncoding, encoding?: BufferEncoding): number;
         getDownload(type?: number): [number, number];
+        checkHash(checksum: ChecksumValue, options: CheckHashOptions): boolean;
+        checkHash(checksum: ChecksumValue, data: Bufferable | null, uri: string | URL | undefined): boolean;
+        checkHash(checksum: ChecksumValue, data: Bufferable, options?: CheckHashOptions): boolean;
         transformAsset(data: IFileThread<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>;
         getUTF8String(file: T, uri?: string): string;
         getBuffer<U>(file: T, minStreamSize?: U): U extends number ? Promise<Buffer | null> : Buffer | null;
@@ -498,6 +547,7 @@ declare namespace functions {
         finalizeChecksum(): Promise<void>;
         finalizeCleanup(): Promise<void>;
         finalize(): Promise<void>;
+        removeFiles(): void;
         close(): void;
         reset(): boolean;
         get baseDirectory(): string;
@@ -519,7 +569,6 @@ declare namespace functions {
         has(value: unknown): value is string;
 
         /* EventEmitter */
-        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: Bufferable, options?: ReadFileOptions) => void): this;
@@ -527,9 +576,10 @@ declare namespace functions {
         on(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         on(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
         on(event: "file:move", listener: (dest: string, options?: MoveFileOptions) => void): this;
+        on(event: "file:permission", listener: (src: string, type?: FileActionType) => void): this;
         on(event: "dir:create", listener: (src: string, options?: CreateDirOptions) => void): this;
         on(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
-        once(event: "end", listener: PostFinalizeCallback): this;
+        on(event: "dir:permission", listener: (src: string, type?: DirectoryActionType) => 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: Bufferable, options?: ReadFileOptions) => void): this;
@@ -537,9 +587,10 @@ declare namespace functions {
         once(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         once(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
         once(event: "file:move", listener: (dest: string, options?: MoveFileOptions) => void): this;
+        once(event: "file:permission", listener: (src: string, type?: FileActionType) => void): this;
         once(event: "dir:create", listener: (src: string, options?: CreateDirOptions) => void): this;
         once(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
-        emit(event: "end", result: FinalizeResult): boolean;
+        once(event: "dir:permission", listener: (src: string, type?: DirectoryActionType) => void): this;
         emit(event: "exec", command: ExecCommand, options?: SpawnOptions): boolean;
         emit(event: "error", err: Error): boolean;
         emit(event: "file:read", src: string, data: Bufferable, options?: ReadFileOptions): boolean;
@@ -547,8 +598,17 @@ declare namespace functions {
         emit(event: "file:delete", src: string, options?: DeleteFileOptions): boolean;
         emit(event: "file:copy", dest: string, options?: CopyFileOptions): boolean;
         emit(event: "file:move", dest: string, options?: MoveFileOptions): boolean;
+        emit(event: "file:permission", src: string, type?: FileActionType): boolean;
         emit(event: "dir:create", src: string, options?: CreateDirOptions): boolean;
         emit(event: "dir:remove", src: string, options?: RemoveDirOptions): boolean;
+        emit(event: "dir:permission", src: string, type?: DirectoryActionType): boolean;
+
+        on(event: "end", listener: PostFinalizeCallback): this;
+        on(event: "asset:permission", listener: (file: T) => void): this;
+        once(event: "end", listener: PostFinalizeCallback): this;
+        once(event: "asset:permission", listener: (file: T) => void): this;
+        emit(event: "end", result: FinalizeResult): boolean;
+        emit(event: "asset:permission", file: T): boolean;
     }
 
     interface FileManagerConstructor<T extends ExternalAsset> extends HostConstructor {
@@ -687,9 +747,7 @@ declare namespace functions {
         checkFail(message: unknown, options: LogFailOptions): LogArguments | false | undefined;
         writeLog(component: LogComponent, queue?: boolean): void;
         writeLog(type: StatusType, value: unknown, options: LogOptions): void;
-        writeLog(type: StatusType, value: unknown, from: string, source?: string): void;
-        writeLog(type: StatusType, value: unknown, timeStamp?: LogDate, from?: string, source?: string): void;
-        writeLog(type: StatusType, value: unknown, timeStamp?: LogDate, duration?: number, from?: string, source?: string): 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;
@@ -734,8 +792,10 @@ declare namespace functions {
         on(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         on(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
         on(event: "file:move", listener: (dest: string, options?: MoveFileOptions) => void): this;
+        on(event: "file:permission", listener: (src: string, type?: FileActionType) => void): this;
         on(event: "dir:create", listener: (src: string, options?: CreateDirOptions) => void): this;
         on(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
+        on(event: "dir:permission", listener: (src: string, type?: DirectoryActionType) => 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: Bufferable, options?: ReadFileOptions) => void): this;
@@ -743,8 +803,10 @@ declare namespace functions {
         once(event: "file:delete", listener: (src: string, options?: DeleteFileOptions) => void): this;
         once(event: "file:copy", listener: (dest: string, options?: CopyFileOptions) => void): this;
         once(event: "file:move", listener: (dest: string, options?: MoveFileOptions) => void): this;
+        once(event: "file:permission", listener: (src: string, type?: FileActionType) => void): this;
         once(event: "dir:create", listener: (src: string, options?: CreateDirOptions) => void): this;
         once(event: "dir:remove", listener: (src: string, options?: RemoveDirOptions) => void): this;
+        once(event: "dir:permission", listener: (src: string, type?: DirectoryActionType) => void): this;
         emit(event: "exec", command: ExecCommand, options?: SpawnOptions): boolean;
         emit(event: "error", err: Error): boolean;
         emit(event: "file:read", src: string, data: Bufferable, options?: ReadFileOptions): boolean;
@@ -752,8 +814,10 @@ declare namespace functions {
         emit(event: "file:delete", src: string, options?: DeleteFileOptions): boolean;
         emit(event: "file:copy", dest: string, options?: CopyFileOptions): boolean;
         emit(event: "file:move", dest: string, options?: MoveFileOptions): boolean;
+        emit(event: "file:permission", src: string, type?: FileActionType): boolean;
         emit(event: "dir:create", src: string, options?: CreateDirOptions): boolean;
         emit(event: "dir:remove", src: string, options?: RemoveDirOptions): boolean;
+        emit(event: "dir:permission", src: string, type?: DirectoryActionType): boolean;
     }
 
     interface ModuleConstructor<T extends IHost = IHost> {
@@ -789,10 +853,11 @@ declare namespace functions {
         hasLogType(value: LogType): boolean;
         isURL(value: string, ...exclude: string[]): boolean;
         isFile(value: string | URL, type?: ProtocolType): boolean;
-        isDir(value: string | URL): boolean;
+        isDir(value: string | URL, absolute?: boolean): boolean;
         isPath(value: string | URL, type?: "unc" | "unc-exists"): boolean;
         isPath(value: string | URL, isFile?: boolean): boolean;
-        isErrorCode(err: unknown, ...code: string[]): boolean;
+        /** @deprecated @e-mc/types */
+        isErrorCode<U extends unknown[]>(err: unknown, ...code: U): err is Required<ErrorCode<U[number]>>;
         fromLocalPath(value: string): string;
         resolveFile(value: string): string;
         resolvePath(value: string, base: string | URL): string;

package/lib/module.d.ts

@@ -141,4 +141,6 @@ export type ReadTextOptions = ReadBufferOptions;
 export type ReadFileCallback<T extends Bufferable = Bufferable> = (err: NodeJS.ErrnoException | null, data?: T) => void;
 export type ProtocolType = "http" | "https" | "http/s" | "ftp" | "sftp" | "s/ftp" | "torrent" | "unc" | "file";
 export type PermissionType = "fs" | "memory" | "memory.user" | "worker";
+export type FileActionType = "read" | "write" | "delete" | "copy" | "move";
+export type DirectoryActionType = "create" | "remove";
 export type FileTypeFormat = Bufferable | Uint8Array | ArrayBuffer | Readable;

package/lib/node.d.ts

@@ -21,8 +21,8 @@ export interface Settings {
     logger?: LoggerModule;
 }
 
-export interface ErrorCode extends Error {
-    code?: unknown;
+export interface ErrorCode<T = unknown> extends Error {
+    code?: T;
 }
 
 export type HighResolutionTime = bigint | [number, number];

package/lib/request.d.ts

@@ -4,6 +4,7 @@ import type { IRequest } from './index';
 import type { BinaryAction } from './asset';
 import type { HeadersAction, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
 import type { IncludeAction } from './module';
+import type { ErrorCode } from './node';
 import type { HttpHostSettings, RequestModule } from './settings';
 
 import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'node:http';
@@ -115,10 +116,11 @@ export interface IHttpAdapter<T extends OpenOptions = OpenOptions> {
 }
 
 export interface HttpAdapterConstructor<T extends OpenOptions = OpenOptions> {
+    constructorOf<U extends HttpAdapterConstructor>(value: unknown): value is U;
     isUnsupported(value: number): boolean;
     isDowngrade(err: unknown): err is Error;
     wasAborted(err: unknown): err is Error;
-    isConnectionError(err: unknown): err is Error;
+    isConnectionError(err: unknown): err is Required<ErrorCode<string>>;
     defineHostConfig(settings: RequestModule): void;
     readonly prototype: IHttpAdapter<T>;
     new(instance: IRequest, state: ControllerState, uri: string | URL, options: T): IHttpAdapter<T>;
@@ -142,7 +144,7 @@ export interface OpenOptions extends KeepAliveAction, SilentAction, EncodingActi
     timeout?: number;
     pipeTo?: string | Writable;
     postData?: unknown;
-    connected?: ((headers: IncomingHttpHeaders) => boolean | void);
+    connected?: (headers: IncomingHttpHeaders) => boolean | void;
     trailers?: (headers: IncomingHttpHeaders) => void;
     statusMessage?: string;
     progressId?: number | string;

package/lib/settings.d.ts

@@ -141,7 +141,12 @@ export interface DownloadModule<T = PlainObject> extends HandlerSettings<T> {
         /* Copy */
         check_first?: boolean;
         checksum?: boolean;
+        combined?: string;
+        csv?: boolean;
+        differ?: string;
+        error?: string;
         cutoff_mode?: "HARD" | "SOFT" | "CAUTIOUS";
+        hash: "md5" | "SHA-1" | "DropboxHash";
         ignore_case_sync?: boolean;
         ignore_checksum?: boolean;
         ignore_existing?: boolean;
@@ -161,8 +166,10 @@ export interface DownloadModule<T = PlainObject> extends HandlerSettings<T> {
         no_check_dest?: boolean;
         no_traverse?: boolean;
         no_update_dir_modtime?: boolean;
+        no_update_modtime?: boolean;
         refresh_times?: boolean;
         size_only?: boolean;
+        streaming_upload_cutoff?: string;
         update?: boolean;
         /* Listing */
         fast_list?: boolean;
@@ -234,10 +241,13 @@ export interface MemoryModule<T = MemorySettings> extends HandlerSettings<T>, Re
 
 export interface MemorySettings extends PlainObject {
     users?: boolean | string[];
+    stats?: {
+        file_count?: boolean;
+    };
     cache_disk?: MemoryCacheDiskSettings;
 }
 
-export interface MemoryCacheDiskSettings<T = number | string> extends IncludeAction<string[] | null> {
+export interface MemoryCacheDiskSettings<T = number | string, U = string[] | null> extends IncludeAction<U> {
     enabled?: boolean;
     min_size?: T;
     max_size?: T;
@@ -354,7 +364,8 @@ export interface CompressModule<U = CompressSettings> extends HandlerSettings<U>
 }
 
 export interface CompressSettings extends PlainObject {
-    cache?: boolean;
+    cache?: boolean | CacheDirAction & ObjectMap<number | string | boolean>;
+    /** @deprecated cache.expires */
     cache_expires?: number | string;
     gzip_level?: number | string;
     brotli_quality?: number | string;
@@ -535,8 +546,15 @@ export interface PurgeAction {
     purge?: PurgeComponent;
 }
 
+export interface CacheDirAction {
+    enabled?: boolean;
+    dir?: string;
+    expires?: number | string;
+}
+
 export interface PoolConfig<T = number> extends MinMax {
     idle?: T;
+    idle_max?: number;
     queue_max?: number;
     queue_idle?: T;
     purge?: T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/types",
-  "version": "0.12.9",
+  "version": "0.13.1",
   "description": "Type definitions for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -23,6 +23,6 @@
     "chalk": "4.1.2"
   },
   "devDependencies": {
-    "typescript": "5.8.3"
+    "typescript": "5.9.3"
   }
 }