@baleada/logic 0.23.4 → 0.24.1

package/lib/index.d.ts

@@ -1,150 +1,254 @@
 import { getStroke, StrokeOptions } from 'perfect-freehand';
 import * as ky_distribution_types_ky from 'ky/distribution/types/ky';
-import ky, { Options } from 'ky';
-import { Config, DOMPurifyI } from 'dompurify';
-import { FullOptions, MatchData, Searcher } from 'fast-fuzzy';
-import { Options as Options$1 } from '@sindresorhus/slugify';
+import ky, { Options as Options$1 } from 'ky';
 import { ClassValue } from 'clsx';
+import { FullOptions, sortKind, MatchData } from 'fast-fuzzy';
+import { Config } from 'dompurify';
+import { Options } from '@sindresorhus/slugify';
 
-type AnimateableKeyframe = {
-    progress: number;
-    properties: {
-        [key: string]: number | string | any[];
+type AnyTransform<Transformed> = (param: any) => Transformed;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/clone)
+ */
+declare function createClone<Any>(): AnyTransform<Any>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/deep-equal)
+ */
+declare function createDeepEqual(compared: any): AnyTransform<boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/equal)
+ */
+declare function createEqual(compared: any): AnyTransform<boolean>;
+
+type ArrayTransform<Item, Transformed> = (array: Item[]) => Transformed;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/concat)
+ */
+declare function createConcat<Item>(...arrays: Item[][]): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/filter)
+ */
+declare function createFilter<Item>(predicate: (item: Item, index: number) => boolean): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/insert)
+ */
+declare function createInsert<Item>(item: Item, index: number): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/map)
+ */
+declare function createMap<Item, Transformed = Item>(transform: (item: Item, index: number) => Transformed): ArrayTransform<Item, Transformed[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/reduce)
+ */
+declare function createReduce<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Accumulator, initialValue?: Accumulator): (array: Item[]) => Accumulator;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/remove)
+ */
+declare function createRemove<Item>(index: number): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/reorder)
+ */
+declare function createReorder<Item>(from: {
+    start: number;
+    itemCount: number;
+} | number, to: number): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/replace)
+ */
+declare function createReplace<Item>(index: number, replacement: Item): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/reverse)
+ */
+declare function createReverse<Item>(): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/slice)
+ */
+declare function createSlice<Item>(from: number, to?: number): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/shuffle)
+ */
+declare function createShuffle<Item>(): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/sort)
+ */
+declare function createSort<Item>(compare?: (itemA: Item, itemB: Item) => number): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/swap)
+ */
+declare function createSwap<Item>(item1Index: number, item2Index: number): ArrayTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/unique)
+ */
+declare function createUnique<Item>(): ArrayTransform<Item, Item[]>;
+
+type ArrayAsyncTransform<Item, Transformed> = (array: Item[]) => Promise<Transformed>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/filter-async)
+ */
+declare function createFilterAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncTransform<Item, Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/find-async)
+ */
+declare function createFindAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncTransform<Item, Item | undefined>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/find-index-async)
+ */
+declare function createFindIndexAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncTransform<Item, number>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/map-async)
+ */
+declare function createMapAsync<Item, Mapped>(transform: (item: Item, index: number) => Promise<Mapped>): ArrayAsyncTransform<Item, Mapped[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/reduce-async)
+ */
+declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
+
+type AssociativeArrayEffect<Key, Value> = (associativeArray: AssociativeArray<Key, Value>) => AssociativeArray<Key, Value>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/associative-array-set)
+ */
+declare function createSet$1<Key extends any, Value extends any>(key: Key, value: Value, options?: WithPredicateKey): AssociativeArrayEffect<Key, Value>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/associative-array-clear)
+ */
+declare function createClear$1<Key extends any, Value extends any>(): AssociativeArrayEffect<Key, Value>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/associative-array-delete)
+ */
+declare function createDelete$1<Key extends any>(key: Key, options?: WithPredicateKey): AssociativeArrayEffect<Key, any>;
+
+type AssociativeArray<Key, Value> = [Key, Value][];
+
+type KeyStatusCode = string;
+
+type CreateAliasesOptions = {
+    toLonghand?: (shorthand: string) => string;
+};
+
+type CreateKeycomboDownOptions = CreateAliasesOptions & {
+    toCode?: (alias: string) => KeyStatusCode;
+};
+
+type CreateKeycomboMatchOptions$1 = CreateKeycomboDownOptions & {
+    toAliases?: (code: KeyStatusCode) => string[];
+};
+
+type KeyboardEventDescriptor = {
+    code: string;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+};
+
+type Direction = 'up' | 'upRight' | 'right' | 'downRight' | 'down' | 'downLeft' | 'left' | 'upLeft';
+
+type HookApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
+    status: RecognizeableStatus;
+    metadata: Metadata;
+    sequence: ListenEffectParam<Type>[];
+};
+
+type PolarCoordinates = {
+    distance: number;
+    angle: {
+        radians: number;
+        degrees: number;
     };
-    timing?: AnimateableTiming;
 };
