@oscarpalmer/atoms 0.213.0 → 0.215.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-//#region src/models.d.ts
+//#region src/models/index.d.ts
 /**
  * A generic array or object
  */
@@ -13,6 +13,10 @@ export type BuiltIns = void | Date | Primitive | RegExp;
  * A generic class constructor
  */
 export type Constructor<Instance = unknown> = new (...args: any[]) => Instance;
+/**
+ * A frozen value with readonly properties _(going as deep as possible)_
+ */
+export type Frozen<Value> = Value extends unknown[] ? Readonly<Value> : Value extends PlainObject ? { readonly [Key in keyof Value]: Frozen<Value[Key$1]>; } : Value extends Map<infer Key, infer Value> ? ReadonlyMap<Key$1, Frozen<Value>> : Value extends Set<infer Item> ? ReadonlySet<Frozen<Item>> : Readonly<Value>;
 /**
  * A generic async callback function
  */
@@ -72,52 +76,6 @@ export type NumericalKeys<Value> = { [ItemKey in keyof Value]: ItemKey extends n
  * The numerical values of an object
  */
 export type NumericalValues<Item extends PlainObject> = Simplify<{ [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey]; }>;
-/**
- * An asynchronous function that can only be called once, returning the same value on subsequent calls
- */
-export type OnceAsync<Callback extends GenericAsyncCallback> = {
-  /**
-   * Did the callback's promise reject?
-   */
-  readonly error: boolean;
-  /**
-   * Has the callback finished?
-   */
-  readonly finished: boolean;
-  /**
-   * Run the callback
-   *
-   * @param parameters Callback parameters
-   * @returns Call result
-   */
-  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
-} & OnceProperties;
-/**
- * A callback function that can only be called once, returning the same value on subsequent calls
- */
-export type Once<Callback extends GenericCallback> = {
-  /**
-   * Run the callback
-   *
-   * @param parameters Callback parameters
-   * @returns Call result
-   */
-  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
-} & OnceProperties;
-type OnceProperties = {
-  /**
-   * Has the callback been called?
-   */
-  readonly called: boolean;
-  /**
-   * Has the callback's value been cleared?
-   */
-  readonly cleared: boolean;
-  /**
-   * Clear the callback's cached value
-   */
-  clear(): void;
-};
 /**
  * A generic object
  */
@@ -824,11 +782,16 @@ export declare function getArray<Item>(value: Item[]): Item[];
  */
 export declare function getArray<Value>(value: Value): Value[];
 //#endregion
-//#region src/internal/array/match.d.ts
+//#region src/models/array/array.misc.model.d.ts
 /**
  * Comparison of an array within another array
  */
-export type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
+type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
+type ArrayMapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
+type ArrayMapped<Item, Map extends ArrayMapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
+type ArrayObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
+//#endregion
+//#region src/internal/array/match.d.ts
 /**
  * Is the needle array at the end of the haystack array?
  *
@@ -2372,9 +2335,6 @@ export declare namespace move {
 }
 //#endregion
 //#region src/array/select.d.ts
-type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
-type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
-type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
 /**
  * Get a filtered and mapped array of items
  *
@@ -2394,7 +2354,7 @@ type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ?
  * ); // => ['Bob']
  * ```
  */
-export declare function filterAndMap<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
+export declare function filterAndMap<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends ArrayMapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<ArrayMapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -2414,7 +2374,7 @@ export declare function filterAndMap<Item, FilterCallback extends (item: Item, i
  * ); // => ['Bob']
  * ```
  */
-export declare function filterAndMap<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
+export declare function filterAndMap<Item extends PlainObject, ItemKey extends keyof Item, Map extends ArrayMapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<ArrayMapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -2432,7 +2392,7 @@ export declare function filterAndMap<Item extends PlainObject, ItemKey extends k
  * ); // => ['Bob']
  * ```
  */
-export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
+export declare function filterAndMap<Item, Map extends ArrayMapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<ArrayMapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -2450,7 +2410,7 @@ export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(a
  * ); // => [9]
  * ```
  */
-export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
+export declare function filterAndMap<Item, Map extends ArrayMapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<ArrayMapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -2472,7 +2432,7 @@ export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(a
  * ); // => ['Bob']
  * ```
  */
-export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
+export declare function mapAndFilter<Item, Map extends ArrayMapKeyOrCallback<Item>, FilterCallback extends (item: ArrayMapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<ArrayMapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -2516,7 +2476,7 @@ export declare function mapAndFilter<Item, MapCallback extends (item: Item, inde
  * ); // => [{tag: 'b'}]
  * ```
  */
-export declare function mapAndFilter<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
+export declare function mapAndFilter<Item, MapKey extends ArrayObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -2536,7 +2496,7 @@ export declare function mapAndFilter<Item, MapKey extends ObjectKeysOf<Item>, It
  * ); // => ['Bob']
  * ```
  */
-export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
+export declare function mapAndFilter<Item, Map extends ArrayMapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: ArrayMapped<Item, Map>, index: number, array: Item[]) => boolean): Array<ArrayMapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -2556,16 +2516,16 @@ export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(a
  * ); // => [4, 4]
  * ```
  */
-export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
+export declare function mapAndFilter<Item, Map extends ArrayMapKeyOrCallback<Item>>(array: Item[], map: Map, value: ArrayMapped<Item, Map>): Array<ArrayMapped<Item, Map>>;
 export declare namespace filterAndMap {
   export var reverse: typeof mapAndFilter;
 }
 //#endregion
-//#region src/array/sort.d.ts
+//#region src/models/array/array.sort.model.d.ts
 /**
  * Sorting information for arrays _(using a comparison callback)_
  */
-export type ArrayComparisonSorter<Item> = {
+type ArrayComparisonSorter<Item> = {
   /**
    * Callback to use when comparing items and values
    */
@@ -2578,7 +2538,7 @@ export type ArrayComparisonSorter<Item> = {
 /**
  * Sorting information for arrays _(using a key)_
  */
-export type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
+type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
   /**
    * Comparator to use when comparing items and values
    */
@@ -2599,15 +2559,15 @@ type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: Arra
 /**
  * Sorter to use for sorting
  */
-export type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sorters to use for sorting
  */
-export type ArraySorters<Item> = Array<ArraySorter<Item>>;
+type ArraySorters<Item> = Array<ArraySorter<Item>>;
 /**
  * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
-export type ArrayValueSorter<Item> = {
+type ArrayValueSorter<Item> = {
   /**
    * Direction to sort by
    */
@@ -2629,13 +2589,24 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
 /**
  * Direction to sort by
  */
-export type SortDirection = "ascending" | "descending";
+type SortDirection = "ascending" | "descending";
+type SortHandler = {
+  comparison?: SortHandlerComparison;
+  get: boolean;
+  identifier: string;
+  modifier: number;
+  value?: Function;
+};
+type SortHandlerComparison = {
+  complex?: Function;
+  simple?: Function;
+};
 /**
  * Sorter for an array with predefined sorters
  *
  * Can be used to sort an array, get the predicted index for an item, and check if an array is sorted
  */
-export type Sorter<Item> = {
+type Sorter<Item> = {
   /**
    * Get the index for an item _(to be inserted into an array of items)_
    *
@@ -2661,6 +2632,11 @@ export type Sorter<Item> = {
    */
   sort(array: Item[]): Item[];
 };
+export declare const SORT_DIRECTION_ASCENDING: SortDirection;
+export declare const SORT_DIRECTION_DESCENDING: SortDirection;
+//#endregion
+//#region src/array/sort.d.ts
+declare function Sorter(this: any, sorters: SortHandler[]): void;
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on sorters _(and an optional default direction)_
  *
@@ -2806,8 +2782,6 @@ export declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, des
  * @returns Sorted array
  */
 export declare function sort<Item>(array: Item[], descending?: boolean): Item[];
-export declare const SORT_DIRECTION_ASCENDING: SortDirection;
-export declare const SORT_DIRECTION_DESCENDING: SortDirection;
 export declare namespace sort {
   export var getIndex: typeof getSortedIndex;
   export var initialize: typeof initializeSorter;
@@ -3194,7 +3168,7 @@ export declare namespace toRecord {
  */
 export declare function noop(): void;
 //#endregion
-//#region src/internal/function/limit.d.ts
+//#region src/models/function/limiter.model.d.ts
 /**
  * An asynchronous function that can be cancelled
  */
@@ -3280,7 +3254,57 @@ export declare namespace throttle {
   export var async: typeof asyncThrottle;
 }
 //#endregion
+//#region src/models/function/once.model.d.ts
+/**
+ * An asynchronous function that can only be called once, returning the same value on subsequent calls
+ */
+type AsyncOnce<Callback extends GenericAsyncCallback> = {
+  /**
+   * Did the callback's promise reject?
+   */
+  readonly error: boolean;
+  /**
+   * Has the callback finished?
+   */
+  readonly finished: boolean;
+  /**
+   * Run the callback
+   *
+   * @param parameters Callback parameters
+   * @returns Call result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+} & OnceProperties;
+/**
+ * A callback function that can only be called once, returning the same value on subsequent calls
+ */
+type Once<Callback extends GenericCallback> = {
+  /**
+   * Run the callback
+   *
+   * @param parameters Callback parameters
+   * @returns Call result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+} & OnceProperties;
+type OnceProperties = {
+  /**
+   * Has the callback been called?
+   */
+  readonly called: boolean;
+  /**
+   * Has the callback's value been cleared?
+   */
+  readonly cleared: boolean;
+  /**
+   * Clear the callback's cached value
+   */
+  clear(): void;
+};
+//#endregion
 //#region src/function/once.d.ts
+declare function AsyncOnce(this: any, callback: GenericAsyncCallback): void;
+declare function Once(this: any, callback: GenericCallback): void;
 /**
  * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
  *
@@ -3289,7 +3313,7 @@ export declare namespace throttle {
  * @param callback Callback to use once
  * @returns _Once_ callback
  */
-export declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsync<Callback>;
+export declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): AsyncOnce<Callback>;
 /**
  * Is the value an asynchronous once callback?
  *
@@ -3320,7 +3344,7 @@ export declare namespace once {
   export var isAsync: typeof isAsyncOnce;
 }
 //#endregion
-//#region src/function/retry.d.ts
+//#region src/models/function/retry.model.d.ts
 /**
  * An error thrown when a retry fails
  */
@@ -3328,11 +3352,13 @@ export declare class RetryError extends Error {
   readonly original: unknown;
   constructor(message: string, original: unknown);
 }
-export type RetryOptions = {
+type RetryOptions = {
   delay?: number;
   times?: number;
   when?: (error: unknown) => boolean;
 };
+//#endregion
+//#region src/function/retry.d.ts
 /**
  * Retry a callback a specified number of times, with a delay between attempts
  *
@@ -3508,16 +3534,14 @@ export declare namespace indexOf {
   export var last: typeof lastIndexOf;
 }
 //#endregion
-//#region src/internal/function/assert.d.ts
-/**
- * Asserter for a property of a value
- */
-export type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends NestedPick<Value, Path> = NestedPick<Value, Path>> = Asserter<Asserted>;
+//#region src/models/function/assert.model.d.ts
+type AssertNestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: AssertNestedPick<Value[Key], Rest>; } : never : Path extends keyof Value ? { [Key in Path]: Value[Key]; } : never : never;
 /**
  * A function that asserts a value is of a specific type, throwing an error if it is not
  */
-export type Asserter<Value> = (value: unknown) => asserts value is Value;
-type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: NestedPick<Value[Key], Rest>; } : never : Path extends keyof Value ? { [Key in Path]: Value[Key]; } : never : never;
+type Asserter<Value> = (value: unknown) => asserts value is Value;
+//#endregion
+//#region src/internal/function/assert.d.ts
 /**
  * Asserts that a condition is true, throwing an error if it is not
  *
@@ -3580,7 +3604,7 @@ export declare function assertIs<Value>(condition: (value: unknown) => value is
  * @param error Error constructor _(defaults to `Error`)_
  * @returns _Asserter_
  */
-export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<NestedPick<Value, Path>>;
+export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<AssertNestedPick<Value, Path>>;
 export declare namespace assert {
   export var condition: typeof assertCondition;
   export var defined: typeof assertDefined;
@@ -3589,11 +3613,59 @@ export declare namespace assert {
   export var property: typeof assertProperty;
 }
 //#endregion
-//#region src/internal/function/memoize.d.ts
+//#region src/internal/sized/map.d.ts
+/**
+ * A _Map_ with a maximum size
+ *
+ * Behavior is similar to a _LRU_ cache, where the least recently used entries are removed
+ */
+export declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<SizedKey, SizedValue> {
+  #private;
+  /**
+   * Is the _Map_ full?
+   */
+  get full(): boolean;
+  get maximum(): number;
+  /**
+   * Create a new _SizedMap_ with entries and a maximum size _(2^20)_
+   *
+   * @param entries Array of key-value pairs to initialize the _SizedMap_ with
+   * @template SizedKey Type of the keys in the _SizedMap_
+   * @template SizedValue Type of the values in the _SizedMap_
+   */
+  constructor(entries: [SizedKey, SizedValue][]);
+  /**
+   * Create a new _SizedMap_ with a maximum size _(but clamped at 2^24)_
+   *
+   * @param maximum Maximum size of the _SizedMap_
+   * @template SizedKey Type of the keys in the _SizedMap_
+   * @template SizedValue Type of the values in the _SizedMap_
+   */
+  constructor(maximum: number);
+  /**
+   * Create a new _SizedMap_ with _(optional)_ entries and a maximum size
+   *
+   * @param entries Array of key-value pairs to initialize the _SizedMap_ with
+   * @param maximum Maximum size of the _SizedMap_ _(defaults to 2^20; clamped at 2^24)_
+   * @template SizedKey Type of the keys in the _SizedMap_
+   * @template SizedValue Type of the values in the _SizedMap_
+   */
+  constructor(entries?: [SizedKey, SizedValue][], maximum?: number);
+  /**
+   * @inheritdoc
+   */
+  override get(key: SizedKey): SizedValue | undefined;
+  /**
+   * @inheritdoc
+   */
+  override set(key: SizedKey, value: SizedValue): this;
+}
+//#endregion
+//#region src/models/function/memoize.model.d.ts
 /**
  * A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
  */
-export type Memoized<Callback extends GenericCallback> = {
+type Memoized<Callback extends GenericCallback> = {
   /**
    * Maximum cache size
    *
@@ -3648,7 +3720,7 @@ export type Memoized<Callback extends GenericCallback> = {
 /**
  * Options for a _Memoized_ function
  */
-export type MemoizedOptions<Callback extends GenericCallback> = {
+type MemoizedOptions<Callback extends GenericCallback> = {
   /**
    * Callback for getting a cache key for the provided parameters
    */
@@ -3658,6 +3730,13 @@ export type MemoizedOptions<Callback extends GenericCallback> = {
    */
   cacheSize?: number;
 };
+type MemoizedStateOptions = {
+  cacheKey?: GenericCallback;
+  cacheSize: number;
+};
+//#endregion
+//#region src/internal/function/memoize.d.ts
+declare function Memoized(this: any, callback: GenericCallback, options: MemoizedStateOptions): void;
 /**
  * Memoize a function, caching and retrieving results based on the first parameter
  *
@@ -3667,11 +3746,19 @@ export type MemoizedOptions<Callback extends GenericCallback> = {
  */
 export declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
 //#endregion
-//#region src/internal/models/result.model.d.ts
+//#region src/models/result.model.d.ts
 /**
  * An unknown result
  */
 export type AnyResult<Value, E> = Err<E> | ExtendedErr<E> | Ok<Value>;
+/**
+ * A synchronous _Flow_, a function that attempts to pipe values through a series of functions
+ */
+export type AttemptFlow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Result<UnwrapValue<Value>>;
+/**
+ * An asynchronous _Flow_, a function that attempts to pipe values through a series of functions
+ */
+export type AttemptAsyncFlow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<Result<UnwrapValue<Value>>>;
 /**
  * An error result
  */
@@ -3729,15 +3816,17 @@ type UnwrapResult<Original extends Result<unknown, unknown>> = Original extends
  */
 export type UnwrapValue<Original> = Original extends GenericCallback ? ReturnType<Original> extends Result<unknown, unknown> ? UnwrapResult<ReturnType<Original>> : ReturnType<Original> : Original extends Result<unknown, unknown> ? UnwrapResult<Original> : Original extends Promise<infer Value> ? Awaited<Value> : Original;
 //#endregion
-//#region src/internal/function/work.d.ts
+//#region src/models/function/work.model.d.ts
 /**
- * A synchronous _Flow_, a function that pipe a value through a series of functions
+ * An asynchronous _Flow_, a function that pipes a value through a series of functions
  */
-export type Flow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => UnwrapValue<Value>;
+type AsyncFlow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<UnwrapValue<Value>>;
 /**
- * An asynchronous _Flow_, a function that pipes a value through a series of functions
+ * A synchronous _Flow_, a function that pipe a value through a series of functions
  */
-export type FlowPromise<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<UnwrapValue<Value>>;
+type Flow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => UnwrapValue<Value>;
+//#endregion
+//#region src/internal/function/work.d.ts
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a function
  *
@@ -3745,7 +3834,7 @@ export type FlowPromise<Callback extends GenericCallback, Value> = (...args: Par
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<Fn extends GenericCallback>(fn: Fn): FlowPromise<Fn, ReturnType<Fn>>;
+export declare function asyncFlow<Fn extends GenericCallback>(fn: Fn): AsyncFlow<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3753,7 +3842,7 @@ export declare function asyncFlow<Fn extends GenericCallback>(fn: Fn): FlowPromi
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): FlowPromise<First, Second>;
+export declare function asyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): AsyncFlow<First, Second>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3761,7 +3850,7 @@ export declare function asyncFlow<First extends GenericCallback, Second>(first:
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): FlowPromise<First, Third>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): AsyncFlow<First, Third>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3769,7 +3858,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third>(
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): FlowPromise<First, Fourth>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): AsyncFlow<First, Fourth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3777,7 +3866,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): FlowPromise<First, Fifth>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): AsyncFlow<First, Fifth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3785,7 +3874,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): FlowPromise<First, Sixth>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): AsyncFlow<First, Sixth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3793,7 +3882,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): FlowPromise<First, Seventh>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): AsyncFlow<First, Seventh>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3801,7 +3890,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): FlowPromise<First, Eighth>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): AsyncFlow<First, Eighth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3809,7 +3898,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): FlowPromise<First, Ninth>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): AsyncFlow<First, Ninth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3817,7 +3906,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): FlowPromise<First, Tenth>;
+export declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): AsyncFlow<First, Tenth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -3825,7 +3914,7 @@ export declare function asyncFlow<First extends GenericCallback, Second, Third,
  *
  * @returns _Flow_ function
  */
-export declare function asyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): FlowPromise<Fn, ReturnType<Fn>>;
+export declare function asyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): AsyncFlow<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -4105,54 +4194,6 @@ export declare namespace pipe {
   export var async: typeof asyncPipe;
 }
 //#endregion
-//#region src/internal/sized/map.d.ts
-/**
- * A _Map_ with a maximum size
- *
- * Behavior is similar to a _LRU_ cache, where the least recently used entries are removed
- */
-export declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<SizedKey, SizedValue> {
-  #private;
-  /**
-   * Is the _Map_ full?
-   */
-  get full(): boolean;
-  get maximum(): number;
-  /**
-   * Create a new _SizedMap_ with entries and a maximum size _(2^20)_
-   *
-   * @param entries Array of key-value pairs to initialize the _SizedMap_ with
-   * @template SizedKey Type of the keys in the _SizedMap_
-   * @template SizedValue Type of the values in the _SizedMap_
-   */
-  constructor(entries: [SizedKey, SizedValue][]);
-  /**
-   * Create a new _SizedMap_ with a maximum size _(but clamped at 2^24)_
-   *
-   * @param maximum Maximum size of the _SizedMap_
-   * @template SizedKey Type of the keys in the _SizedMap_
-   * @template SizedValue Type of the values in the _SizedMap_
-   */
-  constructor(maximum: number);
-  /**
-   * Create a new _SizedMap_ with _(optional)_ entries and a maximum size
-   *
-   * @param entries Array of key-value pairs to initialize the _SizedMap_ with
-   * @param maximum Maximum size of the _SizedMap_ _(defaults to 2^20; clamped at 2^24)_
-   * @template SizedKey Type of the keys in the _SizedMap_
-   * @template SizedValue Type of the values in the _SizedMap_
-   */
-  constructor(entries?: [SizedKey, SizedValue][], maximum?: number);
-  /**
-   * @inheritdoc
-   */
-  override get(key: SizedKey): SizedValue | undefined;
-  /**
-   * @inheritdoc
-   */
-  override set(key: SizedKey, value: SizedValue): this;
-}
-//#endregion
 //#region src/internal/string/case.d.ts
 /**
  * Convert a string to camel case _(thisIsCamelCase)_
@@ -4252,7 +4293,7 @@ export declare function tryEncode(value: boolean | number | string): unknown;
  */
 export declare function words(value: string): string[];
 //#endregion
-//#region src/internal/value/handlers.d.ts
+//#region src/models/value/value.handler.model.d.ts
 type BaseHandler = {
   handlers: WeakMap<WeakKey, string | GenericCallback>;
   options: BaseHandlerOptions;
@@ -4274,8 +4315,26 @@ type ValueHandler = {
   handle(value: unknown, ...parameters: unknown[]): unknown;
 };
 //#endregion
+//#region src/models/value/value.misc.model.d.ts
+type ComparisonHandler<Value = any> = (first: Value, second: Value) => number;
+/**
+ * Thanks, type-fest!
+ */
+type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+/**
+ * A shaken object, without any `undefined` values
+ */
+type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key]; } & { [Key in keyof Value as undefined extends Value[Key] ? [Value[Key]] extends [undefined] ? never : Key : never]?: Exclude<Value[Key], undefined>; }>;
+/**
+ * A smushed object, with all nested objects flattened into a single level, using dot notation keys
+ */
+type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>>; }>;
+/**
+ * An unsmushed object, with all dot notation keys turned into nested keys
+ */
+type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [UnionKey in KeysOfUnion<Value>]: Value[UnionKey]; }, `${string}.${string}`>>;
+//#endregion
 //#region src/internal/value/compare.d.ts
-type Comparator<Value = any> = (first: Value, second: Value) => number;
 /**
  * Compare two values _(for sorting purposes)_
  *
@@ -4300,18 +4359,18 @@ export declare function deregisterComparator<Instance>(constructor: Constructor<
  * @param constructor Class constructor
  * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-export declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
+export declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ComparisonHandler<Instance>): void;
 export declare namespace compare {
   export var deregister: typeof deregisterComparator;
   export var handler: CompareHandler<number>;
   export var register: typeof registerComparator;
 }
 //#endregion
-//#region src/internal/value/equal.d.ts
+//#region src/models/value/value.equal.model.d.ts
 /**
  * Options for value equality comparison
  */
-export type EqualOptions = {
+type EqualOptions = {
   /**
    * When `true`, strings are compared case-insensitively
    */
@@ -4362,6 +4421,19 @@ type Equalizer = {
    */
   register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
 };
+type EqualizerOptions = {
+  ignoreCase: boolean;
+  ignoreExpressions: EqualizerOptionsKeys<RegExp[]>;
+  ignoreKeys: EqualizerOptionsKeys<Set<string>>;
+  relaxedNullish: boolean;
+};
+type EqualizerOptionsKeys<Values> = {
+  enabled: boolean;
+  values: Values;
+};
+//#endregion
+//#region src/internal/value/equal.d.ts
+declare function Equalizer(this: any, options: EqualizerOptions): void;
 /**
  * Deregister a equality comparison handler for a specific class
  *
@@ -4587,7 +4659,7 @@ export declare function setValue<Data extends PlainObject, Path extends NestedKe
  */
 export declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
 //#endregion
-//#region src/internal/models/plan.model.d.ts
+//#region src/models/plan.model.d.ts
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
@@ -4605,15 +4677,27 @@ type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): Promise<PlanReturned<Returned>>;
+  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
+};
+type AsyncPlanState = {
+  generator(...parameters: unknown[]): AsyncGenerator;
+} & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
+type BaseState<Type extends PlanType> = {
+  type: Type;
 };
+type InternalAsyncPlan = {
+  [PLAN_SYMBOL]: AsyncPlanState;
+} & AsyncPlan<never, never, unknown[]>;
+type InternalPlan = {
+  [PLAN_SYMBOL]: PlanState;
+} & Plan<never, never, unknown[]>;
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
@@ -4640,11 +4724,44 @@ type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    */
   run(...parameters: Parameters): PlanReturned<Returned>;
 };
+/**
+ * An immediately failing plan
+ */
+type PlanFailure<E> = {
+  /**
+   * Get the generator for the failed plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<Err<E>, never>;
+};
 type PlanOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
 type PlanErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
-type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrors<Yielded, Returned>;
-type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : never;
+type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer E> ? E : Original extends PlanFailure<infer E> ? E : never;
 type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
+/**
+ * An immediately successful or failing plan
+ */
+type PlanResult<Success, Failure> = PlanSuccess<Success> | PlanFailure<Failure>;
+type PlanState = {
+  generator(...parameters: unknown[]): Generator;
+} & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
+/**
+ * An immediately successful plan
+ */
+type PlanSuccess<Value> = {
+  /**
+   * Get the generator for the successful plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<never, Value>;
+};
+type PlanType = "asyncPlan" | "plan";
+declare const PLAN_SYMBOL: unique symbol;
+declare const PLAN_TYPE_PLAN_ASYNC: PlanType;
+declare const PLAN_TYPE_PLAN_SYNC: PlanType;
 //#endregion
 //#region src/plan/result.d.ts
 /**
@@ -4654,7 +4771,23 @@ type PlanReturned<Returned> = Returned extends Error ? never : Returned extends
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * Attempt to run the generator to completion
+ *
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Promised result
+ */
+export declare function asyncAttemptRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * Attempt to run the plan to completion
+ *
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Promised result
+ */
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -4662,7 +4795,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -4679,6 +4812,8 @@ export declare function attemptRun<Yielded, Returned, Parameters extends unknown
  * @returns Result
  */
 export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRunAsyncPlan(this: never, first: never, second: never): Promise<unknown>;
+export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;
 }
@@ -4688,20 +4823,41 @@ export declare namespace attemptRun {
  * Run an asynchronous generator to completion
  *
  * @param generator Generator to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @param generator Generator to run
+ * @param signal Optional abort signal
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+/**
+ * Run an asynchronous plan to completion
+ *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
+ * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
@@ -4709,9 +4865,12 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * Run a plan to completion
  *
  * @param plan Plan to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
+export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
+export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
 }
@@ -4770,34 +4929,26 @@ export declare function isPlan<Yielded = unknown, Returned = unknown, Parameters
 /**
  * Create an immediately failing plan
  *
- * @param reason Failure reason
+ * @param value Failure value
  * @returns Plan failure
  */
-export declare function fail<Reason>(reason: Reason): Generator<Reason, void>;
+export declare function fail<Value>(value: Value): PlanFailure<Value>;
 /**
  * Create an immediately succeeding plan
  *
  * @param value Success value
  * @returns Plan success
  */
-export declare function succeed<Value>(value: Value): Generator<never, Value>;
-export declare function succeedResult<Returned>(value: Returned): Generator<never, Ok<Returned>>;
-export declare namespace succeed {
-  export var result: typeof succeedResult;
-}
+export declare function succeed<Value>(value: Value): PlanSuccess<Value>;
 //#endregion
-//#region src/internal/aborter.d.ts
+//#region src/models/aborter.model.d.ts
 type Aborter = {
   callback: GenericCallback;
   cancel(): void;
   signal: AbortSignal;
 };
 //#endregion
-//#region src/promise/constants.d.ts
-declare const PROMISE_TYPE_FULFILLED = "fulfilled";
-declare const PROMISE_TYPE_REJECTED = "rejected";
-//#endregion
-//#region src/promise/models.d.ts
+//#region src/models/promise.model.d.ts
 /**
  * A _Promise_ that can be canceled
  */
@@ -4814,7 +4965,7 @@ export declare class CancelablePromise<Value = void> extends Promise<Value> {
 /**
  * A _Promise_ that was fulfilled
  */
-export type FulfilledPromise<Value> = {
+type FulfilledPromise<Value> = {
   /**
    * Status of the _Promise_
    */
@@ -4824,18 +4975,18 @@ export type FulfilledPromise<Value> = {
    */
   value: Awaited<Value>;
 };
-export type PromiseData = {
+type PromiseData = {
   last: number;
   result: ArrayOrPlainObject;
 };
-export type PromiseHandlers = {
+type PromiseHandlers = {
   resolve(value: unknown[]): void;
   reject(reason: unknown): void;
 };
 /**
  * Options for a _Promise_-handling function
  */
-export type PromiseOptions = {
+type PromiseOptions = {
   /**
    * AbortSignal for aborting the _Promise_; when aborted, the _Promise_ will reject with the reason of the signal
    */
@@ -4845,7 +4996,7 @@ export type PromiseOptions = {
    */
   time?: number;
 };
-export type PromiseParameters = {
+type PromiseParameters = {
   aborter?: Aborter;
   complete: boolean;
   data: PromiseData;
@@ -4860,18 +5011,18 @@ export type PromiseParameters = {
  * - `complete`: wait for all _Promises_ to settle, then return the results, as an array of fulfilled and/or rejected results
  * - `first`: rejects on the first rejected _Promise_, and returns an array of values
  */
-export type PromiseStrategy = "complete" | "first";
+type PromiseStrategy = "complete" | "first";
 /**
  * An error thrown when a promise times out
  */
 export declare class PromiseTimeoutError extends Error {
   constructor();
 }
-export type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; } extends (infer Result) ? Result : never;
+type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
 /**
  * Options for handling multiple _Promises_
  */
-export type PromisesOptions = {
+type PromisesOptions = {
   /**
    * AbortSignal for aborting the _Promises_; when aborted, the _Promises_ will reject with the reason of the signal
    */
@@ -4881,14 +5032,14 @@ export type PromisesOptions = {
    */
   strategy?: PromiseStrategy;
 };
-export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; } extends (infer Result) ? Result : never;
-export type PromisesValue<Value> = (FulfilledPromise<Value> | RejectedPromise);
-export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; } extends (infer Result) ? Result : never;
+type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
+type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; } extends (infer Result) ? Result : never;
+type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
+type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; } extends (infer Result) ? Result : never;
 /**
  * A _Promise_ that was rejected
  */
-export type RejectedPromise = {
+type RejectedPromise = {
   /**
    * Status of the _Promise_
    */
@@ -4898,6 +5049,8 @@ export type RejectedPromise = {
    */
   reason: unknown;
 };
+declare const PROMISE_TYPE_FULFILLED = "fulfilled";
+declare const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
 //#region src/promise/delay.d.ts
 /**
@@ -5302,14 +5455,6 @@ export declare namespace matchResult {
 }
 //#endregion
 //#region src/result/work/flow.d.ts
-/**
- * A synchronous _Flow_, a function that attempts to pipe values through a series of functions
- */
-export type AttemptFlow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Result<UnwrapValue<Value>>;
-/**
- * An asynchronous _Flow_, a function that attempts to pipe values through a series of functions
- */
-export type AttemptFlowPromise<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<Result<UnwrapValue<Value>>>;
 /**
  * Create an asynchronous _Flow_, a function that attempts to pipe a value through a series of functions
  *
@@ -5317,7 +5462,7 @@ export type AttemptFlowPromise<Callback extends GenericCallback, Value> = (...ar
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlowPromise<Fn, ReturnType<Fn>>;
+export declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn): AttemptAsyncFlow<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5325,7 +5470,7 @@ export declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn): At
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): AttemptFlowPromise<First, Second>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): AttemptAsyncFlow<First, Second>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5333,7 +5478,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second>(
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): AttemptFlowPromise<First, Third>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): AttemptAsyncFlow<First, Third>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5341,7 +5486,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): AttemptFlowPromise<First, Fourth>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): AttemptAsyncFlow<First, Fourth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5349,7 +5494,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): AttemptFlowPromise<First, Fifth>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): AttemptAsyncFlow<First, Fifth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5357,7 +5502,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): AttemptFlowPromise<First, Sixth>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): AttemptAsyncFlow<First, Sixth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5365,7 +5510,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): AttemptFlowPromise<First, Seventh>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): AttemptAsyncFlow<First, Seventh>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5373,7 +5518,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): AttemptFlowPromise<First, Eighth>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): AttemptAsyncFlow<First, Eighth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5381,7 +5526,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): AttemptFlowPromise<First, Ninth>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): AttemptAsyncFlow<First, Ninth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5389,7 +5534,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): AttemptFlowPromise<First, Tenth>;
+export declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): AttemptAsyncFlow<First, Tenth>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5397,7 +5542,7 @@ export declare function attemptAsyncFlow<First extends GenericCallback, Second,
  *
  * @returns _Flow_ function
  */
-export declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): AttemptFlowPromise<Fn, ReturnType<Fn>>;
+export declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): AttemptAsyncFlow<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a series of functions
  *
@@ -5664,11 +5809,11 @@ export declare namespace attemptPipe {
   export var async: typeof attemptAsyncPipe;
 }
 //#endregion
-//#region src/string/fuzzy.d.ts
+//#region src/models/string/string.fuzzy.model.d.ts
 /**
  * Fuzzy searcher for an array of items
  */
-export type Fuzzy<Item> = {
+type Fuzzy<Item> = {
   /**
    * Get items currently being searched through
    *
@@ -5704,7 +5849,7 @@ export type Fuzzy<Item> = {
    */
   search(value: string, limit: number): FuzzyResult<Item>;
 };
-export type FuzzyConfiguration<Item> = {
+type FuzzyConfiguration<Item> = {
   /**
    * Handler to stringify items
    *
@@ -5720,7 +5865,11 @@ export type FuzzyConfiguration<Item> = {
    */
   key?: keyof Item;
 } : {}) & FuzzyOptions;
-export type FuzzyOptions = {
+type FuzzyItem<Item> = {
+  item: Item;
+  haystack: string;
+};
+type FuzzyOptions = {
   /**
    * Maximum number of combined items to return in `exact` and `similar` _(defaults to all matches)_
    */
@@ -5736,7 +5885,7 @@ export type FuzzyOptions = {
 /**
  * Search results from a fuzzy search, with exact and similar matches
  */
-export type FuzzyResult<Item> = {
+type FuzzyResult<Item> = {
   /**
    * Ordered items that exactly match the search value
    */
@@ -5746,10 +5895,16 @@ export type FuzzyResult<Item> = {
    */
   similar: Item[];
 };
-/**
- * Options for fuzzy searching
- */
-export type FuzzySearchOptions = FuzzyOptions;
+type FuzzyState<Item> = {
+  handler(item: Item): string;
+  items: Item[];
+  limit?: number;
+  strings: string[];
+  tolerance: number;
+};
+//#endregion
+//#region src/string/fuzzy.d.ts
+declare function Fuzzy(this: any, state: FuzzyState<unknown>): void;
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -5879,11 +6034,11 @@ export declare function includes(haystack: string, needle: string, ignoreCase?:
  */
 export declare function startsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 //#endregion
-//#region src/string/normalize.d.ts
+//#region src/models/string/string.normalize.model.d.ts
 /**
  * Options for normalizing a string
  */
-export type NormalizeOptions = {
+type NormalizeOptions = {
   /**
    * Remove diacritical marks from the string? _(defaults to `true`)_
    */
@@ -5910,7 +6065,7 @@ export type NormalizeOptions = {
 /**
  * String normalizer function
  */
-export type Normalizer = {
+type Normalizer = {
   /**
    * Normalize a string
    *
@@ -5919,6 +6074,10 @@ export type Normalizer = {
    */
   normalize(value: string): string;
 };
+type NormalizerOptions = Required<NormalizeOptions>;
+//#endregion
+//#region src/string/normalize.d.ts
+declare function Normalizer(this: any, options: NormalizerOptions): void;
 /**
  * Deburr a string, removing diacritical marks
  *
@@ -5949,7 +6108,7 @@ export declare namespace normalize {
   export var initialize: typeof initializeNormalizer;
 }
 //#endregion
-//#region src/string/template.d.ts
+//#region src/models/string/string.template.model.d.ts
 /**
  * Renderer for a string template with variables
  *
@@ -5961,7 +6120,7 @@ type Renderer = (variables?: PlainObject, options?: Partial<TemplateOptions>) =>
 /**
  * Options for templating strings
  */
-export type TemplateOptions = {
+type TemplateOptions = {
   /**
    * Ignore case when searching for variables?
    */
@@ -5987,10 +6146,14 @@ type Templater = {
    */
   render(value: string, variables?: PlainObject): string;
 };
+type TemplaterOptions = Required<TemplateOptions>;
 /**
  * Render a template string with variables
  */
 type TemplaterRenderer = (variables?: PlainObject) => string;
+//#endregion
+//#region src/string/template.d.ts
+declare function Templater(this: any, options: TemplaterOptions): void;
 /**
  * Create a _Templater_ with predefined options
  *
@@ -6019,8 +6182,8 @@ export declare namespace template {
   export var initialize: typeof initializeTemplater;
 }
 //#endregion
-//#region src/value/clone.d.ts
-export type CloneOptions = {
+//#region src/models/value/value.clone.model.d.ts
+type CloneOptions = {
   /**
    * Copy functions instead of returning `undefined`? _(defaults to `false`)_
    */
@@ -6033,7 +6196,7 @@ export type CloneOptions = {
 /**
  * A cloning function with predefined options
  */
-export type Cloner = {
+type Cloner = {
   /**
    * Clone any kind of value
    *
@@ -6048,7 +6211,7 @@ export type Cloner = {
    *
    * @param constructor Class constructor
    */
-  deregister: typeof deregisterCloner;
+  deregister<Instance>(constructor: Constructor<Instance>): void;
   /**
    * Register a clone handler for a specific class
    *
@@ -6057,8 +6220,11 @@ export type Cloner = {
    * @param constructor Class constructor
    * @param handler Method name or clone function _(defaults to method name `clone`)_
    */
-  register: typeof registerCloner;
+  register<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
 };
+//#endregion
+//#region src/value/clone.d.ts
+declare function Cloner(this: any, options: Required<CloneOptions>): void;
 /**
  * Clone any kind of value _(deeply, if needed)_
  *
@@ -6137,11 +6303,11 @@ export declare function inMap<Key, Value>(map: Map<Key, Value>, value: Value, ke
  */
 export declare function inSet<Value>(set: Set<Value>, value: Value): boolean;
 //#endregion
-//#region src/value/diff.d.ts
+//#region src/models/value/value.diff.model.d.ts
 /**
  * Options for value comparison
  */
-export type DiffOptions = {
+type DiffOptions = {
   /**
    * Should `null` and `undefined` be considered equal and ignored in results?
    */
@@ -6150,7 +6316,7 @@ export type DiffOptions = {
 /**
  * The result of a comparison beteen two values
  */
-export type DiffResult<First, Second = First> = {
+type DiffResult<First, Second = First> = {
   /**
    * The original values that were compared
    */
@@ -6171,7 +6337,7 @@ type DiffType = "full" | "none" | "partial";
 /**
  * The difference between two values
  */
-export type DiffValue<First = unknown, Second = First> = {
+type DiffValue<First = unknown, Second = First> = {
   /**
    * The value from the first value
    */
@@ -6181,6 +6347,8 @@ export type DiffValue<First = unknown, Second = First> = {
    */
   to: Second;
 };
+//#endregion
+//#region src/value/diff.d.ts
 /**
  * Find the differences between two values
  *
@@ -6192,10 +6360,6 @@ export type DiffValue<First = unknown, Second = First> = {
 export declare function diff<First, Second = First>(first: First, second: Second, options?: DiffOptions): DiffResult<First, Second>;
 //#endregion
 //#region src/value/freeze.d.ts
-/**
- * A frozen value with readonly properties _(going as deep as possible)_
- */
-export type Frozen<Value> = Value extends unknown[] ? Readonly<Value> : Value extends PlainObject ? { readonly [Key in keyof Value]: Frozen<Value[Key]>; } : Value extends Map<infer Key, infer Value> ? ReadonlyMap<Key, Frozen<Value>> : Value extends Set<infer Item> ? ReadonlySet<Frozen<Item>> : Readonly<Value>;
 /**
  * Freeze an array and its indiced values, but not any nested values
  *
@@ -6355,10 +6519,6 @@ export declare function omit<Value extends PlainObject, ValueKey extends keyof V
 export declare function pick<Value extends PlainObject, ValueKey extends keyof Value>(value: Value, keys: ValueKey[]): Pick<Value, ValueKey>;
 //#endregion
 //#region src/value/shake.d.ts
-/**
- * A shaken object, without any `undefined` values
- */
-type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key]; } & { [Key in keyof Value as undefined extends Value[Key] ? [Value[Key]] extends [undefined] ? never : Key : never]?: Exclude<Value[Key], undefined>; }>;
 /**
  * Shake an object, removing all keys with `undefined` values
  *
@@ -6368,10 +6528,6 @@ type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undef
 export declare function shake<Value extends PlainObject>(value: Value): Shaken<Value>;
 //#endregion
 //#region src/value/smush.d.ts
-/**
- * A smushed object, with all nested objects flattened into a single level, using dot notation keys
- */
-type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>>; }>;
 /**
  * Smush an object into a flat object that uses dot notation keys
  *
@@ -6381,14 +6537,6 @@ type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Va
 export declare function smush<Value extends PlainObject>(value: Value): Smushed<Value>;
 //#endregion
 //#region src/value/unsmush.d.ts
-/**
- * Thanks, type-fest!
- */
-type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-/**
- * An unsmushed object, with all dot notation keys turned into nested keys
- */
-type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [UnionKey in KeysOfUnion<Value>]: Value[UnionKey]; }, `${string}.${string}`>>;
 /**
  * Unsmush a smushed object _(turning dot notation keys into nested keys)_
  *
@@ -6397,32 +6545,12 @@ type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [UnionKey in KeysOfU
  */
 export declare function unsmush<Value extends PlainObject>(value: Value): Unsmushed<Value>;
 //#endregion
-//#region src/value/merge.d.ts
+//#region src/models/value/value.merge.model.d.ts
 /**
  * Options for assigning values
  */
-export type AssignOptions = Omit<MergeOptions, "assignValues">;
-/**
- * An assigner function for assigning values from one or more objects to the first one
- */
-export type Assigner = {
-  /**
-   * Assign values from one or more objects to the first one
-   *
-   * @param to Value to assign to
-   * @param from Values to assign
-   * @returns Assigned value
-   */
-  assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
-};
-/**
- * Options for merging values
- */
-export type MergeOptions = {
-  /**
-   * Assign values to the first array or object instead of creating a new one?
-   */
-  assignValues?: boolean;
+type AssignOptions = BaseOptions;
+type BaseOptions = {
   /**
    * Key _(or key epxressions)_ for values that should be replaced
    *
@@ -6448,10 +6576,32 @@ export type MergeOptions = {
    */
   skipNullableInArrays?: boolean;
 };
+/**
+ * An assigner function for assigning values from one or more objects to the first one
+ */
+type Assigner = {
+  /**
+   * Assign values from one or more objects to the first one
+   *
+   * @param to Value to assign to
+   * @param from Values to assign
+   * @returns Assigned value
+   */
+  assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
+};
+/**
+ * Options for merging values
+ */
+type MergeOptions = {
+  /**
+   * Assign values to the first array or object instead of creating a new one?
+   */
+  assignValues?: boolean;
+};
 /**
  * A merger function for merging multiple arrays or objects into a single one
  */
-export type Merger = {
+type Merger = {
   /**
    * Merge multiple arrays or objects into a single one
    *
@@ -6460,6 +6610,17 @@ export type Merger = {
    */
   merge<Values extends ArrayOrPlainObject[]>(values: Array<NestedPartial<Values[number]>>): UnionToIntersection<Values[number]>;
 };
+type MergeReplaceableObjectsCallback = (name: string) => boolean;
+type MergingOptions = {
+  assignValues: boolean;
+  replaceableObjects: MergeReplaceableObjectsCallback | undefined;
+  skipNullableAny: boolean;
+  skipNullableInArrays: boolean;
+};
+//#endregion
+//#region src/value/merge.d.ts
+declare function Assigner(this: any, options: MergingOptions): void;
+declare function Merger(this: any, options: MergingOptions): void;
 /**
  * Assign values from one or more objects to the first one
  *
@@ -6502,7 +6663,7 @@ export declare namespace merge {
   export var initialize: typeof initializeMerger;
 }
 //#endregion
-//#region src/value/transform.d.ts
+//#region src/models/value/value.transform.model.d.ts
 /**
  * A callback transform an object's properties
  */
@@ -6511,18 +6672,11 @@ type TransformCallback<Value extends PlainObject, Key extends keyof Value> = (ke
  * A collection of keyed callbacks to transform an object's properties
  */
 type TransformCallbacks<Value extends PlainObject> = Partial<{ [Key in keyof Value]: (value: Value[Key]) => Value[Key]; }>;
-/**
- * A transformer for an object, with predefined callbacks for transforming its properties
- */
-export type Transformer<Value extends PlainObject> = {
-  /**
-   * Transform an object's properties
-   *
-   * @param value Object to transform
-   * @returns Transformed object
-   */
-  transform(value: Value): Value;
-};
+type TransformHandler<Value extends PlainObject> = TransformCallback<Value, keyof Value> | TransformCallbacks<Value>;
+//#endregion
+//#region src/value/transform.d.ts
+declare function Transformer(this: any, transformer: ReturnType<typeof getTransformHandler>): void;
+declare function getTransformHandler<Value extends PlainObject, Key extends keyof Value>(input: unknown): TransformHandler<Value> | undefined;
 /**
  * Initialize a transformer for an object with a transformer function
  *
@@ -6561,7 +6715,7 @@ export declare namespace transform {
   export var initialize: typeof initializeTransformer;
 }
 //#endregion
-//#region src/internal/subscription.d.ts
+//#region src/models/subscription.model.d.ts
 type Subscription = {
   /**
    * Is the subscription active?
@@ -6660,33 +6814,12 @@ type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
   keyed?: Map<Key$1, Map<MapKey, MapValue>>;
 };
-/**
- * Is the value a subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a subscription, otherwise `false`
- */
-export declare function isSubscription(value: unknown): value is Subscription;
-/**
- * Is the value a subscriptions store?
- *
- * @param value Value to check
- * @returns `true` if the value is a subscriptions store, otherwise `false`
- */
-export declare function isSubscriptions(value: unknown): value is Subscriptions;
-/**
- * Create a subscription store
- *
- * @param parameters Store parameters
- * @returns Subscription store
- */
-export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
 //#endregion
-//#region src/beacon.d.ts
+//#region src/models/beacon.model.d.ts
 /**
  * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
  */
-export type Beacon<Value> = {
+type Beacon<Value> = {
   /**
    * Is the beacon active?
    */
@@ -6722,7 +6855,7 @@ export type Beacon<Value> = {
    */
   finish(): void;
 };
-export type BeaconOptions<Value> = {
+type BeaconOptions<Value> = {
   /**
    * Method for comparing values for equality
    *
@@ -6733,7 +6866,14 @@ export type BeaconOptions<Value> = {
    */
   equal?: (first: Value, second: Value) => boolean;
 };
-export type Observable<Value> = {
+type BeaconState<Value> = {
+  active: boolean;
+  observable?: Observable<Value>;
+  options: Required<BeaconOptions<Value>>;
+  subscriptions?: Subscriptions<Observer<unknown>>;
+  value: Value;
+};
+type Observable<Value> = {
   /**
    * Is the observable active?
    */
@@ -6773,6 +6913,33 @@ type Observer<Value> = {
    */
   next?: (value: Value) => void;
 };
+//#endregion
+//#region src/internal/subscription.d.ts
+/**
+ * Is the value a subscription?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a subscription, otherwise `false`
+ */
+export declare function isSubscription(value: unknown): value is Subscription;
+/**
+ * Is the value a subscriptions store?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a subscriptions store, otherwise `false`
+ */
+export declare function isSubscriptions(value: unknown): value is Subscriptions;
+/**
+ * Create a subscription store
+ *
+ * @param parameters Store parameters
+ * @returns Subscription store
+ */
+export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
+//#endregion
+//#region src/beacon.d.ts
+declare function Beacon(this: any, value: unknown, options?: BeaconOptions<unknown>): void;
+declare function Observable(this: any, beacon: BeaconState<unknown>): void;
 /**
  * Create a new beacon
  *
@@ -6803,7 +6970,7 @@ export declare function isBeaconSubscription(value: unknown): value is Subscript
  */
 export declare function isObservable<Value = unknown>(value: unknown): value is Observable<Value>;
 //#endregion
-//#region src/internal/models/herald.model.d.ts
+//#region src/models/herald.model.d.ts
 type Herald<Events extends Record<string, GenericCallback>> = {
   readonly events: HeraldEvents<Events>;
   /**
@@ -6842,7 +7009,7 @@ type HeraldOptions<Events extends Record<string, GenericCallback>> = {
   onCreate?: HeraldOnCreate<Events>;
 };
 //#endregion
-//#region src/color/models.d.ts
+//#region src/models/color.model.d.ts
 /**
  * A color that is represented in multiple color formats
  */
@@ -7765,8 +7932,8 @@ export declare function isNumerical(value: unknown): value is number | `${number
  */
 export declare function isObject(value: unknown): value is object;
 //#endregion
-//#region src/logger.d.ts
-type Logger = {
+//#region src/models/logger.model.d.ts
+type Lumberjack = {
   /**
    * Log any number of values at the "debug" log level
    */
@@ -7834,15 +8001,17 @@ type TimeLogger = {
    */
   get stop(): () => void;
 };
+//#endregion
+//#region src/logger.d.ts
 declare function TimeLogger(this: any, label: string): void;
-declare function isLogger(value: unknown): value is Logger;
+declare function isLogger(value: unknown): value is Lumberjack;
 declare function isTimeLogger(value: unknown): value is TimeLogger;
 /**
  * A logger that can be used to log messages to the console
  *
  * _(Logging can be enabled or disabled by setting the `enabled` property)_
  */
-declare const Logger: Logger;
+declare const Logger: Lumberjack;
 //#endregion
 //#region src/internal/math/aggregate.d.ts
 /**
@@ -8148,11 +8317,11 @@ export declare function fromQuery(query: string): PlainObject;
  */
 export declare function toQuery(parameters: PlainObject): string;
 //#endregion
-//#region src/queue.d.ts
+//#region src/models/queue.model.d.ts
 /**
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
-export type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
+type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Get keys of all active queues
    */
@@ -8250,7 +8419,7 @@ export type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback,
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-export type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
+type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Is the queue active?
    */
@@ -8313,13 +8482,7 @@ export type Queue<Callback extends GenericCallback | GenericAsyncCallback, Callb
    */
   resume(): void;
 };
-/**
- * An error thrown by the Queue when an operation fails
- */
-export declare class QueueError extends Error {
-  constructor(message: string);
-}
-export type QueueOptions = {
+type QueueOptions = {
   /**
    * Automatically start processing the queue when the first item is added _(defaults to `true`)_
    */
@@ -8336,7 +8499,7 @@ export type QueueOptions = {
 /**
  * A queued item
  */
-export type Queued<Value> = {
+type Queued<Value> = {
   /**
    * ID of the queued item _(can be used to remove it from the queue)_
    */
@@ -8347,6 +8510,10 @@ export type Queued<Value> = {
   readonly promise: Promise<Value extends Promise<infer Result> ? Result : Value>;
 };
 type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
+//#endregion
+//#region src/queue.d.ts
+declare function KeyedQueue(this: any, callback: GenericAsyncCallback, options: Required<QueueOptions>): void;
+declare function Queue(this: any, callback: GenericAsyncCallback, options: Required<QueueOptions>, key?: string): void;
 /**
  * Is the value keyed queue?
  *
@@ -8518,4 +8685,4 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { type AsyncLimiter, type AsyncPlan, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, type Herald, type HeraldEvents, Key$1 as Key, type Limiter, Logger, type Plan, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };
+export { type ArrayComparisonSorter, type ArrayKeySorter, type ArrayKeySorters, type ArraySorter, type ArraySorters, type ArrayValueSorter, type Asserter, type AssignOptions, type Assigner, type AsyncFlow, type AsyncLimiter, type AsyncOnce, type AsyncPlan, type Beacon, type BeaconOptions, type CloneOptions, type Cloner, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type CompareCallback, type ComparisonSorter, type DiffOptions, type DiffResult, type EqualOptions, type Equalizer, type Flow, type FulfilledPromise, type Fuzzy, type FuzzyItem, type FuzzyOptions, type FuzzyResult, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, type Herald, type HeraldEvents, type HeraldOptions, Key$1 as Key, type KeyedQueue, type Limiter, Logger, type Memoized, type MemoizedOptions, type MergeOptions, type Merger, type NormalizeOptions, type Normalizer, type Observable, type Observer, type Once, type Plan, type PlanFailure, type PlanResult, type PlanSuccess, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type Queue, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, type Renderer, type Shaken, type Smushed, type SortDirection, type Sorter, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TemplateOptions, type Templater, type TemplaterOptions, type TemplaterRenderer, type TimeLogger, type TransformCallback, type TransformCallbacks, type Transformer, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };