@e-mc/types 0.0.1

package/lib/db.d.ts

@@ -0,0 +1,264 @@
+import type { DataSource, DbDataSource } from './squared';
+
+import type { CacheOptions, IdentifierAction } from './core';
+
+import type { DB_TYPE } from '../index.d';
+
+import type { SecureContextOptions } from 'tls';
+
+// @ts-ignore
+import type { AggregateOptions, BulkWriteOptions, CollectionOptions, CommandOperationOptions, DbOptions, Document, Filter, MongoClientOptions, OptionalUnlessRequiredId, Sort, SortDirection, UpdateFilter } from 'mongodb';
+// @ts-ignore
+import type { CommandOptions } from '@redis/client/dist/lib/command-options';
+// @ts-ignore
+import type { ClientCommandOptions } from '@redis/client/dist/lib/client';
+// @ts-ignore
+import type { RedisClientOptions } from '@redis/client';
+// @ts-ignore
+import type { RedisCommandArgument } from '@redis/client/dist/lib/commands';
+// @ts-ignore
+import type { RedisJSON } from '@redis/json/dist/commands';
+// @ts-ignore
+import type { RediSearchSchema } from 'redis';
+// @ts-ignore
+import type { PoolOptions, QueryOptions } from 'mysql2/promise';
+// @ts-ignore
+import type { PoolConfig as PostgresPoolConfig, QueryArrayConfig } from 'pg';
+// @ts-ignore
+import type { BindParameters, ConnectionAttributes, ExecuteOptions, PoolAttributes } from 'oracledb';
+// @ts-ignore
+import type { ConnectionConfig as IConnectionConfig, ParameterOptions, TediousType, TediousTypes } from 'tedious';
+// @ts-ignore
+import type { PoolConfig as MSSQLPoolConfig } from 'tedious-connection-pool';
+
+interface ExecuteAction<T = unknown> {
+    params?: T;
+}
+
+export interface CascadeAction {
+    cascade?: string;
+    cacheObjectKey?: string;
+    fallback?: unknown;
+}
+
+export interface MongoDBDataSource extends DbDataSource<Filter<Document> | MongoDBQueryWithOptions, MongoClientOptions, UpdateFilter<Document> | OptionalUnlessRequiredId<unknown>[], string | MongoDBCredential, string>, MongoDBClientDBOptions, CascadeAction {
+    source: "mongodb";
+    id?: string;
+    updateType?: 0 | 1 | 2 | 3;
+}
+
+export interface RedisDataSource extends DbDataSource<string, PlainObject, ArrayOf<RedisSetValue> | ArrayOf<RedisJSONValue>, string | RedisCredential, string>, CascadeAction, AuthValue {
+    source: "redis";
+    key?: ArrayOf<RedisCommandArgument>;
+    field?: RedisCommandArgument;
+    path?: string;
+    format?: RedisFormat | "HKEYS" | "HVALS";
+    search?: {
+        index?: string;
+        schema?: RediSearchSchema | string;
+        query?: string;
+        options?: PlainObject;
+    };
+    options?: {
+        client?: RedisClientOptions;
+        get?: PlainObject;
+        command?: RedisCommandOptions;
+    };
+    database?: number;
+}
+
+export interface MySQLDataSource<T = unknown> extends DbDataSource<string | QueryOptions, unknown, unknown, string | MySQLCredential, string>, ExecuteAction<T> {
+    source: "mysql";
+}
+
+export interface PostgresDataSource<T = unknown[]> extends DbDataSource<string | QueryArrayConfig, unknown, unknown, string | PostgresCredential, string>, ExecuteAction<T> {
+    source: "postgres";
+}
+
+export interface OracleDataSource extends DbDataSource<string, ExecuteOptions, unknown, string | OracleCredential, string>, ExecuteAction<BindParameters> {
+    source: "oracle";
+}
+
+export interface MSSQLDataSource extends DbDataSource<string, unknown, unknown, string | MSSQLCredential, string | MSSQLPoolConfig>, ExecuteAction<MSSQLRequestParameters | MSSQLRequestWithOutputParameters> {
+    source: "mssql";
+    storedProc?: boolean;
+}
+
+export interface MongoDBCredential extends ServerAuth, Pick<MongoClientOptions, "auth" | "authMechanism" | "authSource" | "tlsCAFile" | "tlsCertificateFile" | "tlsCertificateKeyFile" | "tlsCertificateKeyFilePassword" | "sslCA" | "sslKey" | "sslCert"> {}
+
+export type RedisCredential = ServerAuth;
+
+export interface MySQLCredential extends ServerAuth, Omit<PoolOptions, "ssl"> {
+    ssl?: boolean | string | SecureContextOptions & { rejectUnauthorized?: boolean };
+}
+
+export interface PostgresCredential extends Omit<ServerAuth, "password">, PostgresPoolConfig {}
+
+export interface OracleCredential extends ServerAuth, ConnectionAttributes, PoolAttributes {}
+
+export interface MSSQLCredential extends ServerAuth, IConnectionConfig {}
+
+export interface MongoDBSortValue {
+    value?: Sort;
+    direction?: SortDirection;
+}
+
+export interface MongoDBAggregate {
+    pipeline?: Document[];
+    options?: AggregateOptions;
+}
+
+export interface MongoDBClientDBOptions {
+    client?: {
+        db?: DbOptions;
+        collection?: CollectionOptions;
+    };
+    execute?: {
+        insert?: BulkWriteOptions;
+    };
+    aggregate?: MongoDBAggregate;
+    sort?: Sort | string | MongoDBSortValue;
+}
+
+export interface MongoDBQueryWithOptions {
+    value: Filter<Document>;
+    options: CommandOperationOptions;
+}
+
+export interface RedisSetValue<T = "HASH" | undefined, U = RedisCommandArgument, V = RedisCommandValue | RedisHSETObject> {
+    format: T;
+    key?: U;
+    field?: V;
+    value?: V;
+    NX?: boolean;
+    XX?: boolean;
+    EX?: number;
+    PX?: number;
+    EXAT?: number;
+    PXAT?: number;
+    options?: {
+        set?: PlainObject;
+        expire?: { [K in RedisExpireCondition]?: boolean; };
+        command?: RedisCommandOptions;
+    };
+}
+
+export interface RedisJSONValue extends Omit<RedisSetValue<"JSON", string, RedisJSON>, "field" | "EX" | "PX" | "EXAT" | "PXAT"> {
+    path?: string;
+}
+
+export interface MSSQLRequestWithOutputParameters {
+    input?: MSSQLRequestParameters;
+    output?: MSSQLRequestParameters;
+}
+
+export interface MSSQLRequestParameterValue {
+    name?: string;
+    value?: unknown;
+    type?: keyof TediousTypes | TediousType;
+    options?: ParameterOptions;
+}
+
+export interface ExecuteQueryOptions {
+    checkObject?: CheckObjectCallback | string;
+    checkObjectKey?: string;
+    errorQuery?: ErrorQueryCallback;
+    sessionKey?: string;
+    outCacheMiss?: string[];
+}
+
+export interface ExecuteBatchQueryOptions extends ExecuteQueryOptions {
+    parallel?: boolean;
+    connectOnce?: boolean;
+}
+
+export interface ProcessRowsOptions {
+    disconnect?: () => void;
+    parallel?: boolean;
+}
+
+export interface DbConnection {
+    hostname: string;
+    password: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    username: string;
+    database: string;
+}
+
+export interface HandleFailOptions {
+    commandType?: number;
+    errorQuery?: ErrorQueryCallback;
+}
+
+export interface ServerAuth<T = number> extends AuthValue, IdentifierAction {
+    protocol?: string;
+    server?: string;
+    hostname?: string;
+    port?: T;
+    database?: string;
+}
+
+export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V = unknown> {
+    client: U;
+    lastAccessed: number;
+    success: number;
+    failed: number;
+    poolKey: string;
+    uuidKey: Null<AuthValue>;
+    add(item: T, uuidKey?: string): this;
+    has(item: T): boolean;
+    getConnection(): Promise<V>;
+    remove(): void;
+    detach(force?: boolean): Promise<void>;
+    close(): Promise<void>;
+    isIdle(timeout: number): boolean;
+    isEmpty(): boolean;
+    set connected(value: boolean);
+    get persist(): boolean;
+    get closed(): boolean;
+    get closeable(): boolean;
+    set parent(value: ObjectMap<IDbPool<T>>);
+}
+
+export interface DbPoolConstructor<T extends DbDataSource = DbDataSource, U = unknown> {
+    findKey<V extends IDbPool, W extends DbDataSource>(pools: ObjectMap<V>, uuidKey: unknown, poolKey: Undef<string>, ...items: W[]): Null<V>;
+    validateKey<V extends IDbPool>(pools: ObjectMap<V>, username: string, uuidKey: unknown): [string, Null<V>];
+    checkTimeout<V extends IDbPool>(pools: ObjectMap<V>, value: number, limit?: number): Promise<number>;
+    readonly prototype: IDbPool<T, U>;
+    new(pool: U, poolKey: string, uuidKey?: string): IDbPool<T, U>;
+}
+
+export interface PoolConfig<T = number> extends MinMax {
+    idle?: T;
+    queue_max?: number;
+    queue_idle?: T;
+    purge?: T;
+}
+
+export interface TimeoutAction {
+    timeout?: NumString;
+}
+
+export type DbSource = "mongodb" | "redis" | "mysql" | "postgres" | "oracle" | "mssql";
+export type QueryResult = unknown[];
+export type BatchQueryResult = Null<QueryResult>[];
+export type CheckObjectCallback = (item: DataSource, data: unknown) => Null<QueryResult>;
+export type RedisFormat = "HASH" | "JSON";
+export type RedisExpireCondition = "NX" | "XX" | "GT" | "LT";
+export type RedisCommandValue = RedisCommandArgument | number;
+export type RedisCommandOptions = CommandOptions<ClientCommandOptions>;
+export type RedisHSETObject = Record<NumString, RedisCommandValue>;
+export type MSSQLRequestParameters = Null<MSSQLRequestParameterValue[] | ObjectMap<Omit<MSSQLRequestParameterValue, "name">>>;
+export type ErrorQueryCallback = (err: unknown, item: DbDataSource, commandType?: number) => boolean;
+
+export interface SQL_COMMAND {
+    SELECT: 1;
+    INSERT: 2;
+    UPDATE: 3;
+    DELETE: 4;
+}
+
+export type { DB_TYPE, CacheOptions, IdentifierAction, RedisCommandArgument, RedisJSON };

