@e-mc/types 0.10.6 → 0.11.0

package/lib/settings.d.ts

@@ -4,15 +4,15 @@ 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 { HttpOutgoingHeaders, SecureConfig, ServerPort } from './http';
-import type { BackgroundColor, BroadcastOutMethod, ErrorOutMethod, ForegroundColor, LoggerColor, LoggerStatus, TextAlign } from './logger';
+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';
 
-import type { SpawnOptions } from 'child_process';
-import type { BinaryLike, CipherGCMTypes } from 'crypto';
-import type { LookupAddress } from 'dns';
-import type { BrotliOptions, ZlibOptions } from 'zlib';
-
+import type { SpawnOptions } from 'node:child_process';
+import type { BinaryLike, CipherGCMTypes } from 'node:crypto';
+import type { LookupAddress } from 'node:dns';
+import type { BrotliOptions, ZlibOptions } from 'node:zlib';
+import type { BackgroundColor as IBackgroundColor } from 'chalk';
 // @ts-ignore
 import type { Unit } from 'bytes';
 // @ts-ignore
@@ -22,13 +22,18 @@ import type { Options as ZopfliOptions } from 'node-zopfli';
 // @ts-ignore
 import type { PicomatchOptions } from 'picomatch';
 
+interface MinMax<T = number> {
+    min?: T;
+    max?: T;
+}
+
 export interface HandlerModule<T = PlainObject> extends HandlerSettings<T> {
     handler?: string;
     extensions?: string[];
 }
 
 export interface HandlerSettings<T = PlainObject> {
-    settings?: T & { broadcast_id?: ArrayOf<string> };
+    settings?: T & { broadcast_id?: string | string[] };
 }
 
 export interface ClientModule<T = ClientSettings> extends HandlerModule<T>, PermissionAction {}
@@ -38,19 +43,23 @@ export interface ClientSettings<T = PlainObject> extends PlainObject {
     cache_dir?: string;
 }
 
-export interface NodeModule<T = PlainObject> extends HandlerSettings<T> {
+export interface NodeModule<T = NodeSettings> extends HandlerSettings<T> {
     process?: {
         cpu_usage?: boolean;
         memory_usage?: boolean;
         inline?: boolean;
     };
     require?: {
-        ext?: ArrayOf<string> | boolean;
+        ext?: string | string[] | boolean;
         npm?: boolean;
         inline?: boolean;
     };
 }
 
+export interface NodeSettings extends PlainObject {
+    package_manager?: "npm" | "yarn" | "pnpm";
+}
+
 export interface ProcessModule<T = PlainObject> extends HandlerSettings<T> {
     env?: ProcessEnvConfig;
     thread?: {
@@ -59,13 +68,13 @@ export interface ProcessModule<T = PlainObject> extends HandlerSettings<T> {
             private?: boolean;
         };
         queue?: {
-            limit?: NumString;
-            expires?: NumString;
-            priority: { bypass?: NumString } & MinMax<NumString>;
+            limit?: number | string;
+            expires?: number | string;
+            priority: { bypass?: number | string } & MinMax<number | string>;
         };
-        limit?: NumString;
-        sub_limit?: NumString;
-        expires?: NumString;
+        limit?: number | string;
+        sub_limit?: number | string;
+        expires?: number | string;
     };
     cipher?: CipherConfig;
     password?: string;
@@ -77,34 +86,37 @@ export interface ProcessEnvConfig {
 
 export interface TempModule<T = PlainObject> extends HandlerSettings<T> {
     dir?: string;
+    env?: string;
+    os?: boolean;
     write?: boolean;
 }
 
 export interface PermissionModule<T = PermissionSettings> extends PermittedDirectories, HandlerSettings<T> {
     home_read?: boolean;
     home_write?: boolean;
-    process_exec?: (string | ExecOptions)[];
+    process_exec?: Array<string | ExecOptions>;
 }
 
 export interface PermissionSettings extends PlainObject {
-    picomatch?: Null<PicomatchOptions>;
-    minimatch?: Null<MinimatchOptions>;
+    picomatch?: PicomatchOptions | null;
+    minimatch?: MinimatchOptions | null;
 }
 
 export interface DownloadModule<T = PlainObject> extends HandlerSettings<T> {
-    expires?: NumString;
+    expires?: number | string;
     aria2?: {
         bin?: string | false;
         exec?: ExecAction;
-        update_status?: NumString | { interval?: NumString; broadcast_only?: boolean };
-        max_concurrent_downloads?: NumString;
-        max_connection_per_server?: NumString;
-        bt_stop_timeout?: NumString;
-        bt_tracker_connect_timeout?: NumString;
-        bt_tracker_timeout?: NumString;
+        check_integrity?: boolean;
+        update_status?: number | string | { interval?: number | string; broadcast_only?: boolean };
+        max_concurrent_downloads?: number | string;
+        max_connection_per_server?: number | string;
+        bt_stop_timeout?: number | string;
+        bt_tracker_connect_timeout?: number | string;
+        bt_tracker_timeout?: number | string;
         min_split_size?: string;
-        disk_cache?: NumString;
-        lowest_speed_limit?: NumString;
+        disk_cache?: number | string;
+        lowest_speed_limit?: number | string;
         always_resume?: boolean;
         file_allocation?: "none" | "prealloc" | "trunc" | "falloc";
         conf_path?: string;
@@ -132,7 +144,7 @@ export interface DocumentGroup<T = { imports?: StringMap } & AnyObject, U = AnyO
 }
 
 export interface DocumentUserSettings<T = AnyObject, U = T> extends DocumentGroup<T, U>, PlainObject {
-    extensions?: Null<string[]>;
+    extensions?: string[] | null;
     imports_strict?: boolean;
 }
 
@@ -144,13 +156,13 @@ export interface DocumentComponentOption<T = unknown> {
     cache?: T;
     coerce?: boolean;
     abort?: boolean;
-    local_file?: NumString;
+    local_file?: number | string;
 }
 
-export interface DocumentSettings extends DocumentGroup, PurgeAction, ClientSettings<DocumentUserSettings>, PlainObject {
-    imports_strict?: boolean;
+export interface DocumentSettings<T extends DocumentUserSettings = DocumentUserSettings> extends DocumentGroup, PurgeAction, ClientSettings<T>, PlainObject {
     directory?: DocumentDirectory;
     options?: DocumentComponentOptions;
+    imports_strict?: boolean;
 }
 
 export interface DocumentDirectory extends StringMap {
@@ -165,14 +177,14 @@ export interface ClientDbSettings<T = PlainObject> extends ClientSettings<T>, Pu
     imports?: StringMap;
 }
 
-export interface MemoryModule<T = MemorySettings> extends HandlerSettings<T>, Record<string, Undef<T | ObjectMap<PurgeBase>>> {}
+export interface MemoryModule<T = MemorySettings> extends HandlerSettings<T>, Record<string, T | ObjectMap<PurgeBase> | undefined> {}
 
 export interface MemorySettings extends PlainObject {
     users?: boolean | string[];
     cache_disk?: MemoryCacheDiskSettings;
 }
 
-export interface MemoryCacheDiskSettings<T = NumString> extends IncludeAction<Null<string[]>> {
+export interface MemoryCacheDiskSettings<T = number | string> extends IncludeAction<string[] | null> {
     enabled?: boolean;
     min_size?: T;
     max_size?: T;
@@ -189,12 +201,12 @@ export interface DbUserSettings extends DbSourceDataType<{ commands?: ObjectMap<
 
 export interface DbCacheSettings extends TimeoutAction {
     dir?: string;
-    purge?: NumString;
+    purge?: number | string;
     when_empty?: boolean;
 }
 
 export interface DbSourceOptions {
-    pool?: PoolConfig<NumString>;
+    pool?: PoolConfig<number | string>;
     cache?: DbCacheValue;
     coerce?: DbCoerceValue;
 }
@@ -204,20 +216,20 @@ export interface DbCoerceSettings<T = boolean> {
     options?: T;
 }
 
-export interface PurgeBase<T = NumString> extends MinMax {
+export interface PurgeBase<T = number | string> extends MinMax {
     enabled?: boolean;
     percent?: T;
     limit?: number;
 }
 
 export interface PurgeComponent extends PurgeBase {
-    interval?: NumString;
+    interval?: number | string;
     all?: boolean | number;
     log?: boolean;
     prefix?: string;
 }
 
-export type DbCacheValue = NumString | DbCacheSettings;
+export type DbCacheValue = number | string | DbCacheSettings;
 export type DbCoerceValue = boolean | DbCoerceSettings;
 export type DbSourceDataType<T = unknown> = {
     [K in DbSource]?: T;
@@ -234,35 +246,42 @@ export interface ImageSettings extends PlainObject {
     };
 }
 
-export interface RequestModule<T = RequestSettings> extends HandlerSettings<T> {
-    timeout?: NumString;
-    read_timeout?: NumString;
+export interface RequestModule<T = RequestSettings> extends HandlerSettings<T>, HttpHostSettings {
+    timeout?: number | string;
+    read_timeout?: number | string;
     agent?: {
         keep_alive?: boolean;
-        timeout?: NumString;
+        timeout?: number | string;
     };
     disk?: HttpDiskSettings;
     buffer?: HttpMemorySettings;
     connect?: HttpConnectSettings;
     dns?: DnsLookupSettings;
     use?: {
-        http_version?: NumString;
+        http_version?: number | string;
         accept_encoding?: boolean;
     };
-    proxy?: AuthValue & IncludeAction & {
-        address?: string;
-        port?: NumString;
-        keep_alive?: boolean;
-    };
+    proxy?: HttpProxySettings;
     headers?: HttpOutgoingHeaders;
-    certs?: ObjectMap<SecureConfig<ArrayOf<string>>>;
+    certs?: ObjectMap<SecureConfig<string | string[]>>;
+    post_limit?: number | string;
+}
+
+export interface HttpProxySettings extends AuthValue, IncludeAction {
+    address?: string;
+    port?: number | string;
+    origin?: string;
+    keep_alive?: boolean;
+}
+
+export interface HttpHostSettings {
     localhost?: string[];
     protocol?: {
         "http/1.1"?: string[];
         h2c?: string[];
         h2?: string[];
     };
-    post_limit?: NumString;
+    write_stream?: ObjectMap<number | string>;
 }
 
 export interface RequestSettings extends PurgeAction, PlainObject {
@@ -270,7 +289,7 @@ export interface RequestSettings extends PurgeAction, PlainObject {
 }
 
 export interface WatchModule<T = WatchSettings> extends HandlerModule<T>, ServerInfo {
-    interval?: NumString;
+    interval?: number | string;
 }
 
 export interface WatchSettings<T = WatchUserSettings> extends ClientSettings<ObjectMap<T>>, PlainObject {}
@@ -279,19 +298,15 @@ export interface CompressModule<U = CompressSettings> extends HandlerSettings<U>
     gzip?: ZlibOptions;
     brotli?: BrotliOptions;
     zopfli?: ZopfliOptions;
-    tinify?: {
-        api_key?: string;
-        proxy?: string;
-    };
 }
 
 export interface CompressSettings extends PlainObject {
     cache?: boolean;
-    cache_expires?: NumString;
-    gzip_level?: NumString;
-    brotli_quality?: NumString;
-    zopfli_iterations?: NumString;
-    chunk_size?: NumString;
+    cache_expires?: number | string;
+    gzip_level?: number | string;
+    brotli_quality?: number | string;
+    zopfli_iterations?: number | string;
+    chunk_size?: number | string;
 }
 
 export interface TaskModule<T = PlainObject> extends ClientModule<T>, PlainObject {}
@@ -315,18 +330,32 @@ export interface CloudAuthSettings {
     database?: boolean;
 }
 
-export interface ErrorModule extends HandlerModule {
+export interface ErrorModule<T = ErrorSettings> extends HandlerModule<T> {
     out?: string | ErrorOutMethod;
     abort?: string[];
     fatal?: boolean;
-    recursion_limit?: NumString;
+    recursion_limit?: number | string;
 }
 
-export interface LoggerModule<T = NumString, U = boolean | T, V = LoggerFormat<T>> {
+export interface ErrorSettings extends PlainObject {
+    trap_exceptions?: boolean;
+}
+
+export interface LoggerProgress extends LoggerFormatColor {
+    scroll_buffer?: number | string;
+    max_width?: number | string;
+    use_color?: boolean;
+    text_wrap?: TextWrapStyle;
+    box_char?: string;
+    raw_mode?: boolean;
+}
+
+export interface LoggerModule<T = number | string, U = boolean | T, V = LoggerFormat<T>> {
     enabled?: boolean;
-    level?: NumString;
+    level?: number | string;
     production?: string[];
     format?: LoggerFormatSettings<V>;
+    progress?: LoggerProgress;
     meter?: LoggerMeterSettings<T>;
     broadcast?: BroadcastServer & { color?: boolean };
     status?: boolean | LoggerStatus;
@@ -359,9 +388,10 @@ export interface LoggerFormatSettings<T = PlainObject> {
     session_id?: T;
     message?: T;
     meter?: T;
+    error?: T;
 }
 
-export interface LoggerMeterSettings<T = NumString> {
+export interface LoggerMeterSettings<T = number | string> {
     http?: T;
     image?: T;
     compress?: T;
@@ -370,53 +400,59 @@ export interface LoggerMeterSettings<T = NumString> {
 
 export interface LoggerProcessSettings extends LoggerColor {
     cpu?: boolean;
-    cpu_bar?: boolean | ArrayOf<number>;
+    cpu_bar?: boolean | number | number[];
+    cpu_bar_color?: [typeof IBackgroundColor, typeof IBackgroundColor, typeof IBackgroundColor];
     cpu_single_core?: boolean;
     mem?: boolean;
     mem_format?: "%" | Unit;
 }
 
-export interface LoggerFormat<T = NumString> {
-    width?: T;
+export interface LoggerFormatColor {
     color?: ForegroundColor;
     bg_color?: BackgroundColor;
+}
+
+export interface LoggerFormat<T = number | string> extends LoggerFormatColor {
+    width?: T;
+    alt_color?: ForegroundColor;
     bg_alt_color?: BackgroundColor;
     bold?: boolean;
     justify?: TextAlign;
     unit?: string;
     as?: StringMap;
+    braces?: string | [string, string];
 }
 
 export interface HttpSettings {
-    version?: NumString;
-    timeout?: NumString;
+    version?: number | string;
+    timeout?: number | string;
     headers?: HttpOutgoingHeaders;
-    certs?: ObjectMap<SecureConfig<ArrayOf<string>>>;
+    certs?: ObjectMap<SecureConfig<string | string[]>>;
 }
 
 export interface HttpDiskSettings extends IncludeAction {
     enabled?: boolean;
-    limit?: NumString;
-    expires?: NumString;
+    limit?: number | string;
+    expires?: number | string;
 }
 
 export interface HttpMemorySettings extends HttpDiskSettings {
-    limit_all?: NumString;
-    to_disk?: NumString | [NumString, NumString?];
-    purge_amount?: NumString;
+    limit_all?: number | string;
+    to_disk?: number | string | [number | string, (number | string)?];
+    purge_amount?: number | string;
 }
 
 export interface HttpConnectSettings {
-    timeout?: NumString;
-    retry_wait?: NumString;
-    retry_after?: NumString;
-    retry_limit?: NumString;
-    redirect_limit?: NumString;
+    timeout?: number | string;
+    retry_wait?: number | string;
+    retry_after?: number | string;
+    retry_limit?: number | string;
+    redirect_limit?: number | string;
 }
 
 export interface DnsLookupSettings {
-    family?: NumString;
-    expires?: NumString;
+    family?: number | string;
+    expires?: number | string;
     resolve?: ObjectMap<Partial<LookupAddress>>;
 }
 
@@ -424,18 +460,18 @@ export interface HashConfig extends IncludeAction<ObjectMap<string[] | "*">> {
     enabled?: boolean;
     algorithm?: HashAlgorithm;
     etag?: boolean;
-    expires?: NumString;
+    expires?: number | string;
     renew?: boolean;
-    limit?: NumString;
+    limit?: number | string;
 }
 
-export interface BroadcastServer extends ServerInfo<ArrayOf<NumString>> {
+export interface BroadcastServer extends ServerInfo<ArrayOf<number | string>> {
     out?: string | BroadcastOutMethod;
 }
 
 export interface ExecOptions extends SpawnOptions {
     command?: string;
-    warn?: ArrayOf<string>;
+    warn?: string | string[];
 }
 
 export interface PurgeAction {
@@ -457,12 +493,12 @@ export interface CipherConfig {
     iv?: BinaryLike;
 }
 
-export interface ServerInfo<T = NumString> extends ServerPort<T> {
+export interface ServerInfo<T = number | string> extends ServerPort<T> {
     enabled?: boolean;
     secure?: SecureConfig & ServerPort<T>;
 }
 
 export type WatchUserSettings = ObjectMap<WatchInterval>;
-export type DocumentTransform = Null<boolean | "etag" | HashAlgorithm | HashConfig>;
+export type DocumentTransform = boolean | "etag" | HashAlgorithm | HashConfig | null;
 
 export type { ExecAction, PermissionReadWrite, SecureConfig };

package/lib/squared.d.ts

@@ -1,5 +1,4 @@
 /// <reference path="type.d.ts" />
-/// <reference path="object.d.ts" />
 
 import type { BinaryToTextEncoding } from "crypto";
 
@@ -23,20 +22,13 @@ interface BlobValue extends KeyValue<string, unknown> {
     filename?: string;
 }
 
-interface BoxRect<T = number> {
-    top: T;
-    right: T;
-    bottom: T;
-    left: T;
-}
-
-interface BoxRectDimension extends BoxRect, Dimension {
-    numberOfLines?: number;
-    overflow?: boolean;
+export interface KeyValue<T, out U> {
+    key: T;
+    value: U;
 }
 
 export interface FileAsset extends TextAsset, OutputAction, DocumentAction, MultipartAction, ResourceAction, IncrementalAction, ChecksumAction {
-    format?: ArrayOf<string>;
+    format?: string | string[];
     dataView?: NodeJS.ArrayBufferView;
     base64?: string;
     imported?: boolean | string[];
@@ -53,7 +45,7 @@ export interface DataSource<T = unknown> extends DocumentAction {
     preRender?: string | FunctionType;
     whenEmpty?: string | FunctionType;
     removeEmpty?: boolean;
-    ignoreCache?: boolean | 0 | 1 | [number, number?, number?];
+    ignoreCache?: IntBool | FirstOf<number, number>;
     transactionState?: number;
     transactionFail?: boolean;
 }
@@ -64,10 +56,11 @@ export interface DbDataSource<T = unknown, U = unknown, V = unknown, W = unknown
     credential?: string | W;
     options?: U;
     update?: V;
-    withCommand?: string | TupleOf<string>;
+    withCommand?: string | [string, string];
     parallel?: boolean;
+    flat?: number;
     willAbort?: boolean;
-    streamRow?: Null<boolean | string | ((row: unknown) => Void<Error | false>)>;
+    streamRow?: boolean | string | ((row: unknown) => Error | false | void) | null;
     usePool?: boolean | X;
 }
 
@@ -91,11 +84,11 @@ export interface WatchAction {
 }
 
 export interface BundleAction<T = unknown> {
-    bundleId?: NumString;
+    bundleId?: number | string;
     bundleIndex?: number;
     bundleReplace?: T;
     bundleQueue?: Promise<unknown>[];
-    trailingContent?: ArrayOf<string>;
+    trailingContent?: string | string[];
     exported?: boolean;
 }
 
@@ -105,7 +98,7 @@ export interface ChecksumAction {
 }
 
 export interface DocumentAction {
-    document?: ArrayOf<string>;
+    document?: string | string[];
     encoding?: BufferEncoding;
 }
 
@@ -208,6 +201,7 @@ export interface ViewEngine {
     name?: string;
     singleRow?: boolean;
     outputEmpty?: boolean;
+    expires?: number | string;
     options?: {
         compile?: PlainObject;
         output?: PlainObject;
@@ -225,7 +219,7 @@ export interface CompressFormat extends CompressLevel {
     condition?: string;
     plugin?: string;
     timeout?: number;
-    options?: PlainObject & { apiKey?: string };
+    options?: PlainObject;
 }
 
 export interface WatchInterval<T = FileAsset> extends TaskBase {
@@ -242,7 +236,7 @@ export interface WatchReload extends WebSocketClient {
 
 export interface WebSocketResponse {
     event?: string;
-    socketId?: ArrayOf<string>;
+    socketId?: string | string[];
     type?: string;
     encoding?: BufferEncoding;
     value?: unknown;
@@ -268,17 +262,17 @@ export interface BroadcastResponse extends WebSocketResponse {
 
 export interface FileInfo {
     name: string;
-    size: NumString;
+    size: number | string;
 }
 
 export interface RequestBase<T = PlainObject> {
     baseUrl?: string;
     priority?: number;
     threads?: number;
-    broadcastId?: ArrayOf<string>;
-    log?: boolean | ArrayOf<string> | T;
-    error?: { abort?: boolean | ArrayOf<string>; fatal?: boolean };
-    ignoreExtensions?: boolean | ArrayOf<string>;
+    broadcastId?: string | string[];
+    log?: boolean | string | string[] | T;
+    error?: { abort?: boolean | string | string[]; fatal?: boolean };
+    ignoreExtensions?: boolean | string | string[];
 }
 
 export interface RequestData extends RequestBase, ImportAction<StringMap>, IncrementalAction {
@@ -322,32 +316,7 @@ export interface ResponseError {
 
 export interface RequestObserve extends WebSocketClient {
     action?: string;
-    expires?: NumString;
-}
-
-export interface FinalizedElement {
-    documentId: string;
-    bounds: BoxRectDimension;
-    css: PlainObject;
-    outerWrapperIds?: string[];
-}
-
-export interface ConditionProperty {
-    conditionText: string;
-}
-
-export interface CssConditionData extends ConditionProperty {
-    name?: string;
-    conditionText: string;
-}
-
-export interface ControllerSettingsDirectoryUI {
-    layout: string;
-    string: string;
-    font: string;
-    image: string;
-    video: string;
-    audio: string;
+    expires?: number | string;
 }
 
 export interface ChecksumBase<T = BinaryToTextEncoding> {
@@ -357,15 +326,15 @@ export interface ChecksumBase<T = BinaryToTextEncoding> {
 
 export interface ChecksumOutput<T = BinaryToTextEncoding> extends ChecksumBase<T> {
     filename?: string;
-    include?: ArrayOf<string>;
-    exclude?: ArrayOf<string>;
+    include?: string | string[];
+    exclude?: string | string[];
     recursive?: boolean | 1;
 }
 
 export interface TaskBase {
-    interval?: NumString;
-    start?: NumString;
-    expires?: NumString;
+    interval?: number | string;
+    start?: number | string;
+    expires?: number | string;
 }
 
 export type WebSocketEvent = "close" | "error";

package/lib/type.d.ts

@@ -1,31 +1,36 @@
-/* eslint @typescript-eslint/no-explicit-any: "off", @typescript-eslint/no-redeclare: "off" */
-
+/** @deprecated */
 type Undef<T> = T | undefined;
+/** @deprecated */
 type Null<T> = T | null;
 type Void<T> = T | void;
 type Optional<T> = T | null | undefined;
 type Nullable<T> = { [P in keyof T]: T[P] | null; };
-type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+type Writable<T> = { -readonly [P in keyof T]: T[P] };
 type KeyOfType<T, U = any, V = any> = { [K in keyof T]: K extends U ? T[K] extends V ? K : never : never }[keyof T];
 type MapOfType<T, U = any, V = any> = { [K in KeyOfType<T, U, V>]: K extends U ? T[K] extends V ? T[K] : never : never };
 
 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;
 
+/** @deprecated */
 type NumString = number | string;
+type IntBool = boolean | 0 | 1;
 type ArrayOf<T> = T | T[];
+/** @deprecated */
 type TupleOf<T> = [T, T];
-type FirstOf<T, U = boolean> = T[] | [U, ...T[]];
+type FirstOf<T, U = boolean> = T extends U ? [T, ...T[]] : T[] | [U, T, ...T[]];
 type Bufferable = string | Buffer;
 
 type AnyObject = Record<string, unknown>;
 type PlainObject = Record<string | number | symbol, unknown>;
 
 type StandardMap = Record<string, any>;
-type StringMap = Record<string, Undef<string>>;
-type ObjectMap<T> = Record<string, Undef<T>>;
+type StringMap = Record<string, string | undefined>;
+type ObjectMap<T> = Record<string, T | undefined>;
+type IterableMap<T> = Record<string, T>;
 
 type PropertyAction<T, U extends string, V extends boolean = false> = {
     [K in keyof T as `${U}${V extends true ? string & K : Capitalize<string & K>}`]: T[K];