-type AnimateableOptions = {
-    duration?: number;
-    timing?: AnimateableTiming;
-    iterations?: number | true;
-    alternates?: boolean;
+
+type KeyboardTimeMetadata = {
+    times: {
+        start: number;
+        end: number;
+    };
+    duration: number;
 };
-type AnimateableTiming = [number, number, number, number];
-type AnimateFrameEffect = (frame?: AnimateFrame) => any;
-type AnimateFrame = {
-    properties: {
-        [key: string]: {
-            progress: {
-                time: number;
-                animation: number;
-            };
-            interpolated: number | string | any[];
+
+type PointerStartMetadata = {
+    points: {
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
         };
     };
-    timestamp: number;
 };
-type AnimateOptions = {
-    interpolate?: {
-        colorModel?: 'rgb' | 'hsl' | 'lab' | 'lch' | 'xyz';
+
+type PointerTimeMetadata = {
+    times: {
+        start: number;
+        end: number;
     };
+    duration: number;
+    velocity: number;
 };
-type AnimateableStatus = 'ready' | 'playing' | 'played' | 'reversing' | 'reversed' | 'paused' | 'sought' | 'stopped';
-declare class Animateable {
-    private initialDuration;
-    private iterationLimit;
-    private alternates;
-    private controlPoints;
-    private reversedControlPoints;
-    private toAnimationProgress;
-    private reversedToAnimationProgress;
-    private playCache;
-    private reverseCache;
-    private pauseCache;
-    private seekCache;
-    private alternateCache;
-    private visibilitychange;
-    private getEaseables;
-    private getReversedEaseables;
-    constructor(keyframes: AnimateableKeyframe[], options?: AnimateableOptions);
-    private computedStatus;
-    private ready;
-    private computedTime;
-    private resetTime;
-    private computedProgress;
-    private resetProgress;
-    private computedIterations;
-    private resetIterations;
-    get keyframes(): AnimateableKeyframe[];
-    set keyframes(keyframes: AnimateableKeyframe[]);
-    get playbackRate(): number;
-    set playbackRate(playbackRate: number);
-    get status(): AnimateableStatus;
-    get iterations(): number;
-    get request(): number;
-    get time(): {
-        elapsed: number;
-        remaining: number;
+
+type PointerMoveMetadata = {
+    distance: {
+        straight: {
+            fromStart: PolarCoordinates['distance'];
+            fromPrevious: PolarCoordinates['distance'];
+        };
+        horizontal: {
+            fromStart: PolarCoordinates['distance'];
+            fromPrevious: PolarCoordinates['distance'];
+        };
+        vertical: {
+            fromStart: PolarCoordinates['distance'];
+            fromPrevious: PolarCoordinates['distance'];
+        };
     };
-    get progress(): {
-        time: number;
-        animation: number;
+    angle: {
+        fromPrevious: PolarCoordinates['angle'];
+        fromStart: PolarCoordinates['angle'];
     };
-    private computedKeyframes;
-    private reversedKeyframes;
-    private properties;
-    private easeables;
-    private reversedEaseables;
-    setKeyframes(keyframes: AnimateableKeyframe[]): this;
-    private computedPlaybackRate;
-    private duration;
-    private totalTimeInvisible;
-    setPlaybackRate(playbackRate: number): this;
-    play(effect: AnimateFrameEffect, options?: AnimateOptions): this;
-    private playing;
-    private played;
-    reverse(effect: AnimateFrameEffect, options?: AnimateOptions): this;
-    private reversing;
-    private reversed;
-    private invisibleAt;
-    private listenForVisibilitychange;
-    private computedRequest;
-    private createAnimate;
-    private startTime;
-    private setStartTimeAndStatus;
-    private getToAnimationProgress;
-    private getFrame;
-    private recurse;
-    pause(): this;
-    private paused;
-    private cancelAnimate;
-    seek(timeProgress: number, options?: {
-        effect?: AnimateFrameEffect;
-    } & AnimateOptions): this;
-    private sought;
-    restart(): this;
-    stop(): this;
-    private stopped;
-}
-declare const linear: AnimateableKeyframe['timing'];
-declare const materialStandard: AnimateableKeyframe['timing'];
-declare const materialDecelerated: AnimateableKeyframe['timing'];
-declare const materialAccelerated: AnimateableKeyframe['timing'];
-declare const verouEase: AnimateableKeyframe['timing'];
-declare const verouEaseIn: AnimateableKeyframe['timing'];
-declare const verouEaseOut: AnimateableKeyframe['timing'];
-declare const verouEaseInOut: AnimateableKeyframe['timing'];
-declare const easingsNetInSine: AnimateableKeyframe['timing'];
-declare const easingsNetOutSine: AnimateableKeyframe['timing'];
-declare const easingsNetInOutSine: AnimateableKeyframe['timing'];
-declare const easingsNetInQuad: AnimateableKeyframe['timing'];
-declare const easingsNetOutQuad: AnimateableKeyframe['timing'];
-declare const easingsNetInOutQuad: AnimateableKeyframe['timing'];
-declare const easingsNetInCubic: AnimateableKeyframe['timing'];
-declare const easingsNetOutCubic: AnimateableKeyframe['timing'];
-declare const easingsNetInOutCubic: AnimateableKeyframe['timing'];
-declare const easingsNetInQuart: AnimateableKeyframe['timing'];
-declare const easingsNetInQuint: AnimateableKeyframe['timing'];
-declare const easingsNetOutQuint: AnimateableKeyframe['timing'];
-declare const easingsNetInOutQuint: AnimateableKeyframe['timing'];
-declare const easingsNetInExpo: AnimateableKeyframe['timing'];
-declare const easingsNetOutExpo: AnimateableKeyframe['timing'];
-declare const easingsNetInOutExpo: AnimateableKeyframe['timing'];
-declare const easingsNetInCirc: AnimateableKeyframe['timing'];
-declare const easingsNetOutCirc: AnimateableKeyframe['timing'];
-declare const easingsNetInOutCirc: AnimateableKeyframe['timing'];
-declare const easingsNetInBack: AnimateableKeyframe['timing'];
-declare const easingsNetOutBack: AnimateableKeyframe['timing'];
-declare const easingsNetInOutBack: AnimateableKeyframe['timing'];
+    direction: {
+        fromPrevious: Direction;
+        fromStart: Direction;
+    };
+};
+
+type Graph<Id extends string, StateValue> = {
+    nodes: GraphNode<Id>[];
+    edges: GraphEdge<Id, StateValue>[];
+};
+type GraphNode<Id extends string> = Id;
+type GraphEdge<Id extends string, StateValue> = {
+    from: Id;
+    to: Id;
+    predicateShouldTraverse: (state: GraphState<Id, StateValue>) => boolean;
+};
+type GraphState<Id extends string, StateValue> = Record<Id, {
+    status: 'set' | 'unset';
+    value?: StateValue | undefined;
+}>;
+type GraphPath<Id extends string> = GraphNode<Id>[];
+type GraphStep<Id extends string, StateValue> = {
+    state: GraphState<Id, StateValue>;
+    path: GraphPath<Id>;
+};
+type GraphCommonAncestor<Id extends string> = {
+    node: GraphNode<Id>;
+    distances: Record<GraphNode<Id>, number>;
+};
+type GraphTreeNode<Id extends string> = {
+    node: GraphNode<Id>;
+    children: GraphTreeNode<Id>[];
+};
+type GraphTree<Id extends string> = GraphTreeNode<Id>[];
+type GraphAsync<Id extends string, StateValue> = {
+    nodes: GraphNode<Id>[];
+    edges: GraphAsyncEdge<Id, StateValue>[];
+};
+type GraphAsyncEdge<Id extends string, StateValue> = {
+    from: Id;
+    to: Id;
+    predicateShouldTraverse: (state: GraphState<Id, StateValue>) => Promise<boolean>;
+};
 
 type RecognizeableOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
     maxSequenceLength?: true | number;
@@ -161,12 +265,18 @@ type RecognizeableEffectApi<Type extends ListenableSupportedType, Metadata exten
     denied: () => void;
     getSequence: () => ListenEffectParam<Type>[];
     pushSequence: (sequenceItem: ListenEffectParam<Type>) => void;
-    onRecognized: (sequenceItem: ListenEffectParam<Type>) => any;
+    listenInjection: RecognizeOptions<Type>['listenInjection'];
 };
 type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
 type RecognizeOptions<Type extends ListenableSupportedType> = {
-    onRecognized?: (sequenceItem: ListenEffectParam<Type>) => any;
+    listenInjection?: {
+        effect: (sequenceItem: ListenEffectParam<Type>) => any;
+        optionsByType: Record<Type, ListenOptions<Type>>;
+    };
 };
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/recognizeable)
+ */
 declare class Recognizeable<Type extends ListenableSupportedType, Metadata extends Record<any, any>> {
     private maxSequenceLength;
     private effects;
@@ -184,7 +294,7 @@ declare class Recognizeable<Type extends ListenableSupportedType, Metadata exten
     get metadata(): Metadata;
     private computedSequence;
     setSequence(sequence: ListenEffectParam<Type>[]): this;
-    recognize(sequenceItem: ListenEffectParam<Type>, { onRecognized }?: RecognizeOptions<Type>): this;
+    recognize(sequenceItem: ListenEffectParam<Type>, options?: RecognizeOptions<Type>): this;
     private recognizing;
     private toType;
 }
@@ -202,7 +312,7 @@ type ListenableOptions<Type extends ListenableSupportedType, RecognizeableMetada
     recognizeable?: RecognizeableOptions<Type, RecognizeableMetadata>;
 };
 type ListenEffect<Type extends ListenableSupportedType> = Type extends 'intersect' ? (entries: ListenEffectParam<Type>) => any : Type extends 'mutate' ? (records: ListenEffectParam<Type>) => any : Type extends 'resize' ? (entries: ListenEffectParam<Type>) => any : Type extends 'idle' ? (deadline: ListenEffectParam<Type>) => any : Type extends ('message' | 'messageerror') ? (event: MessageEvent) => any : Type extends ListenableMediaQuery ? (event: ListenEffectParam<Type>) => any : Type extends (ListenableLeftClick | ListenableRightClick) ? (event: ListenEffectParam<Type>) => any : Type extends (ListenablePointer) ? (event: ListenEffectParam<Type>) => any : Type extends ('keydown' | 'keyup') ? (event: ListenEffectParam<Type>) => any : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? (event: ListenEffectParam<Type>) => any : Type extends keyof Omit<DocumentEventMap, 'resize'> ? (event: ListenEffectParam<Type>) => any : never;
-type ListenEffectParam<Type extends ListenableSupportedType> = Type extends 'intersect' ? IntersectionObserverEntry[] : Type extends 'mutate' ? MutationRecord[] : Type extends 'resize' ? ResizeObserverEntry[] : Type extends 'idle' ? IdleDeadline : Type extends ListenableMediaQuery ? MediaQueryListEvent : Type extends ListenableRightClick ? MouseEvent : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? HTMLElementEventMap[Type] : Type extends keyof Omit<DocumentEventMap, 'resize'> ? DocumentEventMap[Type] : never;
+type ListenEffectParam<Type extends ListenableSupportedType> = Type extends 'intersect' ? IntersectionObserverEntry[] : Type extends 'mutate' ? MutationRecord[] : Type extends 'resize' ? ResizeObserverEntry[] : Type extends 'idle' ? IdleDeadline : Type extends ('message' | 'messageerror') ? MessageEvent : Type extends ListenableMediaQuery ? MediaQueryListEvent : Type extends ListenableRightClick ? MouseEvent : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? HTMLElementEventMap[Type] : Type extends keyof Omit<DocumentEventMap, 'resize'> ? DocumentEventMap[Type] : never;
 type ListenOptions<Type extends ListenableSupportedType> = Type extends 'intersect' ? {
     observer?: IntersectionObserverInit;
 } & ObservationListenOptions : Type extends 'mutate' ? {
@@ -256,6 +366,9 @@ type ListenableActiveEventId<Type extends ListenableSupportedEventType> = [
     optionsOrUseCapture: AddEventListenerOptions | boolean
 ];
 type ListenableStatus = 'ready' | 'listening' | 'stopped';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/listenable)
+ */
 declare class Listenable<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> {
     private computedRecognizeable;
     private recognizeableEffectsKeys;
@@ -263,36 +376,529 @@ declare class Listenable<Type extends ListenableSupportedType, RecognizeableMeta
     constructor(type: Type, options?: ListenableOptions<Type, RecognizeableMetadata>);
     private computedStatus;
     private ready;
-    get type(): string;
-    set type(type: string);
-    get status(): ListenableStatus;
-    get active(): Set<ListenableActive<Type, RecognizeableMetadata>>;
-    get recognizeable(): Recognizeable<Type, RecognizeableMetadata>;
-    private computedType;
-    private implementation;
-    setType(type: string): this;
-    listen(effect: ListenEffect<Type>, options?: ListenOptions<Type>): this;
-    private intersectionListen;
-    private mutationListen;
-    private resizeListen;
-    private mediaQueryListen;
-    private idleListen;
-    private messageListen;
-    private recognizeableListen;
-    private documentEventListen;
-    private eventListen;
-    private addEventListeners;
-    private listening;
-    stop(options?: {
-        target?: Element | Document | (Window & typeof globalThis);
-    }): this;
+    get type(): string;
+    set type(type: string);
+    get status(): ListenableStatus;
+    get active(): Set<ListenableActive<Type, RecognizeableMetadata>>;
+    get recognizeable(): Recognizeable<Type, RecognizeableMetadata>;
+    private computedType;
+    private implementation;
+    setType(type: string): this;
+    listen(effect: ListenEffect<Type>, options?: ListenOptions<Type>): this;
+    private intersectionListen;
+    private mutationListen;
+    private resizeListen;
+    private mediaQueryListen;
+    private idleListen;
+    private messageListen;
+    private recognizeableListen;
+    private documentEventListen;
+    private eventListen;
+    private addEventListeners;
+    private listening;
+    stop(options?: {
+        target?: Element | Document | (Window & typeof globalThis);
+    }): this;
+    private stopped;
+    private getDefaultListenOptions;
+}
+
+type AssociativeArrayTransform<Key, Value, Transformed> = (associativeArray: AssociativeArray<Key, Value>) => Transformed;
+type WithPredicateKey = {
+    predicateKey?: (candidate: any) => boolean;
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/associative-array-value)
+ */
+declare function createValue$1<Key extends any, Value extends any>(key: Key, options?: WithPredicateKey): AssociativeArrayTransform<Key, Value, Value | undefined>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/associative-array-has)
+ */
+declare function createHas$1<Key extends any>(key: Key, options?: WithPredicateKey): AssociativeArrayTransform<Key, any, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/associative-array-keys)
+ */
+declare function createKeys$1<Key extends any>(): AssociativeArrayTransform<Key, any, Key[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/associative-array-values)
+ */
+declare function createValues<Value extends any>(): AssociativeArrayTransform<any, Value, Value[]>;
+
+type ManyTransform<Parameter, Transformed> = (...params: Parameter[]) => Transformed;
+
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/list)
+ */
+declare function createList(): ManyTransform<ClassValue, string>;
+
+type MixColorTransform<Transformed> = (mixColor: MixColor) => Transformed;
+type ColorInterpolationMethod = RectangularColorSpace | PolarColorSpace | `${PolarColorSpace} ${HueInterpolationMethod}`;
+type RectangularColorSpace = 'srgb' | 'srgb-linear' | 'lab' | 'oklab' | 'xyz' | 'xyz-d50' | 'xyz-d65';
+type PolarColorSpace = 'hsl' | 'hwb' | 'lch' | 'oklch';
+type HueInterpolationMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing';
+type CreateMixOptions = {
+    method?: ColorInterpolationMethod;
+    tag?: string;
+    getParent?: () => HTMLElement;
+};
+type MixColor = `${string} ${number}%` | string;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/mix)
+ */
+declare function createMix(color2: MixColor, options?: CreateMixOptions): MixColorTransform<string>;
+
+type GraphStateTransform<Id extends string, Metadata, Transformed> = (state: GraphState<Id, Metadata>) => Transformed;
+
+type GeneratorTransform<Parameter, Yielded> = (param: Parameter) => Generator<Yielded>;
+
+type GraphNodeTransform<Id extends string, Transformed> = (node: GraphNode<Id>) => Transformed;
+type GraphNodeGeneratorTransform<Id extends string, Yielded> = GeneratorTransform<GraphNode<Id>, Yielded>;
+type GraphNodeTupleTransform<Id extends string, Transformed> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Transformed;
+type GraphNodeTupleGeneratorTransform<Id extends string, Yielded> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Generator<Yielded>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/root)
+ */
+declare function createRoot<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeTransform<Id, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/terminal)
+ */
+declare function createTerminal<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeTransform<Id, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/children)
+ */
+declare function createChildren<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorTransform<GraphNode<Id>, GraphNode<Id>>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/indegree)
+ */
+declare function createIndegree<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeTransform<Id, number>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/outdegree)
+ */
+declare function createOutdegree<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeTransform<Id, number>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/incoming)
+ */
+declare function createIncoming<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorTransform<GraphNode<Id>, GraphType extends GraphAsync<Id, Metadata> ? GraphAsyncEdge<Id, Metadata> : GraphEdge<Id, Metadata>>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/outgoing)
+ */
+declare function createOutgoing<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorTransform<GraphNode<Id>, GraphType extends GraphAsync<Id, Metadata> ? GraphAsyncEdge<Id, Metadata> : GraphEdge<Id, Metadata>>;
+declare function createOnlyChild<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeTransform<Id, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/total-siblings)
+ */
+declare function createTotalSiblings<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeTransform<Id, number>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/siblings)
+ */
+declare function createSiblings<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | GraphAsync<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorTransform<GraphNode<Id>, GraphNode<Id>>;
+
+type GraphTransform<Id extends string, Metadata, Transformed> = (graph: Graph<Id, Metadata>) => Transformed;
+type GraphGeneratorTransform<Id extends string, Metadata, Yielded> = GeneratorTransform<Graph<Id, Metadata>, Yielded>;
+
+type GeneratorAsyncTransform<Parameter, Yielded> = (param: Parameter) => AsyncGenerator<Yielded>;
+
+type GraphAsyncTransform<Id extends string, Metadata, Transformed> = (graph: GraphAsync<Id, Metadata>) => Promise<Transformed>;
+type GraphAsyncGeneratorTransform<Id extends string, Metadata, Yielded> = GeneratorTransform<GraphAsync<Id, Metadata>, Yielded>;
+type GraphAsyncGeneratorAsyncTransform<Id extends string, Metadata, Yielded> = GeneratorAsyncTransform<GraphAsync<Id, Metadata>, Yielded>;
+
+type CreatePathConfig<Id extends string, Metadata> = {
+    predicatePathable: (node: GraphNode<Id>) => boolean;
+    toTraversalCandidates: (path: GraphPath<Id>) => Iterable<GraphEdge<Id, Metadata>>;
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-path)
+ */
+declare function createPath$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>, config: CreatePathConfig<Id, Metadata>): GraphStateTransform<Id, Metadata, GraphPath<Id>>;
+
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-layers)
+ */
+declare function createLayers$1<Id extends string>(options?: {
+    createDepthFirstSteps?: CreateStepsOptions$1<Id>;
+}): GraphGeneratorTransform<Id, any, GraphNode<Id>[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-tree)
+ */
+declare function createTree$2<Id extends string>(options?: {
+    createDepthFirstSteps?: CreateStepsOptions$1<Id>;
+}): GraphTransform<Id, any, GraphTree<Id>>;
+type CreateDepthFirstStepsOptions<Id extends string, StateValue = number> = CreateStepsOptions$1<Id> & {
+    getSetStateValue?: (api: {
+        node: GraphNode<Id>;
+        totalChildrenDiscovered: number;
+    }) => StateValue;
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-depth-first-steps)
+ */
+declare function createDepthFirstSteps$2<Id extends string, StateValue = number>(options?: CreateDepthFirstStepsOptions<Id, StateValue>): GraphGeneratorTransform<Id, StateValue, GraphStep<Id, StateValue>>;
+type CreateStepsOptions$1<Id extends string> = {
+    kind?: 'directed acyclic' | 'arborescence';
+    root?: GraphNode<Id>;
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-roots)
+ */
+declare function createRoots<Id extends string, StateValue, GraphType extends Graph<Id, StateValue> | GraphAsync<Id, StateValue> = Graph<Id, StateValue>>(options?: {
+    kind?: 'directed acyclic' | 'arborescence';
+}): (GraphType extends GraphAsync<Id, StateValue> ? GraphAsyncGeneratorTransform<Id, StateValue, GraphNode<Id>> : GraphGeneratorTransform<Id, StateValue, GraphNode<Id>>);
+
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-common-ancestors)
+ */
+declare function createCommonAncestors$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphNodeTupleGeneratorTransform<Id, GraphCommonAncestor<Id>>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-ancestor)
+ */
+declare function createAncestor$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphNodeTupleTransform<Id, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-node-depth-first-steps)
+ */
+declare function createNodeDepthFirstSteps$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>, options?: {
+    createDepthFirstSteps?: CreateDepthFirstStepsOptions<Id, Metadata>;
+}): GraphNodeGeneratorTransform<Id, GraphStep<Id, Metadata>>;
+
+type CreateStepsOptions<Id extends string> = Pick<CreateStepsOptions$1<Id>, 'kind'> & {
+    priorityBranch?: boolean;
+};
+type DecisionTree<Id extends string> = Graph<Id, DecisionTreeStateValue>;
+type DecisionTreeStateValue = boolean;
+declare function createTree$1<Id extends string>(options?: {
+    createDepthFirstSteps?: CreateStepsOptions<Id>;
+}): GraphTransform<Id, any, GraphTree<Id>>;
+declare function createCommonAncestors$1<Id extends string>(...params: Parameters<typeof createCommonAncestors$2<Id, DecisionTreeStateValue>>): GraphNodeTupleGeneratorTransform<Id, GraphCommonAncestor<Id>>;
+declare function createAncestor$1<Id extends string>(...params: Parameters<typeof createAncestor$2<Id, DecisionTreeStateValue>>): GraphNodeTupleTransform<Id, boolean>;
+declare function createNodeDepthFirstSteps$1<Id extends string>(decisionTree: DecisionTree<Id>, options?: {
+    createDepthFirstSteps?: CreateStepsOptions<Id>;
+}): GraphNodeGeneratorTransform<Id, GraphStep<Id, boolean>>;
+declare function createDepthFirstSteps$1<Id extends string>(options: CreateStepsOptions<Id>): GraphGeneratorTransform<Id, boolean, GraphStep<Id, boolean>>;
+declare function createPath$1<Id extends string>(...params: Parameters<typeof createPath$2<Id, DecisionTreeStateValue>>): GraphStateTransform<Id, boolean, GraphPath<Id>>;
+
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-async-layers)
+ */
+declare function createLayers<Id extends string>(options?: {
+    createDepthFirstSteps?: CreateStepsOptions$1<Id>;
+}): GraphAsyncTransform<Id, any, GraphNode<Id>[][]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-async-tree)
+ */
+declare function createTree<Id extends string>(options?: {
+    createDepthFirstSteps?: CreateStepsOptions$1<Id>;
+}): GraphAsyncTransform<Id, any, GraphTree<Id>>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-async-depth-first-steps)
+ */
+declare function createDepthFirstSteps<Id extends string, StateValue = number>(options?: CreateDepthFirstStepsOptions<Id, StateValue>): GraphAsyncGeneratorAsyncTransform<Id, StateValue, GraphStep<Id, StateValue>>;
+
+type GraphAsyncNodeGeneratorAsyncTransform<Id extends string, Yielded> = GeneratorAsyncTransform<GraphNode<Id>, Yielded>;
+type GraphAsyncNodeTupleTransform<Id extends string, Transformed> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Promise<Transformed>;
+type GraphNodeTupleGeneratorAsyncTransform<Id extends string, Yielded> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => AsyncGenerator<Yielded>;
+
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-common-ancestors)
+ */
+declare function createCommonAncestors<Id extends string, Metadata>(directedAcyclicAsync: GraphAsync<Id, Metadata>): GraphNodeTupleGeneratorAsyncTransform<Id, GraphCommonAncestor<Id>>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/Ancestor)
+ */
+declare function createAncestor<Id extends string, Metadata>(directedAcyclicAsync: GraphAsync<Id, Metadata>): GraphAsyncNodeTupleTransform<Id, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/NodeDepthFirstSteps)
+ */
+declare function createNodeDepthFirstSteps<Id extends string, Metadata>(directedAcyclicAsync: GraphAsync<Id, Metadata>, options?: {
+    createDepthFirstSteps?: CreateDepthFirstStepsOptions<Id, Metadata>;
+}): GraphAsyncNodeGeneratorAsyncTransform<Id, GraphStep<Id, Metadata>>;
+
+type GraphAsyncStateTransform<Id extends string, Metadata, Transformed> = (state: GraphState<Id, Metadata>) => Promise<Transformed>;
+
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/directed-acyclic-async-path)
+ */
+declare function createPath<Id extends string, Metadata>(directedAcyclicAsync: GraphAsync<Id, Metadata>, config: CreatePathConfig<Id, Metadata>): GraphAsyncStateTransform<Id, Metadata, GraphPath<Id>>;
+
+type ElementTransform<El extends HTMLElement, Transformed> = (element: El) => Transformed;
+type CreateFocusableOptions = {
+    predicatesElement?: boolean;
+    tabbableSelector?: string;
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/focusable)
+ */
+declare function createFocusable(order: 'first' | 'last', options?: CreateFocusableOptions): ElementTransform<HTMLElement, HTMLElement | undefined>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/computed-style)
+ */
+declare function createComputedStyle(pseudoElement?: string): ElementTransform<HTMLElement, CSSStyleDeclaration>;
+
+type GraphTreeTransform<Id extends string, Transformed> = (tree: GraphTree<Id>) => Transformed;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/find)
+ */
+declare function createFind<Id extends string>(node: GraphNode<Id>): GraphTreeTransform<Id, GraphTreeNode<Id>>;
+
+type KeyboardEventTransform<Transformed> = (keyboardEvent: KeyboardEvent) => Transformed;
+type CreateKeycomboMatchOptions = Omit<CreateKeycomboMatchOptions$1, 'toAliases'> & {
+    toAliases?: (descriptor: KeyboardEventDescriptor) => string[];
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/keycombo-match)
+ */
+declare const createKeycomboMatch: (keycombo: string, options?: CreateKeycomboMatchOptions) => KeyboardEventTransform<boolean>;
+
+type NumberTransform<Transformed> = (number: number) => Transformed;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/clamp)
+ */
+declare function createClamp(min: number, max: number): NumberTransform<number>;
+type Potentiality<Outcome> = {
+    outcome: Outcome;
+    probability: number;
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/determine)
+ */
+declare function createDetermine<Outcome>(potentialities: Potentiality<Outcome>[]): NumberTransform<Outcome>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/greater)
+ */
+declare function createGreater(threshold: number): NumberTransform<boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/greater-or-equal)
+ */
+declare function createGreaterOrEqual(threshold: number): NumberTransform<boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/less-or-equal)
+ */
+declare function createLessOrEqual(threshold: number): NumberTransform<boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/less)
+ */
+declare function createLess(threshold: number): NumberTransform<boolean>;
+
+type ObjectTransform<Type extends Record<any, any>, Transformed> = (transform: Type) => Transformed;
+type ValueOf<Type> = Type[keyof Type];
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/value)
+ */
+declare function createValue<Type extends Record<any, any>>(key: keyof Type): ObjectTransform<Type, ValueOf<Type>>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/has)
+ */
+declare function createHas<Type extends Record<any, any>>(key: keyof Type): ObjectTransform<Type, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/keys)
+ */
+declare function createKeys<Type extends Record<any, any>>(): ObjectTransform<Type, (keyof Type)[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/entries)
+ */
+declare function createEntries<Type extends Record<any, any>>(): ObjectTransform<Type, [keyof Type, ValueOf<Type>][]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/every)
+ */
+declare function createEvery<Type extends Record<any, any>>(predicate: (key: keyof Type, value: ValueOf<Type>) => unknown): ObjectTransform<Type, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/some)
+ */
+declare function createSome<Type extends Record<any, any>>(predicate: (key: keyof Type, value: ValueOf<Type>) => unknown): ObjectTransform<Type, boolean>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/deep-merge)
+ */
+declare function createDeepMerge<Type extends Record<any, any>>(override?: Type): ObjectTransform<Type, Type>;
+
+type StringTransform<Transformed> = (string: string) => Transformed;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/clip)
+ */
+declare function createClip(content: string | RegExp): StringTransform<string>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/slug)
+ */
+declare function createSlug(options?: Options): StringTransform<string>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/sanitize)
+ */
+declare function createSanitize(options?: Config): StringTransform<string>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/number)
+ */
+declare function createNumber(options?: {
+    radix?: number;
+}): StringTransform<number>;
+type CreateResultsOptions<Candidate extends string | object, MatchData extends boolean> = Omit<FullOptions<Candidate>, 'returnMatchData'> & {
+    returnMatchData?: MatchData;
+};
+declare function createResults<Candidate extends string | object, MatchData extends boolean = false>(candidates: Candidate[], options?: (CreateResultsOptions<Candidate, MatchData> | ((api: {
+    sortKind: typeof sortKind;
+}) => CreateResultsOptions<Candidate, MatchData>))): StringTransform<MatchData extends true ? MatchData<Candidate>[] : Candidate[]>;
+
+type ToGraphYielded = {
+    node: GraphNode<string>;
+    edge: PartialGraphEdge | undefined;
+};
+type PartialGraphEdge = Omit<GraphEdge<string, unknown>, 'predicateShouldTraverse'>;
+type CreateGraphOptions<TreeNode> = {
+    toId?: (node: TreeNode) => string;
+    toChildren?: (node: TreeNode) => TreeNode[];
+};
+/**
+ * [Docs](https://baleada.dev/docs/logic/pipes/graph)
+ */
+declare function createGraph<TreeNode>(options?: CreateGraphOptions<TreeNode>): GeneratorTransform<TreeNode[], ToGraphYielded>;
+
+type AnimateableKeyframe<Value extends string | number | any[]> = {
+    progress: number;
+    properties: {
+        [key: string]: AnimateableValue<Value>;
+    };
+    timing?: AnimateableTiming;
+};
+type AnimateableValue<Value extends string | number | any[]> = Value extends `${string} ${number}%` ? never : (Value | number | any[]);
+type AnimateableOptions = {
+    duration?: number;
+    timing?: AnimateableTiming;
+    iterations?: number | true;
+    alternates?: boolean;
+};
+type AnimateableTiming = [number, number, number, number];
+type AnimateFrameEffect = (frame?: AnimateFrame) => any;
+type AnimateFrame = {
+    properties: {
+        [key: string]: {
+            progress: {
+                time: number;
+                animation: number;
+            };
+            interpolated: number | string | any[];
+        };
+    };
+    timestamp: number;
+};
+type AnimateOptions = {
+    interpolate?: {
+        color?: CreateMixOptions;
+    };
+};
+type AnimateableStatus = 'ready' | 'playing' | 'played' | 'reversing' | 'reversed' | 'paused' | 'sought' | 'stopped';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/animateable)
+ */
+declare class Animateable<Value extends string | number | any[]> {
+    private initialDuration;
+    private iterationLimit;
+    private alternates;
+    private controlPoints;
+    private reversedControlPoints;
+    private toAnimationProgress;
+    private reversedToAnimationProgress;
+    private playCache;
+    private reverseCache;
+    private pauseCache;
+    private seekCache;
+    private alternateCache;
+    private visibilitychange;
+    private getEaseables;
+    private getReversedEaseables;
+    constructor(keyframes: AnimateableKeyframe<Value>[], options?: AnimateableOptions);
+    private computedStatus;
+    private ready;
+    private computedTime;
+    private resetTime;
+    private computedProgress;
+    private resetProgress;
+    private computedIterations;
+    private resetIterations;
+    get keyframes(): AnimateableKeyframe<Value>[];
+    set keyframes(keyframes: AnimateableKeyframe<Value>[]);
+    get playbackRate(): number;
+    set playbackRate(playbackRate: number);
+    get status(): AnimateableStatus;
+    get iterations(): number;
+    get request(): number;
+    get time(): {
+        elapsed: number;
+        remaining: number;
+    };
+    get progress(): {
+        time: number;
+        animation: number;
+    };
+    private computedKeyframes;
+    private reversedKeyframes;
+    private properties;
+    private easeables;
+    private reversedEaseables;
+    setKeyframes(keyframes: AnimateableKeyframe<Value>[]): this;
+    private computedPlaybackRate;
+    private duration;
+    private totalTimeInvisible;
+    setPlaybackRate(playbackRate: number): this;
+    play(effect: AnimateFrameEffect, options?: AnimateOptions): this;
+    private playing;
+    private played;
+    reverse(effect: AnimateFrameEffect, options?: AnimateOptions): this;
+    private reversing;
+    private reversed;
+    private invisibleAt;
+    private listenForVisibilitychange;
+    private computedRequest;
+    private createAnimate;
+    private startTime;
+    private setStartTimeAndStatus;
+    private getToAnimationProgress;
+    private getFrame;
+    private recurse;
+    pause(): this;
+    private paused;
+    private cancelAnimate;
+    seek(timeProgress: number, options?: {
+        effect?: AnimateFrameEffect;
+    } & AnimateOptions): this;
+    private sought;
+    restart(): this;
+    stop(): this;
     private stopped;
 }
+declare const linear: AnimateableKeyframe<any>['timing'];
+declare const materialStandard: AnimateableKeyframe<any>['timing'];
+declare const materialDecelerated: AnimateableKeyframe<any>['timing'];
+declare const materialAccelerated: AnimateableKeyframe<any>['timing'];
+declare const verouEase: AnimateableKeyframe<any>['timing'];
+declare const verouEaseIn: AnimateableKeyframe<any>['timing'];
+declare const verouEaseOut: AnimateableKeyframe<any>['timing'];
+declare const verouEaseInOut: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInSine: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutSine: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutSine: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInQuad: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutQuad: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutQuad: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInCubic: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutCubic: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutCubic: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInQuart: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInQuint: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutQuint: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutQuint: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInExpo: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutExpo: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutExpo: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInCirc: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutCirc: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutCirc: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInBack: AnimateableKeyframe<any>['timing'];
+declare const easingsNetOutBack: AnimateableKeyframe<any>['timing'];
+declare const easingsNetInOutBack: AnimateableKeyframe<any>['timing'];
 
 type BroadcastableOptions = {
     name?: string;
 };
 type BroadcastableStatus = 'ready' | 'broadcasting' | 'broadcasted' | 'errored' | 'stopped';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/broadcastable)
+ */
 declare class Broadcastable<State> {
     private name;
     constructor(state: State, options?: BroadcastableOptions);
@@ -359,6 +965,9 @@ type CompleteOptions = {
         after: string;
     }) => Completeable['selection']);
 };
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/completeable)
+ */
 declare class Completeable {
     private segmentFrom;
     private segmentTo;
@@ -408,6 +1017,9 @@ declare class Completeable {
 
 type CopyableOptions = Record<never, never>;
 type CopyableStatus = 'ready' | 'copying' | 'copied' | 'errored';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/copyable)
+ */
 declare class Copyable {
     private computedIsClipboardText;
     private copyListenable;
@@ -442,6 +1054,9 @@ type DelayableOptions = {
 };
 type DelayableEffect = (timestamp: number) => any;
 type DelayableStatus = 'ready' | 'delaying' | 'delayed' | 'paused' | 'sought' | 'stopped';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/delayable)
+ */
 declare class Delayable {
     private animateable;
     constructor(effect: DelayableEffect, options?: DelayableOptions);
@@ -472,15 +1087,18 @@ declare class Delayable {
     private stopped;
 }
 
-type DrawableState = ReturnType<typeof getStroke>;
+type DrawableStroke = ReturnType<typeof getStroke>;
 type DrawableOptions = {
-    toD?: (stroke: DrawableState) => string;
+    toD?: (stroke: DrawableStroke) => string;
 };
 type DrawableStatus = 'ready' | 'drawing' | 'drawn';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/drawable)
+ */
 declare class Drawable {
     private computedD;
     private toD;
-    constructor(stroke: DrawableState, options?: DrawableOptions);
+    constructor(stroke: DrawableStroke, options?: DrawableOptions);
     computedStatus: DrawableStatus;
     private ready;
     get stroke(): number[][];
@@ -488,7 +1106,7 @@ declare class Drawable {
     get status(): DrawableStatus;
     get d(): string;
     private computedStroke;
-    setStroke(stroke: DrawableState): this;
+    setStroke(stroke: DrawableStroke): this;
     draw(points: Parameters<typeof getStroke>[0], options?: StrokeOptions): this;
     private drawing;
     private drawn;
@@ -497,32 +1115,41 @@ declare function toD(stroke: number[][]): string;
 declare function toFlattenedD(stroke: number[][]): string;
 
 type ResolveableOptions = Record<never, never>;
-type ResolveableGetPromise<Value> = (...args: any[]) => (Promise<Value> | Promise<Value>[]);
 type ResolveableStatus = 'ready' | 'resolving' | 'resolved' | 'errored';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/resolveable)
+ */
 declare class Resolveable<Value> {
-    constructor(getPromise: ResolveableGetPromise<Value>, options?: ResolveableOptions);
+    constructor(getPromise: () => Promise<Value>, options?: ResolveableOptions);
     private computedStatus;
     private ready;
-    get getPromise(): (...args: any[]) => Promise<Value> | Promise<Value>[];
-    set getPromise(getPromise: (...args: any[]) => Promise<Value> | Promise<Value>[]);
+    get getPromise(): () => Promise<Value>;
+    set getPromise(getPromise: () => Promise<Value>);
     get status(): ResolveableStatus;
-    get value(): Error | Value | Value[];
+    get value(): Value;
+    get error(): Error;
     private computedGetPromise;
-    setGetPromise(getPromise: (...args: any[]) => (Promise<Value> | Promise<Value>[])): this;
+    setGetPromise(getPromise: () => Promise<Value>): this;
     private computedValue;
-    resolve(...args: any[]): Promise<this>;
+    private computedError;
+    resolve(): Promise<this>;
     private resolving;
     private resolved;
     private errored;
 }
 
 type FetchableOptions = {
-    ky?: Options | ((api: ToKyOptionsApi) => Options);
+    ky?: Options$1 | ((api: ToKyOptionsApi) => Options$1);
 };
 type ToKyOptionsApi = {
     stop: typeof ky['stop'];
 };
 type FetchableStatus = 'ready' | 'fetching' | 'fetched' | 'retrying' | 'aborted' | 'errored';
+type FetchOptions = Omit<Options$1, 'signal'>;
+type FetchMethodOptions = Omit<FetchOptions, 'method'>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/fetchable)
+ */
 declare class Fetchable {
     private computedArrayBuffer;
     private computedBlob;
@@ -534,14 +1161,14 @@ declare class Fetchable {
     private ready;
     get resource(): string;
     set resource(resource: string);
+    get status(): FetchableStatus;
     private computedKy;
     get ky(): ky_distribution_types_ky.KyInstance;
     private computedAbortController;
     get abortController(): AbortController;
-    get status(): FetchableStatus;
-    get response(): Response;
     private computedRetryCount;
     get retryCount(): number;
+    get response(): Response;
     get error(): Error;
     get arrayBuffer(): Resolveable<ArrayBuffer>;
     get blob(): Resolveable<Blob>;
@@ -552,24 +1179,27 @@ declare class Fetchable {
     setResource(resource: string): this;
     private computedResponse;
     private computedError;
-    fetch(options?: Options): Promise<this>;
+    fetch(options?: FetchOptions): Promise<this>;
     private fetching;
     private retrying;
     private fetched;
     private aborted;
     private errored;
-    get(options?: Options): Promise<this>;
-    patch(options?: Options): Promise<this>;
-    post(options?: Options): Promise<this>;
-    put(options?: Options): Promise<this>;
-    delete(options?: Options): Promise<this>;
-    head(options?: Options): Promise<this>;
+    get(options?: FetchMethodOptions): Promise<this>;
+    patch(options?: FetchMethodOptions): Promise<this>;
+    post(options?: FetchMethodOptions): Promise<this>;
+    put(options?: FetchMethodOptions): Promise<this>;
+    delete(options?: FetchMethodOptions): Promise<this>;
+    head(options?: FetchMethodOptions): Promise<this>;
     abort(): this;
 }
 
 type FullscreenableOptions = Record<never, never>;
 type FullscreenableGetElement<ElementType> = ((...args: any[]) => ElementType);
 type FullscreenableStatus = 'ready' | 'fullscreened' | 'errored' | 'exited';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/fullscreenable)
+ */
 declare class Fullscreenable<ElementType extends Element> {
     constructor(getElement: FullscreenableGetElement<ElementType>, options?: FullscreenableOptions);
     private computedStatus;
@@ -591,21 +1221,26 @@ declare class Fullscreenable<ElementType extends Element> {
 }
 
 type GrantableOptions = Record<never, never>;
-type GrantableStatus = 'ready' | 'querying' | 'queried' | 'errored';
-declare class Grantable<DescriptorType extends PermissionDescriptor> {
-    constructor(descriptor: DescriptorType, options?: GrantableOptions);
+type GrantableStatus = 'ready' | 'granting' | 'granted' | 'errored';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/grantable)
+ */
+declare class Grantable {
+    constructor(descriptor: PermissionDescriptor, options?: GrantableOptions);
     private computedStatus;
     private ready;
-    get descriptor(): DescriptorType;
-    set descriptor(descriptor: DescriptorType);
-    get permission(): Error | PermissionStatus;
+    get descriptor(): PermissionDescriptor;
+    set descriptor(descriptor: PermissionDescriptor);
+    get permission(): PermissionStatus;
+    get error(): Error;
     get status(): GrantableStatus;
     private computedDescriptor;
-    setDescriptor(descriptor: DescriptorType): this;
+    setDescriptor(descriptor: PermissionDescriptor): this;
     private computedPermission;
-    query(): Promise<this>;
-    private querying;
-    private queried;
+    private computedError;
+    grant(): Promise<this>;
+    private granting;
+    private granted;
     private errored;
 }
 
@@ -620,6 +1255,9 @@ type NextAndPreviousOptions = {
     distance?: number;
     loops?: boolean;
 };
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/navigateable)
+ */
 declare class Navigateable<Item> {
     constructor(array: Item[], options?: NavigateableOptions);
     private computedStatus;
@@ -657,6 +1295,9 @@ type PickOptions = {
     replace?: 'none' | 'all' | 'fifo' | 'lifo';
     allowsDuplicates?: boolean;
 };
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/pickable)
+ */
 declare class Pickable<Item> {
     constructor(array: Item[], options?: PickableOptions);
     private computedStatus;
@@ -673,11 +1314,11 @@ declare class Pickable<Item> {
     get last(): number;
     get oldest(): number;
     get newest(): number;
-    get status(): PickableStatus;
     get items(): Item[];
     private toItems;
     computedMultiple: boolean;
     get multiple(): boolean;
+    get status(): PickableStatus;
     private toPossiblePicks;
     setArray(array: Item[]): this;
     setPicks(indexOrIndices: number | number[]): this;
@@ -689,59 +1330,24 @@ declare class Pickable<Item> {
     private omitted;
 }
 
-type SanitizeableOptions = Config;
-type SanitizeableStatus = 'ready' | 'sanitized';
-declare class Sanitizeable {
-    private domPurifyConfig;
-    constructor(html: string, options?: Config);
-    private computedDompurify;
-    private computedStatus;
-    private ready;
-    get html(): string;
-    set html(html: string);
-    get dompurify(): DOMPurifyI;
-    get status(): SanitizeableStatus;
-    private computedHtml;
-    setHtml(html: string): this;
-    sanitize(): this;
-    private sanitized;
-}
-
-type SearchableOptions<Item> = FullOptions<Item>;
-type SearchableStatus = 'ready' | 'searched';
-declare class Searchable<Item extends string | object> {
-    private searcherOptions;
-    private computedResults;
-    constructor(candidates: Item[], options?: FullOptions<Item>);
-    private computedStatus;
-    private ready;
-    private computedCandidates;
-    get candidates(): Item[];
-    set candidates(candidates: Item[]);
-    get results(): MatchData<Item>[] | Item[];
-    get searcher(): Searcher<Item, FullOptions<Item>>;
-    get status(): SearchableStatus;
-    private computedSearcher;
-    setCandidates(candidates: Item[]): this;
-    search(query: string, options?: FullOptions<Item>): this;
-    private searched;
-}
-
 type ShareableOptions = Record<never, never>;
 type ShareableStatus = 'ready' | 'sharing' | 'shared' | 'errored';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/shareable)
+ */
 declare class Shareable {
-    constructor(state: ShareData, options?: ShareableOptions);
+    constructor(shareData: ShareData, options?: ShareableOptions);
     private computedStatus;
     private ready;
-    get state(): ShareData;
-    set state(state: ShareData);
+    get shareData(): ShareData;
+    set shareData(shareData: ShareData);
     get status(): ShareableStatus;
     private computedCan;
     get can(): Resolveable<boolean>;
     private computedError;
     get error(): Error;
     private computedState;
-    setState(state: ShareData): this;
+    setShareData(shareData: ShareData): this;
     share(): Promise<this>;
     private sharing;
     private shared;
@@ -753,6 +1359,9 @@ type StoreableOptions = {
     statusKeySuffix?: string;
 };
 type StoreableStatus = 'ready' | 'constructing' | 'stored' | 'errored' | 'removed';
+/**
+ * [Docs](https://baleada.dev/docs/logic/classes/storeable)
+ */
 declare class Storeable<String extends string> {
     private kind;
     private statusKeySuffix;
@@ -780,101 +1389,37 @@ declare class Storeable<String extends string> {
     removeStatus(): this;
 }
 
-type AnyFn<Returned> = (param: any) => Returned;
-declare function createClone<Any>(): AnyFn<Any>;
-declare function createEqual(compared: any): AnyFn<boolean>;
-
-type ArrayFn<Item, Returned> = (array: Item[]) => Returned;
-declare function createConcat<Item>(...arrays: Item[][]): ArrayFn<Item, Item[]>;
-declare function createFilter<Item>(predicate: (item: Item, index: number) => boolean): ArrayFn<Item, Item[]>;
-declare function createInsert<Item>(item: Item, index: number): ArrayFn<Item, Item[]>;
-declare function createMap<Item, Transformed = Item>(transform: (item: Item, index: number) => Transformed): ArrayFn<Item, Transformed[]>;
-declare function createReduce<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Accumulator, initialValue?: Accumulator): (array: Item[]) => Accumulator;
-declare function createRemove<Item>(index: number): ArrayFn<Item, Item[]>;
-declare function createReorder<Item>(from: {
-    start: number;
-    itemCount: number;
-} | number, to: number): ArrayFn<Item, Item[]>;
-declare function createReplace<Item>(index: number, replacement: Item): ArrayFn<Item, Item[]>;
-declare function createReverse<Item>(): ArrayFn<Item, Item[]>;
-declare function createSlice<Item>(from: number, to?: number): ArrayFn<Item, Item[]>;
-declare function createSort<Item>(compare?: (itemA: Item, itemB: Item) => number): ArrayFn<Item, Item[]>;
-declare function createSwap<Item>(indices: [number, number]): ArrayFn<Item, Item[]>;
-declare function createUnique<Item>(): ArrayFn<Item, Item[]>;
-
-type ArrayAsyncFn<Item, Returned> = (array: Item[]) => Promise<Returned>;
-declare function createFilterAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncFn<Item, Item[]>;
-declare function createFindAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncFn<Item, Item | undefined>;
-declare function createFindIndexAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncFn<Item, number>;
-declare function createForEachAsync<Item>(forEach: (item: Item, index: number) => any): ArrayAsyncFn<Item, any>;
-declare function createMapAsync<Item, Mapped>(transform: (item: Item, index: number) => Promise<Mapped>): ArrayAsyncFn<Item, Mapped[]>;
-declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
-
-type StringFn<Returned> = (string: string) => Returned;
-declare function createClip(required: string | RegExp): StringFn<string>;
-declare function createSlug(options?: Options$1): StringFn<string>;
-
-type NumberFn<Returned> = (number: number) => Returned;
-declare function createClamp(min: number, max: number): NumberFn<number>;
-type Potentiality<Outcome> = {
-    outcome: Outcome;
-    probability: number;
-};
-declare function createDetermine<Outcome>(potentialities: Potentiality<Outcome>[]): NumberFn<Outcome>;
-
-type ObjectFn<Key extends string | number | symbol, Value, Returned> = (transform: Record<Key, Value>) => Returned;
-declare function createEntries<Key extends string | number | symbol, Value>(): ObjectFn<Key, Value, [Key, Value][]>;
-declare function createKeys<Key extends string | number | symbol>(): ObjectFn<Key, any, Key[]>;
-declare function createEvery<Key extends string | number | symbol, Value>(predicate: (key: Key, value: Value) => unknown): ObjectFn<Key, Value, boolean>;
-declare function createSome<Key extends string | number | symbol, Value>(predicate: (key: Key, value: Value) => unknown): ObjectFn<Key, Value, boolean>;
+type ArrayAsyncEffect<Item> = (array: Item[]) => Promise<Item[]>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/for-each-async)
+ */
+declare function createForEachAsync<Item>(effect: (item: Item, index: number) => any): ArrayAsyncEffect<Item>;
 
-type MapFn<Key, Value, Returned> = (transform: Map<Key, Value>) => Returned;
-declare function createRename<Key, Value>(from: Key, to: Key): MapFn<Key, Value, Map<Key, Value>>;
+type ObjectEffect<Key extends string | number | symbol, Value> = (object: Record<Key, Value>) => Record<Key, Value>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/set)
+ */
+declare function createSet<Key extends string | number | symbol, Value extends any>(key: Key, value: Value): ObjectEffect<Key, Value>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/delete)
+ */
+declare function createDelete<Key extends string | number | symbol, Value extends any>(key: Key): ObjectEffect<Key, Value>;
+/**
+ * [Docs](https://baleada.dev/docs/logic/links/clear)
+ */
+declare function createClear<Key extends string | number | symbol, Value extends any>(): ObjectEffect<Key, Value>;
 
-type ElementFn<El extends HTMLElement, Returned> = (element: El) => Returned;
-type CreateFocusableOptions = {
-    elementIsCandidate?: boolean;
-    tabbableSelector?: string;
-};
-declare function createFocusable(order: 'first' | 'last', options?: CreateFocusableOptions): ElementFn<HTMLElement, HTMLElement | undefined>;
-
-type AssociativeArrayEntries<Key, Value> = [Key, Value][];
-declare function defineAssociativeArrayEntries<Key, Value>(entries: AssociativeArrayEntries<Key, Value>): AssociativeArrayEntries<Key, Value>;
+declare function createDepthPathConfig<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata> | GraphAsync<Id, Metadata>): CreatePathConfig<Id, Metadata>;
 