package/lib/document.d.ts

@@ -0,0 +1,192 @@
+import type { LocationUri, MimeTypeAction, StorageAction } from './squared';
+
+import type { IDocument, IFileManager, IModule } from './index';
+import type { ExternalAsset, InitialValue } from './asset';
+import type { CloudStorage } from './cloud';
+import type { LogComponent, LogDate } from './logger';
+import type { DocumentTransform } from './settings';
+
+export interface DocumentAsset extends ExternalAsset, StorageAction<CloudStorage> {
+    initialValue?: InitialValue & { inlineFilename?: string };
+}
+
+export interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export interface RawSourceMap<T = NumString> extends StartOfSourceMap {
+    version: T;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+
+export interface SourceInput<T = [string, string?, string?][]> {
+    code?: string;
+    sourceFile?: T;
+    sourceName?: string;
+    sourcesRelativeTo?: string;
+}
+
+export interface SourceCode {
+    code: string;
+    map?: RawSourceMap;
+    sourceMappingURL?: string;
+}
+
+export interface ChunkFile {
+    code: string;
+    filename?: string;
+    entryPoint?: boolean;
+}
+
+export interface ChunkData extends ChunkFile {
+    sourceMap?: SourceMap;
+}
+
+export interface CacheData {
+    uri?: string;
+    etag?: string;
+    encoding?: BufferEncoding;
+    override?: boolean;
+}
+
+export interface TransformAction {
+    cacheData?: CacheData;
+}
+
+export interface TransformResult extends SourceCode {
+    type?: string;
+    chunks?: Null<(SourceCode & ChunkFile)[]>;
+    sourceFiles?: string[];
+}
+
+export interface TransformOutput extends Partial<LocationUri>, Omit<SourceInput<string>, "code">, MimeTypeAction {
+    imported?: boolean;
+    sourceMap?: SourceMap;
+    metadata?: unknown;
+    external?: PlainObject;
+    productionRelease?: boolean;
+    getMainFile?(code?: string, imports?: StringMap): Undef<SourceInput<string>>;
+    getSourceFiles?(imports?: StringMap): Undef<SourceInput>;
+}
+
+export interface TransformOptions<T = AnyObject, U = T> extends TransformOutput {
+    baseConfig: T;
+    outputConfig: U;
+    sourceMap: SourceMap;
+    supplementChunks: ChunkData[];
+}
+
+export interface ITransformSeries<T = AnyObject, U = T> extends IModule, TransformOptions<T, U> {
+    readonly type: string;
+    init(instance: IModule, dirname?: string): this;
+    close(instance: IModule): void;
+    createSourceMap(value: string): SourceMap;
+    getMainFile(code?: string, imports?: StringMap): Undef<SourceInput<string>>;
+    getSourceFiles(imports?: StringMap): Undef<SourceInput>;
+    toBaseConfig(all?: boolean): T;
+    upgrade<V = unknown>(context: V, dirname?: string, name?: string): V;
+    set code(value);
+    get code(): string;
+    get out(): IOut;
+    get metadata(): object;
+    get options(): TransformOutput;
+    get productionRelease(): boolean;
+    get imported(): boolean;
+    set version(value);
+    get version(): string;
+    set packageName(value);
+    get packageName(): string;
+    get packageVersion(): string;
+    get username(): string;
+}
+
+export interface TransformSeriesConstructor {
+    readonly prototype: ITransformSeries;
+    new(type: string, code: string, options: TransformOutput): ITransformSeries;
+}
+
+export interface IOut extends OutV3, OutV4 {}
+
+export interface OutV3 {
+    sourceFiles?: string[];
+    ignoreCache?: boolean;
+    logAppend?: LogComponent[];
+    messageAppend?: string;
+}
+
+export interface OutV4 {
+    logQueued?: LogComponent[];
+}
+
+export interface SourceMapOptions extends MimeTypeAction {
+    file?: string;
+    hash?: string;
+    sourceRoot?: string;
+    sourceMappingURL?: string;
+    inlineMap?: boolean;
+    emptySources?: boolean;
+}
+
+export interface SourceMap extends SourceCode {
+    output: Map<string, SourceCode>;
+    reset(): void;
+    nextMap(name: string, code: string, map: unknown, sourceMappingURL?: string, emptySources?: boolean): boolean;
+    set map(value);
+    get map(): Undef<RawSourceMap>;
+}
+
+export interface SourceMapConstructor {
+    findSourceMap(code?: string, uri?: string): Undef<RawSourceMap>;
+    removeSourceMappingURL(value: string): [string, string?, Null<RawSourceMap>?];
+    isRaw(map: unknown): map is RawSourceMap;
+    readonly prototype: SourceMap;
+    new(code: string, uri?: string): SourceMap;
+}
+
+export interface UpdateGradleOptions {
+    multiple?: boolean;
+    addendum?: string;
+    upgrade?: boolean;
+    updateOnly?: boolean;
+}
+
+export interface LintMessage {
+    ruleId: string;
+    message: string;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+    severity?: 0 | 1 | 2 | "" | "error" | "warning";
+    fatal?: boolean;
+}
+
+export interface GenerateLintTableOptions extends Partial<LocationUri> {
+    leadingText?: string;
+    trailingText?: string;
+    errorCount?: number;
+    warningCount?: number;
+    fatalErrorCount?: number;
+    timeStamp?: LogDate;
+    ruleWidth?: number;
+    messageWidth?: number;
+}
+
+export interface CustomizeOptions {
+    transform?: DocumentTransform;
+}
+
+export interface AsSourceFileOptions {
+    encoding?: BufferEncoding;
+    persist?: boolean;
+    cache?: boolean;
+}
+
+export type Transformer = FunctionType<Undef<Promise<string> | string>>;
+export type ConfigOrTransformer = AnyObject | Transformer;
+export type PluginConfig = [string, Undef<ConfigOrTransformer>, Undef<AnyObject>, boolean?] | [];
+export type TransformCallback<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> = (this: T, instance: IDocument<T, U>, requireOrDocumentDir?: NodeJS.Require | string) => Void<Promise<void>>;

package/lib/dom.d.ts

@@ -0,0 +1,9 @@
+interface EventListenerOptions {
+    capture?: boolean;
+}
+
+export interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}

