@e-mc/types 0.8.7 → 0.9.0

package/lib/cloud.d.ts

@@ -1,6 +1,7 @@
 import type { DbDataSource, LocationUri, StorageAction } from './squared';
 
 import type { ExternalAsset, StreamAction } from './asset';
+import type { ExecuteAction } from './db';
 
 export interface UploadAction {
     cloudUrl?: string;
@@ -8,42 +9,47 @@ export interface UploadAction {
 
 export interface CloudAsset<T = CloudStorage> extends ExternalAsset, UploadAction, StorageAction<T> {}
 
-export interface CloudService {
-    service: string;
-    credential?: unknown;
+export interface CloudService<T = unknown, U = string> {
+    service: U;
+    credential?: T;
 }
 
-export interface CloudDatabase<T = unknown, U = PlainObject, V = unknown, W = unknown> extends CloudService, DbDataSource<T, U, V> {
+export interface CloudDatabase<T = unknown, U = PlainObject, V = unknown, W = unknown, X = unknown> extends CloudService<X>, Omit<DbDataSource<T, U, V>, "credential" | "parallel" | "withCommand" | "usePool">, ExecuteAction<W> {
     id?: string;
-    params?: W;
 }
 
-export interface CloudStorage extends CloudService {
+export interface CloudStorage<T = unknown, U = string> extends CloudService<T, U> {
     bucket?: string;
     admin?: CloudStorageAdmin;
     upload?: CloudStorageUpload;
     download?: CloudStorageDownload;
 }
 
-export interface CloudStorageAdmin<T = unknown, U = string, V = unknown, W = unknown> extends CloudStorageACL<U> {
+export interface CloudStorageAdmin<T = unknown, U = string, V = unknown, W = unknown, X = unknown, Y = unknown> extends CloudStorageACL<U> {
     emptyBucket?: boolean;
     configBucket?: {
         create?: T;
         policy?: V;
+        tags?: unknown;
         website?: BucketWebsiteOptions;
         retentionPolicy?: W;
+        cors?: X;
+        lifecycle?: Y;
     };
     recursive?: boolean;
     preservePath?: boolean;
 }
 
-export interface CloudStorageAction<T = unknown, U = string, V = unknown, W = unknown> extends Partial<LocationUri>, StreamAction {
+export interface CloudStorageAction<T = unknown, U = string, V = unknown, W = unknown, X = unknown, Y = unknown> extends Partial<LocationUri>, StreamAction {
     active?: boolean;
     overwrite?: boolean;
-    admin?: CloudStorageAdmin<T, U, V, W>;
+    chunkSize?: NumString;
+    chunkLimit?: number;
+    flags?: number;
+    admin?: CloudStorageAdmin<T, U, V, W, X, Y>;
 }
 
-export interface CloudStorageUpload<T = unknown, U = string, V = unknown, W = string, X = unknown> extends CloudStorageACL<U>, CloudStorageAction<V, W, unknown, X> {
+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> {
     buffer?: Null<Buffer>;
     contentType?: string;
     metadata?: Record<string, string>;
@@ -60,8 +66,10 @@ export interface CloudStorageACL<T = string> {
     acl?: T;
 }
 
-export interface CloudStorageDownload<T = unknown> extends CloudStorageAction {
+export interface CloudStorageDownload<T = unknown, U = unknown> extends CloudStorageAction {
+    keyname?: string;
     versionId?: string;
+    options?: U;
     deleteObject?: T;
     waitStatus?: boolean;
 }
@@ -73,20 +81,27 @@ export interface BucketWebsiteOptions {
     errorPath?: string;
 }
 
-export interface UploadData<T = unknown, U = string, V = unknown, W = string, X = unknown> extends BucketAction {
-    upload: CloudStorageUpload<T, U, V, W, X>;
+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>;
     localUri: string;
     buffer: Buffer;
 }
 
-export interface DownloadData<T = unknown> extends BucketAction {
-    download: CloudStorageDownload<T>;
+export interface DownloadData<T = unknown, U = unknown> extends BucketAction {
+    download: CloudStorageDownload<T, U>;
 }
 
 export interface BucketAction {
     bucket: string;
 }
 
-export type UploadContent = [BufferContent, string, string?];
+export interface UploadAssetOptions {
+    contentType?: string;
+    ignoreProcess?: boolean;
+    preferBuffer?: boolean;
+}
+
+export type UploadContent = [Bufferable, string, string?];
+export type CloudSource = "atlas" | "aws" | "aws-v3" | "az" | "azure" | "gcp" | "gcloud" | "ibm" | "oci" | "minio";
 export type CloudFeatures = "storage" | "database";
 export type CloudFunctions = "upload" | "download";

package/lib/compat-v4.d.ts

@@ -1,6 +1,6 @@
-import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IImage, IModule, ImageConstructor, ModuleConstructor, WatchConstructor } from './index';
+import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IModule, ModuleConstructor, WatchConstructor } from './index';
 
-import type { ExternalAsset, IFileThread } from './asset';
+import type { ExternalAsset } from './asset';
 import type { CacheOptions } from './core';
 import type { QueryResult } from './db';
 import type { ITransformSeries, OutV3, TransformSeriesConstructor } from './document';
@@ -9,14 +9,11 @@ import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, Interne
 import type { CloneObjectOptions, GetFunctionsOptions } from './module';
 import type { LogFailOptions, LogType, LogValue } from './logger';
 import type { HostConfig, OpenOptions, ProxySettings } from './request';
-import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings, ImageModule } from './settings';
+import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings } from './settings';
 
-import type { Readable, Writable } from 'stream';
 import type { OutgoingHttpHeaders } from 'http';
 import type { LookupFunction } from 'net';
-
-// @ts-ignore
-import type { BytesOptions } from 'bytes';
+import type { Readable, Writable } from 'stream';
 
 type CpuUsage = NodeJS.CpuUsage;
 
@@ -36,13 +33,13 @@ export interface IModuleLibV4 {
     toTimeMs(hrtime: HighResolutionTime, format?: boolean): NumString;
     renameExt(value: string, ext: string, when?: string): string;
     existsSafe(value: string, isFile?: boolean): boolean;
-    readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<BufferContent>;
+    readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<Bufferable>;
     getFunctions<T extends FunctionType>(values: unknown[], absolute?: boolean | GetFunctionsOptions, sync?: boolean, outFailed?: string[]): T[];
-    formatSize(value: NumString, options?: BytesOptions): NumString;
+    formatSize(value: NumString, options?: PlainObject): NumString;
     hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
     hasSize(value: string, keepEmpty?: boolean): boolean;
     getSize(value: string, diskUsed?: boolean): number;
-    byteLength(value: BufferContent, encoding?: BufferEncoding): number;
+    byteLength(value: Bufferable, encoding?: BufferEncoding): number;
     cleanupStream(target: Readable | Writable, pathname?: string): void;
     allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseSettledResult<U>[]>;
 }
@@ -91,10 +88,6 @@ export interface FileManagerCompatV4Constructor<T extends ExternalAsset = Extern
     new(...args: unknown[]): IFileManagerCompatV4<T>;
 }
 
-export interface ImageCompatV4Constructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ImageConstructor<T, U> {
-    using<V extends ExternalAsset>(this: T, instance: IImage<T, U>, data: IFileThread<V>, command: string): Promise<unknown>;
-}
-
 export interface ICloudCompatV4<T extends IHost = IHost> extends ICloud<T> {
     getDatabaseResult(service: string, credential: unknown, queryString: string, options?: CacheOptions | boolean | string): Undef<QueryResult>;
     setDatabaseResult(service: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;

package/lib/compress.d.ts

@@ -7,6 +7,8 @@ interface CompressFormat extends ICompressFormat, LogBaseOptions {
     startTime?: LogTime;
     etag?: string;
     proxyUrl?: string | ((uri: string) => Undef<string>);
+    outExt?: string;
+    outFile?: string;
 }
 
 interface Woff {
@@ -18,8 +20,6 @@ type ResultCallback<T = Null<Buffer | Uint8Array>> = (err: unknown, data?: T, ex
 type ResultData = Null<Buffer | Uint8Array> | string;
 
 export type BufferLike = Buffer | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly number[];
-export type TryFileCompressor = (data: string | Buffer, output: string, config: CompressFormat, callback?: TryFileResult) => Void<Promise<ResultData>>;
+export type TryFileCompressor = (data: string | Buffer, output: string, config: CompressFormat, callback?: ResultCallback<ResultData>) => Void<Promise<ResultData>>;
 export type TryFileCompressorAsync = (data: string | Buffer, output: string, config: CompressFormat) => Promise<ResultData>;
-export type TryFileResult = ResultCallback<ResultData>;
-export type TryImageResult = ResultCallback;
 export type BufferResult = Null<Buffer | Uint8Array>;

package/lib/core.d.ts

@@ -4,14 +4,20 @@ import type { DataSource, RequestBase } from './squared';
 
 import type { IExternalConfig, IExternalFunction, IHost, IModule, ModuleConstructor } from './index';
 import type { QueryResult, TimeoutAction } from './db';
-import type { AddEventListenerOptions } from './dom';
 import type { Settings } from './node';
-import type { ClientDbSettings, ClientModule, DbCacheValue, DbCoerceSettings, DbCoerceValue, DbSourceOptions } from './settings';
+import type { ClientDbSettings, ClientModule, DbCacheValue, DbCoerceSettings, DbSourceOptions } from './settings';
 
 export interface IdentifierAction {
     uuidKey?: string;
 }
 
+export interface AddEventListenerOptions {
+    capture?: boolean;
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
+
 export interface IClient<T extends IHost, U extends ClientModule, V extends FunctionType<any, any> = FunctionType> extends IModule<T>, IExternalConfig<U, U extends ClientModule<infer W> ? W : unknown>, IExternalFunction<V> {
     init(...args: unknown[]): this;
     getUserSettings<X>(): Null<X>;
@@ -28,14 +34,13 @@ export interface IClientDb<T extends IHost, U extends ClientModule<ClientDbSetti
     database: V[];
     cacheExpires: number;
     add(item: V, state?: number): void;
-    hasCache(source: string, sessionKey?: string, override?: DbCacheValue): boolean;
+    hasCache(source: string, sessionKey?: string): boolean;
     hasCoerce(source: string, component: keyof DbCoerceSettings, uuidKey: Undef<string>): boolean;
-    hasCoerce(source: string, component: keyof DbCoerceSettings, override: Optional<DbCoerceValue>, credential?: unknown): boolean;
     hasCoerce(source: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
     getQueryResult(source: string, credential: unknown, queryString: string, renewCache: boolean): Undef<QueryResult>;
-    getQueryResult(source: string, credential: unknown, queryString: string, sessionKey: string, renewCache?: boolean): Undef<QueryResult>;
+    getQueryResult(source: string, credential: unknown, queryString: string, sessionKey?: string, renewCache?: boolean): Undef<QueryResult>;
     getQueryResult(source: string, credential: unknown, queryString: string, options?: CacheOptions | string, renewCache?: boolean): Undef<QueryResult>;
-    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, sessionKey: Undef<string>): QueryResult;
+    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, sessionKey?: string): QueryResult;
     setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
     applyState(items: ArrayOf<V>, value: number, as?: boolean): void;
     commit(items?: V[]): Promise<boolean>;
@@ -86,14 +91,14 @@ export interface AbortComponentConstructor {
 }
 
 export interface IPermission {
-    setDiskRead(pathname?: StringOfArray, enabled?: boolean): void;
-    setDiskWrite(pathname?: StringOfArray, enabled?: boolean): void;
-    setUNCRead(pathname?: StringOfArray, enabled?: boolean): void;
-    setUNCWrite(pathname?: StringOfArray, enabled?: boolean): void;
-    getDiskRead(): StringOfArray;
-    getDiskWrite(): StringOfArray;
-    getUNCRead(): StringOfArray;
-    getUNCWrite(): StringOfArray;
+    setDiskRead(pathname?: ArrayOf<string>, enabled?: boolean): void;
+    setDiskWrite(pathname?: ArrayOf<string>, enabled?: boolean): void;
+    setUNCRead(pathname?: ArrayOf<string>, enabled?: boolean): void;
+    setUNCWrite(pathname?: ArrayOf<string>, enabled?: boolean): void;
+    getDiskRead(): ArrayOf<string>;
+    getDiskWrite(): ArrayOf<string>;
+    getUNCRead(): ArrayOf<string>;
+    getUNCWrite(): ArrayOf<string>;
     hasDiskRead(pathname: string): boolean;
     hasDiskWrite(pathname: string): boolean;
     hasUNCRead(pathname: string): boolean;
@@ -109,8 +114,8 @@ export interface PermissionConstructor {
     create(settings: PermittedDirectories, parent: Null<IPermission>, freeze?: boolean): Null<IPermission>;
     validate(settings: unknown): settings is PermittedDirectories;
     clone(permission: IPermission, freeze?: boolean): IPermission;
-    match(pathname: string, pattern: StringOfArray): boolean;
-    toPosix(value: unknown): StringOfArray;
+    match(pathname: string, pattern: ArrayOf<string>): boolean;
+    toPosix(value: unknown): ArrayOf<string>;
     readonly prototype: IPermission;
     new(freeze?: boolean): IPermission;
 }
@@ -134,11 +139,12 @@ export interface HostInitConfig extends PlainObject, RequestBase<HostInitLog> {
 export interface HostInitLog {
     enabled?: boolean;
     level?: NumString;
-    exclude?: StringOfArray;
+    exclude?: ArrayOf<string>;
     useColor?: boolean;
+    showProgress?: boolean;
 }
 
-export interface PermittedDirectories extends PermissionReadWrite<StringOfArray> {
+export interface PermittedDirectories extends PermissionReadWrite<ArrayOf<string>> {
     inherit?: boolean;
 }
 
@@ -161,7 +167,7 @@ export interface ThreadInfo {
     startTime: number;
     username?: string;
     sessionId?: string;
-    broadcastId?: StringOfArray;
+    broadcastId?: ArrayOf<string>;
 }
 
 export interface ThreadCountStat {

package/lib/db.d.ts

@@ -86,15 +86,6 @@ export interface DbPoolConstructor<T extends DbDataSource = DbDataSource, U = un
     new(pool: U, poolKey: string, uuidKey?: Null<AuthValue>): IDbPool<T, U, V>;
 }
 
-export interface PoolConfig<T = number> extends MinMax {
-    idle?: T;
-    queue_max?: number;
-    queue_idle?: T;
-    purge?: T;
-    timeout?: number;
-    socket_timeout?: number;
-}
-
 export interface TimeoutAction {
     timeout?: NumString;
 }

package/lib/filemanager.d.ts

@@ -1,6 +1,6 @@
 import type { BundleAction, ChecksumOutput, FileInfo, LogStatus } from './squared';
 
-import type { IFileManager, IModule, ModuleConstructor } from './index';
+import type { IFileManager, IImage, IModule, ImageConstructor, ModuleConstructor } from './index';
 import type { ExternalAsset } from './asset';
 import type { HostInitLog as IHostInitLog } from './core';
 import type { ReadHashOptions } from './module';
@@ -60,7 +60,7 @@ export interface IHttpMemoryCache<T extends ExternalAsset = ExternalAsset> exten
 }
 
 export interface HttpDiskCacheAddOptions {
-    buffer?: Null<BufferContent>;
+    buffer?: Null<Bufferable>;
     contentLength?: number;
 }
 
@@ -117,5 +117,6 @@ export interface ChecksumOptions extends ReadHashOptions, Pick<ChecksumOutput, "
     throwsEmpty?: 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/http.d.ts

@@ -2,6 +2,7 @@ import type { LookupAddress } from 'dns';
 import type { ClientRequest, Agent as HttpAgent, OutgoingHttpHeaders } from 'http';
 import type { Agent as HttpsAgent } from 'https';
 import type { ClientHttp2Stream } from 'http2';
+import type { SecureVersion } from 'tls';
 
 export const enum HTTP_STATUS {
     CONTINUE = 100,
@@ -87,6 +88,25 @@ export interface HttpAgentSettings {
     timeout?: number;
 }
 
+export interface SecureConfig<T = string, U = T> {
+    ca?: T;
+    key?: U;
+    cert?: T;
+    passphrase?: U;
+    version?: SecureVersion;
+}
+
+export interface ServerPort<T = NumString> {
+    port?: T;
+}
+
+export interface ServerSecure extends SecureConfig, ServerPort {}
+
+export interface AuthValue {
+    username?: string;
+    password?: string;
+}
+
 export type HttpRequestClient = ClientRequest | ClientHttp2Stream;
 export type HttpOutgoingHeaders = ObjectMap<OutgoingHttpHeaders>;
 export type HttpProtocolVersion = 1 | 2 | 3;