-type AssociativeArray<Key extends any, Value extends any> = {
-    toValue: (key: Key) => Value | undefined;
-    set: (key: Key, value: Value) => void;
-    predicateHas: (key: Key) => boolean;
-    clear: () => void;
-    delete: (key: Key) => boolean;
-    toKeys: () => Key[];
-    toValues: () => Value[];
-    toEntries: () => AssociativeArrayEntries<Key, Value>;
-};
-type AssociativeArrayOptions<Key extends any> = {
-    initial?: AssociativeArrayEntries<Key, any>;
-    createPredicateKey?: (query: Key) => (candidate: Key) => boolean;
-};
-declare function createAssociativeArray<Key extends any, Value extends any>(options?: AssociativeArrayOptions<Key>): {
-    toValue: (key: Key) => Value;
-    set: (key: Key, value: Value) => void;
-    predicateHas: (key: Key) => boolean;
-    clear: () => void;
-    delete: (key: Key) => boolean;
-    toKeys: () => Key[];
-    toValues: () => Value[];
-    toEntries: () => AssociativeArrayEntries<Key, Value>;
-};
+declare function createBreadthPathConfig<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata> | GraphAsync<Id, Metadata>): CreatePathConfig<Id, Metadata>;
 
 type KeypressType = 'keydown' | 'keyup' | 'visibilitychange';
 type KeypressMetadata = {
-    pressed: string;
+    keycombo: string;
 } & KeyboardTimeMetadata;