package/lib/filemanager.d.ts

@@ -0,0 +1,103 @@
+import type { BundleAction, FileInfo, LogStatus } from './squared';
+
+import type { IFileManager, IModule, ModuleConstructor } from './index';
+import type { ExternalAsset } from './asset';
+import type { HostInitLog as IHostInitLog } from './core';
+import type { RequestData as IRequestData } from './node';
+import type { RequestInit } from './request';
+
+import type { FETCH_TYPE } from '../index.d';
+
+export const enum FINALIZE_STATE {
+    READY = 0,
+    COMMIT = 1,
+    END = 2,
+    RESTART = 3,
+    QUEUED = 4,
+    RESTARTED = 5,
+    ABORTED = 6
+}
+
+export interface RequestData<T extends ExternalAsset = ExternalAsset> extends IRequestData<T>, RequestInit {
+    timeout?: ObjectMap<NumString>;
+}
+
+export interface InstallData<T extends IModule = IModule, U extends ModuleConstructor = ModuleConstructor> {
+    instance: T;
+    constructor: U;
+    params: unknown[];
+}
+
+export interface IHttpDiskCache<T extends ExternalAsset = ExternalAsset> {
+    limit: number;
+    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;
+    within(value: T | number): boolean;
+    clear(value?: unknown): void;
+    set enabled(value);
+    get enabled(): boolean;
+    set exclude(value);
+    get exclude(): string[];
+    set include(value);
+    get include(): string[];
+}
+
+export interface IHttpMemoryCache<T extends ExternalAsset = ExternalAsset> extends IHttpDiskCache<T> {
+    toDisk: TupleOf<number>;
+    purge(percent?: number, limit?: number): void;
+    withinDisk(value: T | number): boolean;
+    clear(uri?: string | URL): void;
+}
+
+export interface HttpDiskCacheAddOptions {
+    buffer?: Null<BufferContent>;
+    contentLength?: number;
+}
+
+export interface HttpMemoryCacheAddOptions extends Omit<HttpDiskCacheAddOptions, "buffer"> {
+    toDisk?: string;
+    encoding?: BufferEncoding;
+}
+
+export interface ReplaceOptions {
+    mimeType?: string;
+    rewritePath?: boolean;
+    ignoreExt?: boolean;
+}
+
+export interface AssetContentOptions extends BundleAction {
+    localUri: string;
+}
+
+export interface FileOutput {
+    pathname: string;
+    localUri: string;
+}
+
+export interface FinalizeResult {
+    files: FileInfo[];
+    errors: string[];
+    status?: LogStatus[];
+    aborted?: boolean;
+}
+
+export interface DeleteFileAddendum {
+    id?: number;
+    all?: boolean;
+}
+
+export interface HostInitLog extends IHostInitLog {
+    useNumeric: boolean;
+    showSize?: boolean;
+}
+
+export interface FindAssetOptions<T extends ExternalAsset = ExternalAsset> {
+    instance?: IModule;
+    assets?: T[];
+    replaced?: boolean;
+}
+
+export type FetchType = FETCH_TYPE[keyof FETCH_TYPE];
+export type PostFinalizeCallback = (files: FileInfo[] | string[], errors: string[], status?: LogStatus[]) => void;

package/lib/http.d.ts

@@ -0,0 +1,86 @@
+import type { ClientRequest, Agent as HttpAgent, OutgoingHttpHeaders } from 'http';
+import type { Agent as HttpsAgent } from 'https';
+import type { ClientHttp2Stream } from 'http2';
+
+export const enum HTTP_STATUS {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOL = 101,
+    PROCESSING = 102,
+    EARLY_HINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    MULTIPLE_CHOICES = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    USE_PROXY = 305,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    REQUEST_URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    MISDIRECTED_REQUEST = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    LOCKED = 423,
+    FAILED_DEPENDENCY = 424,
+    UPGRADE_REQUIRED = 426,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+    CLIENT_CLOSED_REQUEST = 499,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505,
+    VARIANT_ALSO_NEGOTIATES = 506,
+    INSUFFICIENT_STORAGE = 507,
+    LOOP_DETECTED = 508,
+    NOT_EXTENDED = 510,
+    NETWORK_AUTHENTICATION_REQUIRED = 511,
+    WEB_SERVER_IS_DOWN = 521,
+    CONNECTION_TIMED_OUT = 522,
+    A_TIMEOUT_OCCURRED = 524
+}
+
+export const enum QUERY_RESULT {
+    FAIL,
+    OK,
+    TIMEOUT
+}
+
+export interface HttpAgentSettings {
+    http?: HttpAgent;
+    https?: HttpsAgent;
+    keepAlive?: boolean;
+    timeout?: number;
+}
+
+export type HttpRequestClient = ClientRequest | ClientHttp2Stream;
+export type HttpOutgoingHeaders = ObjectMap<OutgoingHttpHeaders>;
+export type HttpProtocolVersion = 1 | 2 | 3;
+export type InternetProtocolVersion = 0 | 4 | 6;
+export type LookupCallback = (err: NodeJS.ErrnoException | null, address: string, family: number) => void;

package/lib/image.d.ts

@@ -0,0 +1,44 @@
+import type { MimeTypeAction } from './squared';
+
+import type { BroadcastValue, LogTime } from './logger';
+import type { ImageModule } from './settings';
+
+export interface CommandData {
+    resize?: ResizeData;
+    crop?: CropData;
+    rotate?: RotateData;
+    quality?: QualityData;
+    method?: MethodData;
+    opacity?: number;
+}
+
+export interface RotateData {
+    values: number[];
+    color: number;
+}
+
+export interface ResizeData extends Dimension {
+    mode: string;
+    color: number;
+    align: Undef<string>[];
+    algorithm?: string;
+}
+
+export interface CropData extends Point, Dimension {}
+
+export interface QualityData {
+    value: number;
+    nearLossless: number;
+    method: number;
+    preset?: string;
+}
+
+export interface TransformOptions extends MimeTypeAction {
+    tempFile?: boolean;
+    startTime?: LogTime;
+    module?: ImageModule;
+    broadcastId?: BroadcastValue;
+    cache?: boolean;
+}
+
+export type MethodData = [string, unknown[]?][];