-type KeypressOptions = {
+type KeypressOptions = CreateKeycomboMatchOptions$1 & {
     minDuration?: number;
     preventsDefaultUnlessDenied?: boolean;
-    toDownKeys?: CreatePredicateKeycomboDownOptions['toDownKeys'];
-    toAliases?: CreatePredicateKeycomboMatchOptions$1['toAliases'];
     onDown?: KeypressHook;
     onUp?: KeypressHook;
     onVisibilitychange?: KeypressHook;
@@ -886,16 +1431,18 @@ declare function createKeypress(keycomboOrKeycombos: string | string[], options?
     keyup: RecognizeableEffect<"keyup", KeypressMetadata>;
     visibilitychange: RecognizeableEffect<"visibilitychange", KeypressMetadata>;
 };
+declare class Keypress extends Listenable<KeypressType, KeypressMetadata> {
+    constructor(keycomboOrKeycombos: string | string[], options?: KeypressOptions);
+    get metadata(): KeypressMetadata;
+}
 
 type KeyreleaseType = 'keydown' | 'keyup' | 'visibilitychange';
 type KeyreleaseMetadata = {
-    released: string;
+    keycombo: string;
 } & KeyboardTimeMetadata;
-type KeyreleaseOptions = {
+type KeyreleaseOptions = CreateKeycomboMatchOptions$1 & {
     minDuration?: number;
     preventsDefaultUnlessDenied?: boolean;
-    toDownKeys?: CreatePredicateKeycomboDownOptions['toDownKeys'];
-    toAliases?: CreatePredicateKeycomboMatchOptions$1['toAliases'];
     onDown?: KeyreleaseHook;
     onUp?: KeyreleaseHook;
     onVisibilitychange?: KeyreleaseHook;
@@ -907,44 +1454,57 @@ declare function createKeyrelease(keycomboOrKeycombos: string | string[], option
     keyup: RecognizeableEffect<"keyup", KeyreleaseMetadata>;
     visibilitychange: RecognizeableEffect<"visibilitychange", KeyreleaseMetadata>;
 };
+declare class Keyrelease extends Listenable<KeyreleaseType, KeyreleaseMetadata> {
+    constructor(keycomboOrKeycombos: string | string[], options?: KeyreleaseOptions);
+    get metadata(): KeyreleaseMetadata;
+}
 
 type KeychordType = 'keydown' | 'keyup' | 'visibilitychange';
 type KeychordMetadata = {
     played: ({
-        released: string;
+        keycombo: string;
     } & KeyboardTimeMetadata)[];
 };
-type KeychordOptions = {
+type KeychordOptions = CreateKeycomboMatchOptions$1 & {
     minDuration?: number;
     maxInterval?: number;
     preventsDefaultUnlessDenied?: boolean;
-    toDownKeys?: CreatePredicateKeycomboDownOptions['toDownKeys'];
-    toAliases?: CreatePredicateKeycomboMatchOptions$1['toAliases'];
     onDown?: KeychordHook;
     onUp?: KeychordHook;
     onVisibilitychange?: KeychordHook;
 };
 type KeychordHook = (api: KeychordHookApi) => any;
 type KeychordHookApi = HookApi<KeychordType, KeychordMetadata>;
-declare function createKeychord(keychord: string, options?: KeychordOptions): {
+declare function createKeychord(keycombos: string, options?: KeychordOptions): {
     keydown: RecognizeableEffect<"keydown", KeychordMetadata>;
     keyup: RecognizeableEffect<"keyup", KeychordMetadata>;
     visibilitychange: RecognizeableEffect<"visibilitychange", KeychordMetadata>;
 };
+declare class Keychord extends Listenable<KeychordType, KeychordMetadata> {
+    constructor(keycombos: string, options?: KeychordOptions);
+    get metadata(): KeychordMetadata;
+}
 
 type KonamiType = KeychordType;
 type KonamiMetadata = KeychordMetadata;
 type KonamiOptions = KeychordOptions;
 type KonamiHook = KeychordHook;
 type KonamiHookApi = KeychordHookApi;
-declare function createKonami(options?: KonamiOptions): RecognizeableOptions<KonamiType, KonamiMetadata>['effects'];
+declare function createKonami(options?: KonamiOptions): {
+    keydown: RecognizeableEffect<"keydown", KeychordMetadata>;
+    keyup: RecognizeableEffect<"keyup", KeychordMetadata>;
+    visibilitychange: RecognizeableEffect<"visibilitychange", KeychordMetadata>;
+};
+declare class Konami extends Listenable<KonamiType, KonamiMetadata> {
+    constructor(options?: KonamiOptions);
+    get metadata(): KeychordMetadata;
+}
 
 type MousepressType = 'mousedown' | 'mouseleave' | 'mouseup';
 type MousepressMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
 type MousepressOptions = {
     minDuration?: number;
     minDistance?: number;
-    getMousemoveTarget?: (event: MouseEvent) => HTMLElement;
     onDown?: MousepressHook;
     onMove?: MousepressHook;
     onLeave?: MousepressHook;
@@ -952,7 +1512,18 @@ type MousepressOptions = {
 };
 type MousepressHook = (api: MousepressHookApi) => any;
 type MousepressHookApi = HookApi<MousepressType, MousepressMetadata>;
-declare function createMousepress(options?: MousepressOptions): RecognizeableOptions<MousepressType, MousepressMetadata>['effects'];
+/**
+ * [Docs](https://baleada.dev/docs/logic/factories/mousepress)
+ */
+declare function createMousepress(options?: MousepressOptions): {
+    mousedown: RecognizeableEffect<"mousedown", MousepressMetadata>;
+    mouseleave: RecognizeableEffect<"mouseleave", MousepressMetadata>;
+    mouseup: RecognizeableEffect<"mouseup", MousepressMetadata>;
+};
+declare class Mousepress extends Listenable<MousepressType, MousepressMetadata> {
+    constructor(options?: MousepressOptions);
+    get metadata(): MousepressMetadata;
+}
 
 type MousereleaseType = 'mousedown' | 'mouseleave' | 'mouseup';
 type MousereleaseMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
@@ -960,7 +1531,6 @@ type MousereleaseOptions = {
     minDuration?: number;
     minDistance?: number;
     minVelocity?: number;
-    getMousemoveTarget?: (event: MouseEvent) => HTMLElement;
     onDown?: MousereleaseHook;
     onMove?: MousereleaseHook;
     onLeave?: MousereleaseHook;
@@ -968,7 +1538,18 @@ type MousereleaseOptions = {
 };
 type MousereleaseHook = (api: MousereleaseHookApi) => any;
 type MousereleaseHookApi = HookApi<MousereleaseType, MousereleaseMetadata>;
-declare function createMouserelease(options?: MousereleaseOptions): RecognizeableOptions<MousereleaseType, MousereleaseMetadata>['effects'];
+/**
+ * [Docs](https://baleada.dev/docs/logic/factories/mouserelease)
+ */
+declare function createMouserelease(options?: MousereleaseOptions): {
+    mousedown: RecognizeableEffect<"mousedown", MousereleaseMetadata>;
+    mouseleave: RecognizeableEffect<"mouseleave", MousereleaseMetadata>;
+    mouseup: RecognizeableEffect<"mouseup", MousereleaseMetadata>;
+};
+declare class Mouserelease extends Listenable<MousereleaseType, MousereleaseMetadata> {
+    constructor(options?: MousereleaseOptions);
+    get metadata(): MousereleaseMetadata;
+}
 
 type TouchpressType = 'touchstart' | 'touchmove' | 'touchcancel' | 'touchend';
 type TouchpressMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
@@ -982,7 +1563,16 @@ type TouchpressOptions = {
 };
 type TouchpressHook = (api: TouchpressHookApi) => any;
 type TouchpressHookApi = HookApi<TouchpressType, TouchpressMetadata>;
-declare function createTouchpress(options?: TouchpressOptions): RecognizeableOptions<TouchpressType, TouchpressMetadata>['effects'];
+declare function createTouchpress(options?: TouchpressOptions): {
+    touchstart: RecognizeableEffect<"touchstart", TouchpressMetadata>;
+    touchmove: RecognizeableEffect<"touchmove", TouchpressMetadata>;
+    touchcancel: RecognizeableEffect<"touchcancel", TouchpressMetadata>;
+    touchend: RecognizeableEffect<"touchend", TouchpressMetadata>;
+};
+declare class Touchpress extends Listenable<TouchpressType, TouchpressMetadata> {
+    constructor(options?: TouchpressOptions);
+    get metadata(): TouchpressMetadata;
+}
 
 type TouchreleaseType = 'touchstart' | 'touchmove' | 'touchcancel' | 'touchend';
 type TouchreleaseMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
@@ -997,256 +1587,15 @@ type TouchreleaseOptions = {
 };
 type TouchreleaseHook = (api: TouchreleaseHookApi) => any;
 type TouchreleaseHookApi = HookApi<TouchreleaseType, TouchreleaseMetadata>;
-declare function createTouchrelease(options?: TouchreleaseOptions): RecognizeableOptions<TouchreleaseType, TouchreleaseMetadata>['effects'];
-
-type KeyStatusKey = {
-    key?: string;
-    code?: string;
-};
-
-type Expand<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-
-type CreatePredicateKeycomboDownOptions = {
-    toDownKeys?: (alias: string) => KeyStatusKey[];
-};
-
-type CreatePredicateKeycomboMatchOptions$1 = CreatePredicateKeycomboDownOptions & {
-    toAliases?: (key: KeyStatusKey) => string[];
-};
-
-type Direction = 'up' | 'upRight' | 'right' | 'downRight' | 'down' | 'downLeft' | 'left' | 'upLeft';
-
-type HookApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
-    status: RecognizeableStatus;
-    metadata: Metadata;
-    sequence: ListenEffectParam<Type>[];
-};
-
-type PolarCoordinates = {
-    distance: number;
-    angle: {
-        radians: number;
-        degrees: number;
-    };
-};
-
-type KeyboardTimeMetadata = {
-    times: {
-        start: number;
-        end: number;
-    };
-    duration: number;
-};
-
-type PointerStartMetadata = {
-    points: {
-        start: {
-            x: number;
-            y: number;
-        };
-        end: {
-            x: number;
-            y: number;
-        };
-    };
-};
-
-type PointerTimeMetadata = {
-    times: {
-        start: number;
-        end: number;
-    };
-    duration: number;
-    velocity: number;
-};
-
-type PointerMoveMetadata = {
-    distance: {
-        straight: {
-            fromStart: PolarCoordinates['distance'];
-            fromPrevious: PolarCoordinates['distance'];
-        };
-        horizontal: {
-            fromStart: PolarCoordinates['distance'];
-            fromPrevious: PolarCoordinates['distance'];
-        };
-        vertical: {
-            fromStart: PolarCoordinates['distance'];
-            fromPrevious: PolarCoordinates['distance'];
-        };
-    };
-    angle: {
-        fromPrevious: PolarCoordinates['angle'];
-        fromStart: PolarCoordinates['angle'];
-    };
-    direction: {
-        fromPrevious: Direction;
-        fromStart: Direction;
-    };
-};
-
-type Graph<Id extends string, Metadata> = {
-    nodes: GraphNode<Id>[];
-    edges: GraphEdge<Id, Metadata>[];
-};
-type GraphNode<Id extends string> = Id;
-type GraphEdge<Id extends string, Metadata> = {
-    from: Id;
-    to: Id;
-    predicateTraversable: (state: GraphState<Id, Metadata>) => boolean;
-};
-type GraphState<Id extends string, Metadata> = Record<Id, {
-    status: 'set' | 'unset';
-    metadata: Metadata;
-}>;
-type GraphStep<Id extends string, Metadata> = {
-    path: GraphNode<Id>[];
-    state: GraphState<Id, Metadata>;
-};
-type GraphCommonAncestor<Id extends string> = {
-    node: GraphNode<Id>;
-    distances: Record<GraphNode<Id>, number>;
-};
-type GraphTreeNode<Id extends string> = {
-    node: GraphNode<Id>;
-    children: GraphTreeNode<Id>[];
-};
-declare function defineGraph<Id extends string, Metadata>(nodes: GraphNode<Id>[], edges: GraphEdge<Id, Metadata>[]): {
-    nodes: Id[];
-    edges: GraphEdge<Id, Metadata>[];
-};
-declare function defineGraphNodes<Id extends string>(nodes: GraphNode<Id>[]): Id[];
-declare function defineGraphEdges<Id extends string, Metadata>(edges: GraphEdge<Id, Metadata>[]): GraphEdge<Id, Metadata>[];
-declare function defineGraphNode<Id extends string>(node: GraphNode<Id>): Id;
-declare function defineGraphEdge<Id extends string, Metadata>(from: GraphNode<Id>, to: GraphNode<Id>, predicateTraversable: (state: GraphState<Id, Metadata>) => boolean): {
-    from: Id;
-    to: Id;
-    predicateTraversable: (state: GraphState<Id, Metadata>) => boolean;
-};
-type AsyncGraph<Id extends string, Metadata> = {
-    nodes: GraphNode<Id>[];
-    edges: AsyncGraphEdge<Id, Metadata>[];
-};
-type AsyncGraphEdge<Id extends string, Metadata> = {
-    from: Id;
-    to: Id;
-    predicateTraversable: (metadata: GraphState<Id, Metadata>) => Promise<boolean>;
-};
-declare function defineAsyncGraph<Id extends string, Metadata>(nodes: GraphNode<Id>[], edges: AsyncGraphEdge<Id, Metadata>[]): {
-    nodes: Id[];
-    edges: AsyncGraphEdge<Id, Metadata>[];
-};
-declare function defineAsyncGraphEdges<Id extends string, Metadata>(edges: AsyncGraphEdge<Id, Metadata>[]): AsyncGraphEdge<Id, Metadata>[];
-declare function defineAsyncGraphEdge<Id extends string, Metadata>(from: GraphNode<Id>, to: GraphNode<Id>, predicateTraversable: (metadata: GraphState<Id, Metadata>) => Promise<boolean>): {
-    from: Id;
-    to: Id;
-    predicateTraversable: (metadata: GraphState<Id, Metadata>) => Promise<boolean>;
-};
-
-type GeneratorFn<Parameter, Yielded> = (param: Parameter) => Generator<Yielded>;
-
-type GraphFn<Id extends string, Metadata, Returned> = (graph: Graph<Id, Metadata>) => Returned;
-type GraphGeneratorFn<Id extends string, Metadata, Yielded> = GeneratorFn<Graph<Id, Metadata>, Yielded>;
-type GraphNodeFn<Id extends string, Returned> = (node: GraphNode<Id>) => Returned;
-type GraphNodeGeneratorFn<Id extends string, Yielded> = GeneratorFn<GraphNode<Id>, Yielded>;
-type GraphNodeTupleFn<Id extends string, Returned> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Returned;
-type GraphNodeTupleGeneratorFn<Id extends string, Yielded> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Generator<Yielded>;
-type GraphStateFn<Id extends string, Metadata, Returned> = (state: GraphState<Id, Metadata>) => Returned;
-declare function createToIndegree<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeFn<Id, number>;
-declare function createToOutdegree<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeFn<Id, number>;
-declare function createToIncoming<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorFn<Id, GraphType extends AsyncGraph<Id, Metadata> ? AsyncGraphEdge<Id, Metadata> : GraphEdge<Id, Metadata>>;
-declare function createToOutgoing<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorFn<Id, GraphType extends AsyncGraph<Id, Metadata> ? AsyncGraphEdge<Id, Metadata> : GraphEdge<Id, Metadata>>;
-declare function createPredicateRoot<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeFn<Id, boolean>;
-
-type AsyncGeneratorFn<Parameter, Yielded> = (param: Parameter) => AsyncGenerator<Yielded>;
-
-type AsyncGraphFn<Id extends string, Metadata, Returned> = (graph: AsyncGraph<Id, Metadata>) => Promise<Returned>;
-type AsyncGraphGeneratorFn<Id extends string, Metadata, Yielded> = GeneratorFn<AsyncGraph<Id, Metadata>, Yielded>;
-type AsyncGraphAsyncGeneratorFn<Id extends string, Metadata, Yielded> = AsyncGeneratorFn<AsyncGraph<Id, Metadata>, Yielded>;
-type GraphNodeAsyncGeneratorFn<Id extends string, Yielded> = AsyncGeneratorFn<GraphNode<Id>, Yielded>;
-type GraphNodeTupleAsyncFn<Id extends string, Returned> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Promise<Returned>;
-type GraphNodeTupleAsyncGeneratorFn<Id extends string, Yielded> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => AsyncGenerator<Yielded>;
-type GraphStateAsyncFn<Id extends string, Metadata, Returned> = (state: GraphState<Id, Metadata>) => Promise<Returned>;
-
-declare function createToLayers$1<Id extends string, Metadata>(options?: {
-    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
-}): GraphFn<Id, Metadata, GraphNode<Id>[][]>;
-declare function createToTree$2<Id extends string, Metadata>(options?: {
-    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
-}): GraphFn<Id, Metadata, GraphTreeNode<Id>[]>;
-declare function createToCommonAncestors$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphNodeTupleGeneratorFn<Id, GraphCommonAncestor<Id>>;
-declare function createPredicateAncestor$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphNodeTupleFn<Id, boolean>;
-declare function createToNodeSteps$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>, options?: {
-    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
-}): GraphNodeGeneratorFn<Id, GraphStep<Id, Metadata>>;
-type CreateToStepsOptions$2<Id extends string, Metadata> = {
-    root?: GraphNode<Id>;
-    toMockMetadata?: (node: GraphNode<Id>, totalConnectionsFollowed: number) => Metadata;
-    toUnsetMetadata?: (node: GraphNode<Id>) => Metadata;
-    kind?: 'directed acyclic' | 'arborescence';
-};
-declare function createToSteps$2<Id extends string, Metadata>(options?: CreateToStepsOptions$2<Id, Metadata>): GraphGeneratorFn<Id, Metadata, GraphStep<Id, Metadata>>;
-declare function createToPath$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphStateFn<Id, Metadata, GraphNode<Id>[]>;
-declare function createToRoots<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata> = Graph<Id, Metadata>>(options?: {
-    kind?: 'directed acyclic' | 'arborescence';
-}): (GraphType extends AsyncGraph<Id, Metadata> ? AsyncGraphGeneratorFn<Id, Metadata, GraphNode<Id>> : GraphGeneratorFn<Id, Metadata, GraphNode<Id>>);
-
-declare function createToLayers<Id extends string, Metadata>(options?: {
-    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
-}): AsyncGraphFn<Id, Metadata, GraphNode<Id>[][]>;
-declare function createToTree$1<Id extends string, Metadata>(options?: {
-    createToSteps?: CreateToStepsOptions$1<Id, Metadata>;
-}): AsyncGraphFn<Id, Metadata, GraphTreeNode<Id>[]>;
-declare function createToCommonAncestors$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>): GraphNodeTupleAsyncGeneratorFn<Id, GraphCommonAncestor<Id>>;
-declare function createPredicateAncestor$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>): GraphNodeTupleAsyncFn<Id, boolean>;
-declare function createToNodeSteps$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>, options?: {
-    createToSteps?: CreateToStepsOptions$1<Id, Metadata>;
-}): GraphNodeAsyncGeneratorFn<Id, GraphStep<Id, Metadata>>;
-type CreateToStepsOptions$1<Id extends string, Metadata> = CreateToStepsOptions$2<Id, Metadata>;
-declare function createToSteps$1<Id extends string, Metadata>(options?: CreateToStepsOptions$1<Id, Metadata>): AsyncGraphAsyncGeneratorFn<Id, Metadata, GraphStep<Id, Metadata>>;
-declare function createToPath$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>): GraphStateAsyncFn<Id, Metadata, GraphNode<Id>[]>;
-
-type CreateToStepsOptions<Id extends string> = Expand<Pick<CreateToStepsOptions$2<Id, DecisionTreeMetadata>, 'kind'> & {
-    priorityBranch?: boolean;
-}>;
-type DecisionTree<Id extends string> = Graph<Id, DecisionTreeMetadata>;
-type DecisionTreeMetadata = boolean;
-declare function createToTree<Id extends string>(options?: {
-    createToSteps?: CreateToStepsOptions<Id>;
-}): GraphFn<Id, boolean, GraphTreeNode<Id>[]>;
-declare function createToCommonAncestors<Id extends string>(...params: Parameters<typeof createToCommonAncestors$2<Id, DecisionTreeMetadata>>): GraphNodeTupleGeneratorFn<Id, GraphCommonAncestor<Id>>;
-declare function createPredicateAncestor<Id extends string>(...params: Parameters<typeof createPredicateAncestor$2<Id, DecisionTreeMetadata>>): GraphNodeTupleFn<Id, boolean>;
-declare function createToNodeSteps<Id extends string>(decisionTree: DecisionTree<Id>, options?: {
-    createToSteps?: CreateToStepsOptions<Id>;
-}): GraphNodeGeneratorFn<Id, GraphStep<Id, boolean>>;
-declare function createToSteps<Id extends string>(options?: CreateToStepsOptions<Id>): GraphGeneratorFn<Id, boolean, GraphStep<Id, boolean>>;
-declare function createToPath<Id extends string>(...params: Parameters<typeof createToPath$2<Id, DecisionTreeMetadata>>): GraphStateFn<Id, boolean, Id[]>;
-
-type GraphTreeFn<Id extends string, Returned> = (tree: GraphTreeNode<Id>[]) => Returned;
-declare function createFind<Id extends string>(node: GraphNode<Id>): GraphTreeFn<Id, GraphTreeNode<Id>>;
-
-type ManyFn<Parameter, Returned> = (...params: Parameter[]) => Returned;
-
-declare function createList(): ManyFn<ClassValue, string>;
-
-type ToGraphYielded = {
-    node: GraphNode<string>;
-    edge: PartialGraphEdge | undefined;
-};
-type PartialGraphEdge = Omit<GraphEdge<string, unknown>, 'predicateTraversable'>;
-type CreateToGraphOptions<TreeNode> = {
-    toId?: (node: TreeNode) => string;
-    toChildren?: (node: TreeNode) => TreeNode[];
-};
-declare function createToGraph<TreeNode>(options?: CreateToGraphOptions<TreeNode>): GeneratorFn<TreeNode[], ToGraphYielded>;
-
-type KeyboardEventFn<Returned> = (keyboardEvent: KeyboardEvent) => Returned;
-type CreatePredicateKeycomboMatchOptions = {
-    toDownKeys?: (alias: string) => KeyStatusKey[];
-    toAliases?: (event: KeyboardEvent) => string[];
-};
-declare const createPredicateKeycomboMatch: (keycombo: string, options?: CreatePredicateKeycomboMatchOptions) => KeyboardEventFn<boolean>;
+declare function createTouchrelease(options?: TouchreleaseOptions): {
+    touchstart: RecognizeableEffect<"touchstart", TouchreleaseMetadata>;
+    touchmove: RecognizeableEffect<"touchmove", TouchreleaseMetadata>;
+    touchcancel: RecognizeableEffect<"touchcancel", TouchreleaseMetadata>;
+    touchend: RecognizeableEffect<"touchend", TouchreleaseMetadata>;
+};
+declare class Touchrelease extends Listenable<TouchreleaseType, TouchreleaseMetadata> {
+    constructor(options?: TouchreleaseOptions);
+    get metadata(): TouchreleaseMetadata;
+}
 
-export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, AssociativeArray, AssociativeArrayEntries, AssociativeArrayOptions, AsyncGraph, AsyncGraphEdge, Broadcastable, BroadcastableOptions, BroadcastableStatus, Compareable, CompareableOptions, CompareableStatus, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, CreateToStepsOptions$1 as CreateAsyncDirectedAcyclicToStepsOptions, CreateToStepsOptions as CreateDecisionTreeToStepsOptions, CreateToStepsOptions$2 as CreateDirectedAcyclicToStepsOptions, CreatePredicateKeycomboMatchOptions, CreateFocusableOptions as CreateToFocusableOptions, CreateToGraphOptions, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableState, DrawableStatus, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, Graph, GraphCommonAncestor, GraphEdge, GraphNode, GraphState, GraphStep, GraphTreeNode, KeychordHook, KeychordHookApi, KeychordMetadata, KeychordOptions, KeychordType, KeypressHook, KeypressHookApi, KeypressMetadata, KeypressOptions, KeypressType, KeyreleaseHook, KeyreleaseHookApi, KeyreleaseMetadata, KeyreleaseOptions, KeyreleaseType, KonamiHook, KonamiHookApi, KonamiMetadata, KonamiOptions, KonamiType, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableKeycombo, ListenableMousecombo, ListenableOptions, ListenablePointercombo, ListenableStatus, ListenableSupportedEventType, ListenableSupportedType, MousepressHook, MousepressHookApi, MousepressMetadata, MousepressOptions, MousepressType, MousereleaseHook, MousereleaseHookApi, MousereleaseMetadata, MousereleaseOptions, MousereleaseType, Navigateable, NavigateableOptions, NavigateableStatus, Pickable, PickableOptions, PickableStatus, Potentiality, RecognizeOptions, Recognizeable, RecognizeableEffect, RecognizeableOptions, RecognizeableStatus, Resolveable, ResolveableGetPromise, ResolveableOptions, ResolveableStatus, Sanitizeable, SanitizeableOptions, SanitizeableStatus, Searchable, SearchableOptions, SearchableStatus, Shareable, ShareableOptions, ShareableStatus, Storeable, StoreableOptions, StoreableStatus, ToGraphYielded, TouchpressHook, TouchpressHookApi, TouchpressMetadata, TouchpressOptions, TouchpressType, TouchreleaseHook, TouchreleaseHookApi, TouchreleaseMetadata, TouchreleaseOptions, TouchreleaseType, createAssociativeArray, createPredicateAncestor$1 as createAsyncDirectedAcyclicPredicateAncestor, createToCommonAncestors$1 as createAsyncDirectedAcyclicToCommonAncestors, createToLayers as createAsyncDirectedAcyclicToLayers, createToNodeSteps$1 as createAsyncDirectedAcyclicToNodeSteps, createToPath$1 as createAsyncDirectedAcyclicToPath, createToSteps$1 as createAsyncDirectedAcyclicToSteps, createToTree$1 as createAsyncDirectedAcyclicToTree, createClamp, createClip, createClone, createConcat, createPredicateAncestor as createDecisionTreePredicateAncestor, createToCommonAncestors as createDecisionTreeToCommonAncestors, createToNodeSteps as createDecisionTreeToNodeSteps, createToPath as createDecisionTreeToPath, createToSteps as createDecisionTreeToSteps, createToTree as createDecisionTreeToTree, createDetermine, createPredicateAncestor$2 as createDirectedAcyclicPredicateAncestor, createToCommonAncestors$2 as createDirectedAcyclicToCommonAncestors, createToLayers$1 as createDirectedAcyclicToLayers, createToNodeSteps$2 as createDirectedAcyclicToNodeSteps, createToPath$2 as createDirectedAcyclicToPath, createToRoots as createDirectedAcyclicToRoots, createToSteps$2 as createDirectedAcyclicToSteps, createToTree$2 as createDirectedAcyclicToTree, createEntries, createEqual, createEvery, createFilter, createFilterAsync, createFindAsync, createFindIndexAsync, createFocusable, createForEachAsync, createInsert, createKeychord, createKeypress, createKeyrelease, createKeys, createKonami, createList, createMap, createMapAsync, createMousepress, createMouserelease, createPredicateKeycomboMatch, createPredicateRoot, createReduce, createReduceAsync, createRemove, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSome, createSort, createSwap, createToGraph, createToIncoming, createToIndegree, createToOutdegree, createToOutgoing, createTouchpress, createTouchrelease, createFind as createTreeFind, createUnique, defineAssociativeArrayEntries, defineAsyncGraph, defineAsyncGraphEdge, defineAsyncGraphEdges, defineGraph, defineGraphEdge, defineGraphEdges, defineGraphNode, defineGraphNodes, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, Broadcastable, BroadcastableOptions, BroadcastableStatus, ColorInterpolationMethod, Compareable, CompareableOptions, CompareableStatus, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, CreateStepsOptions$1 as CreateDirectedAcyclicStepsOptions, CreateFocusableOptions, CreateGraphOptions, CreateKeycomboMatchOptions, CreateMixOptions, CreatePathConfig, CreateResultsOptions, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableStatus, DrawableStroke, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, Keychord, KeychordHook, KeychordHookApi, KeychordMetadata, KeychordOptions, KeychordType, Keypress, KeypressHook, KeypressHookApi, KeypressMetadata, KeypressOptions, KeypressType, Keyrelease, KeyreleaseHook, KeyreleaseHookApi, KeyreleaseMetadata, KeyreleaseOptions, KeyreleaseType, Konami, KonamiHook, KonamiHookApi, KonamiMetadata, KonamiOptions, KonamiType, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableKeycombo, ListenableMousecombo, ListenableOptions, ListenablePointercombo, ListenableStatus, ListenableSupportedEventType, ListenableSupportedType, MixColor, Mousepress, MousepressHook, MousepressHookApi, MousepressMetadata, MousepressOptions, MousepressType, Mouserelease, MousereleaseHook, MousereleaseHookApi, MousereleaseMetadata, MousereleaseOptions, MousereleaseType, Navigateable, NavigateableOptions, NavigateableStatus, Pickable, PickableOptions, PickableStatus, Potentiality, RecognizeOptions, Recognizeable, RecognizeableEffect, RecognizeableOptions, RecognizeableStatus, Resolveable, ResolveableOptions, ResolveableStatus, Shareable, ShareableOptions, ShareableStatus, Storeable, StoreableOptions, StoreableStatus, ToGraphYielded, Touchpress, TouchpressHook, TouchpressHookApi, TouchpressMetadata, TouchpressOptions, TouchpressType, Touchrelease, TouchreleaseHook, TouchreleaseHookApi, TouchreleaseMetadata, TouchreleaseOptions, TouchreleaseType, createClear$1 as createAssociativeArrayClear, createDelete$1 as createAssociativeArrayDelete, createHas$1 as createAssociativeArrayHas, createKeys$1 as createAssociativeArrayKeys, createSet$1 as createAssociativeArraySet, createValue$1 as createAssociativeArrayValue, createValues as createAssociativeArrayValues, createBreadthPathConfig, createChildren, createClamp, createClear, createClip, createClone, createComputedStyle, createConcat, createAncestor$1 as createDecisionTreeAncestor, createCommonAncestors$1 as createDecisionTreeCommonAncestors, createNodeDepthFirstSteps$1 as createDecisionTreeNodeDepthFirstSteps, createPath$1 as createDecisionTreePath, createDepthFirstSteps$1 as createDecisionTreeSteps, createTree$1 as createDecisionTreeTree, createDeepEqual, createDeepMerge, createDelete, createDepthPathConfig, createDetermine, createAncestor$2 as createDirectedAcyclicAncestor, createAncestor as createDirectedAcyclicAsyncAncestor, createCommonAncestors as createDirectedAcyclicAsyncCommonAncestors, createDepthFirstSteps as createDirectedAcyclicAsyncDepthFirstSteps, createLayers as createDirectedAcyclicAsyncLayers, createNodeDepthFirstSteps as createDirectedAcyclicAsyncNodeDepthFirstSteps, createPath as createDirectedAcyclicAsyncPath, createTree as createDirectedAcyclicAsyncTree, createCommonAncestors$2 as createDirectedAcyclicCommonAncestors, createDepthFirstSteps$2 as createDirectedAcyclicDepthFirstSteps, createLayers$1 as createDirectedAcyclicLayers, createNodeDepthFirstSteps$2 as createDirectedAcyclicNodeDepthFirstSteps, createPath$2 as createDirectedAcyclicPath, createRoots as createDirectedAcyclicRoots, createTree$2 as createDirectedAcyclicTree, createEntries, createEqual, createEvery, createFilter, createFilterAsync, createFindAsync, createFindIndexAsync, createFocusable, createForEachAsync, createGraph, createGreater, createGreaterOrEqual, createHas, createIncoming, createIndegree, createInsert, createKeychord, createKeycomboMatch, createKeypress, createKeyrelease, createKeys, createKonami, createLess, createLessOrEqual, createList, createMap, createMapAsync, createMix, createMousepress, createMouserelease, createNumber, createOnlyChild, createOutdegree, createOutgoing, createReduce, createReduceAsync, createRemove, createReorder, createReplace, createResults, createReverse, createRoot, createSanitize, createSet, createShuffle, createSiblings, createSlice, createSlug, createSome, createSort, createSwap, createTerminal, createTotalSiblings, createTouchpress, createTouchrelease, createFind as createTreeFind, createUnique, createValue, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };