import * as perfect_freehand from 'perfect-freehand';
import { getStroke, StrokeOptions } from 'perfect-freehand';
import ky, { Options as Options$1, KyInstance } from 'ky';
import { ClassValue } from 'clsx';
import { FullOptions, sortKind, MatchData } from 'fast-fuzzy';
import { Config } from 'dompurify';
import { Options } from '@sindresorhus/slugify';

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[]>;
/**
 * [Docs](https://baleada.dev/docs/logic/pipes/array-format)
 */
declare function createFormat$2(...params: ConstructorParameters<typeof Intl.ListFormat>): ArrayTransform<string, string>;

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<Key>): 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<Key>): AssociativeArrayEffect<Key, any>;

type AssociativeArray<Key, Value> = [Key, Value][];
declare function defineAssociativeArray<Key, Value>(associativeArray: AssociativeArray<Key, Value>): AssociativeArray<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;
};

declare function fromKeyboardEventDescriptorToAliases(descriptor: KeyboardEventDescriptor): string[];

declare function fromCodeToAliases(code: KeyStatusCode): string[];

declare function fromAliasToCode(alias: string): KeyStatusCode;

declare function fromShorthandAliasToLonghandAlias(shorthand: string): string;

type Direction = 'up' | 'upRight' | 'right' | 'downRight' | 'down' | 'downLeft' | 'left' | 'upLeft' | 'none';

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, 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>[];
declare function defineGraph<Id extends string, StateValue>(nodes: GraphNode<Id>[], edges: GraphEdge<Id, StateValue>[]): {
    nodes: Id[];
    edges: GraphEdge<Id, StateValue>[];
};
declare function defineGraphNodes<Id extends string>(nodes: GraphNode<Id>[]): Id[];
declare function defineGraphEdges<Id extends string, StateValue>(edges: GraphEdge<Id, StateValue>[]): GraphEdge<Id, StateValue>[];
declare function defineGraphNode<Id extends string>(node: GraphNode<Id>): Id;
declare function defineGraphEdge<Id extends string, StateValue>(from: GraphNode<Id>, to: GraphNode<Id>, predicateShouldTraverse: (state: GraphState<Id, StateValue>) => boolean): {
    from: Id;
    to: Id;
    predicateShouldTraverse: (state: GraphState<Id, StateValue>) => boolean;
};
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>;
};
declare function defineGraphAsync<Id extends string, StateValue>(nodes: GraphNode<Id>[], edges: GraphAsyncEdge<Id, StateValue>[]): {
    nodes: Id[];
    edges: GraphAsyncEdge<Id, StateValue>[];
};
declare function defineGraphAsyncEdges<Id extends string, StateValue>(edges: GraphAsyncEdge<Id, StateValue>[]): GraphAsyncEdge<Id, StateValue>[];
declare function defineGraphAsyncEdge<Id extends string, StateValue>(from: GraphNode<Id>, to: GraphNode<Id>, predicateShouldTraverse: (state: GraphState<Id, StateValue>) => Promise<boolean>): {
    from: Id;
    to: Id;
    predicateShouldTraverse: (state: GraphState<Id, StateValue>) => Promise<boolean>;
};

type RecognizeableOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
    maxSequenceLength?: true | number;
    effects?: {
        [type in Type]?: RecognizeableEffect<type, Metadata> | RecognizeableEffectConfig<type, Metadata>;
    };
};
type RecognizeableEffectConfig<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
    effect: RecognizeableEffect<Type, Metadata>;
    stop: (target: RecognizeableStopTarget<Type>) => void;
};
type RecognizeableEffect<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = (sequenceItem: ListenEffectParam<Type>, api: RecognizeableEffectApi<Type, Metadata>) => void;
type RecognizeableEffectApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
    getStatus: () => RecognizeableStatus;
    getMetadata: () => Metadata;
    setMetadata: (metadata: Metadata) => void;
    recognized: () => void;
    denied: () => void;
    getSequence: () => ListenEffectParam<Type>[];
    pushSequence: (sequenceItem: ListenEffectParam<Type>) => void;
    listenInjection: RecognizeOptions<Type>['listenInjection'];
};
type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
type RecognizeOptions<Type extends ListenableSupportedType> = {
    listenInjection?: {
        effect: (sequenceItem: ListenEffectParam<Type>) => any;
        optionsByType: Record<Type, ListenOptions<Type>>;
    };
};
type RecognizeableStops<Type extends ListenableSupportedType> = {
    [type in Type]?: (target: RecognizeableStopTarget<type>) => void;
};
type RecognizeableStopTarget<Type extends ListenableSupportedType> = ('target' extends keyof ListenOptions<Type> ? ListenOptions<Type>['target'] : never);
/**
 * [Docs](https://baleada.dev/docs/logic/classes/recognizeable)
 */
declare class Recognizeable<Type extends ListenableSupportedType, Metadata extends Record<any, any>> {
    private maxSequenceLength;
    private effects;
    private effectApi;
    constructor(sequence: ListenEffectParam<Type>[], options?: RecognizeableOptions<Type, Metadata>);
    private computedMetadata;
    private resetComputedMetadata;
    private recognized;
    private denied;
    private computedStatus;
    private ready;
    get sequence(): ListenEffectParam<Type>[];
    set sequence(sequence: ListenEffectParam<Type>[]);
    private computedStops;
    get stops(): RecognizeableStops<Type>;
    get status(): RecognizeableStatus;
    get metadata(): Metadata;
    private computedSequence;
    setSequence(sequence: ListenEffectParam<Type>[]): this;
    recognize(sequenceItem: ListenEffectParam<Type>, options?: RecognizeOptions<Type>): this;
    private recognizing;
    private toType;
}

type ListenableSupportedType = 'recognizeable' | 'intersect' | 'mutate' | 'resize' | 'idle' | 'message' | 'messageerror' | ListenableMediaQuery | keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'> | keyof IDBEventMap;
type IDBEventMap = IDBRequestEventMap & IDBTransactionEventMap & IDBOpenDBRequestEventMap & IDBDatabaseEventMap;
type ListenableMediaQuery = `(${string})`;
type ListenableMousecombo = `${string}+${ListenableLeftClick | ListenableRightClick}`;
type ListenableLeftClick = 'click' | 'dblclick' | `mouse${string}`;
type ListenableRightClick = 'rightclick' | 'contextmenu';
type ListenablePointercombo = `${string}+${ListenablePointer}`;
type ListenablePointer = `pointer${string}`;
type ListenableKeycombo = string;
type ListenableSupportedEventType = keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
type ListenableOptions<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = {
    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 : Type extends keyof IDBEventMap ? (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 ('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] : Type extends keyof IDBEventMap ? IDBEventMap[Type] : never;
type ListenOptions<Type extends ListenableSupportedType> = Type extends 'intersect' ? {
    observer?: IntersectionObserverInit;
} & ObservationListenOptions : Type extends 'mutate' ? {
    observe?: MutationObserverInit;
} & ObservationListenOptions : Type extends 'resize' ? {
    observe?: ResizeObserverOptions;
} & ObservationListenOptions : Type extends 'idle' ? {
    requestIdleCallback?: IdleRequestOptions;
} : Type extends ('message' | 'messageerror') ? {
    target?: BroadcastChannel;
} : Type extends ListenableMediaQuery ? {
    instantEffect?: (list: MediaQueryList) => any;
} : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? EventListenOptions : Type extends keyof Omit<DocumentEventMap, 'resize'> ? EventListenOptions : Type extends keyof IDBEventMap ? EventListenOptions : never;
type ObservationListenOptions = {
    target?: Element;
};
type EventListenOptions = {
    target?: Element | Document | (Window & typeof globalThis) | IDB;
    addEventListener?: AddEventListenerOptions;
    useCapture?: boolean;
    except?: string[];
    only?: string[];
};
type IDB = (IDBRequest | IDBOpenDBRequest | IDBTransaction | IDBDatabase);
type ListenableActive<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = Type extends 'intersect' ? {
    target: Element;
    id: IntersectionObserver;
} : Type extends 'mutate' ? {
    target: Element;
    id: MutationObserver;
} : Type extends 'resize' ? {
    target: Element;
    id: ResizeObserver;
} : Type extends 'idle' ? {
    target: Window & typeof globalThis;
    id: number;
} : Type extends ('message' | 'messageerror') ? {
    target: BroadcastChannel;
    id: [type: string, effect: (event: MessageEvent) => void];
} : Type extends ListenableMediaQuery ? {
    target: MediaQueryList;
    id: [type: string, effect: (param: ListenEffectParam<Type>) => void];
} : Type extends ListenableSupportedEventType ? {
    target: Element | Document;
    id: ListenableActiveEventId<Type>;
} : {
    id: Listenable<Type, RecognizeableMetadata>;
    target: RecognizeableStopTarget<Type>;
    stopExtension: (target: RecognizeableStopTarget<Type>) => void;
};
type ListenableActiveEventId<Type extends ListenableSupportedEventType> = [
    type: Type,
    exceptAndOnlyEffect: (param: ListenEffectParam<Type>) => void,
    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;
    private computedActive;
    constructor(type: Type, options?: ListenableOptions<Type, RecognizeableMetadata>);
    private computedStatus;
    private ready;
    get type(): Type;
    set type(type: Type);
    get status(): ListenableStatus;
    get active(): Set<ListenableActive<Type, RecognizeableMetadata>>;
    get recognizeable(): Recognizeable<Type, RecognizeableMetadata>;
    private computedType;
    private implementation;
    setType(type: Type): 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<Key extends any> = {
    predicateKey?: (candidate: Key) => 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<Key>): 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<Key>): 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 DateTransform<DateKind extends Date | EpochTimeStamp, Transformed> = (date: DateKind) => Transformed;
/**
 * [Docs](https://baleada.dev/docs/logic/pipes/date-format)
 */
declare function createFormat$1(...params: ConstructorParameters<typeof Intl.DateTimeFormat>): DateTransform<Date | EpochTimeStamp, string>;

type ElementTransform<El extends HTMLElement | SVGElement, Transformed> = (element: El) => Transformed;
type CreateFocusableOptions = {
    predicatesElement?: boolean;
    tabbableSelector?: string;
};
/**
 * [Docs](https://baleada.dev/docs/logic/pipes/focusable)
 */
declare function createFocusable(order: 'first' | 'last' | 'next' | 'previous', options?: CreateFocusableOptions): ElementTransform<HTMLElement | SVGElement, HTMLElement | SVGElement | undefined>;
/**
 * [Docs](https://baleada.dev/docs/logic/pipes/computed-style)
 */
declare function createComputedStyle(pseudoElement?: string): ElementTransform<HTMLElement | SVGElement, CSSStyleDeclaration>;

type FunctionTransform<Fn extends Function, Returned> = (param: Fn) => Returned;
declare function createTry<Optimistic, Pessimistic extends Error>(): FunctionTransform<() => Optimistic, Optimistic | Pessimistic>;

type AsyncFunctionTransform<Fn extends Function, Returned> = (param: Fn) => Promise<Returned>;
declare function createTryAsync<Optimistic, Pessimistic extends Error>(): AsyncFunctionTransform<() => Promise<Optimistic>, Optimistic | Pessimistic>;

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 KeyboardEventDescriptorTransform<Transformed> = (descriptor: KeyboardEventDescriptor) => 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) => KeyboardEventDescriptorTransform<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/number-format)
 */
declare function createFormat(...params: ConstructorParameters<typeof Intl.NumberFormat>): NumberTransform<string>;
/**
 * [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>;
/**
 * [Docs](https://baleada.dev/docs/logic/pipes/omit)
 */
declare function createOmit<Type extends Record<any, any>, Omitted extends keyof Type = keyof Type>(keys: Omitted[]): ObjectTransform<Type, Omit<Type, Omitted>>;
/**
 * [Docs](https://baleada.dev/docs/logic/pipes/pick)
 */
declare function createPick<Type extends Record<any, any>, Picked extends keyof Type = keyof Type>(keys: Picked[]): ObjectTransform<Type, Pick<Type, Picked>>;

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, ReturnsMatchData extends boolean> = Omit<FullOptions<Candidate>, 'returnMatchData'> & {
    returnMatchData?: ReturnsMatchData;
};
declare function createResults<Candidate extends string | object, ReturnsMatchData extends boolean = false>(candidates: Candidate[], options?: (CreateResultsOptions<Candidate, ReturnsMatchData> | ((api: {
    sortKind: typeof sortKind;
}) => CreateResultsOptions<Candidate, ReturnsMatchData>))): StringTransform<ReturnsMatchData 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[]);
declare function defineAnimateableKeyframes<Value extends string | number | any[]>(keyframes: AnimateableKeyframe<Value>[]): AnimateableKeyframe<Value>[];
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);
    private computedStatus;
    private ready;
    get state(): State;
    set state(state: State);
    get status(): BroadcastableStatus;
    private computedChannel;
    get channel(): BroadcastChannel;
    private computedError;
    get error(): Error;
    private computedState;
    setState(state: State): this;
    broadcast(): this;
    private broadcasting;
    private broadcasted;
    private errored;
    stop(): this;
    private stopped;
}
declare function toMessageListenParams<State>(instance: Broadcastable<State>, effect: (event: MessageEvent<State>) => void): Parameters<Listenable<'message'>['listen']>;

type CompareableOptions = {
    locales?: Parameters<typeof Intl.Collator>[0];
    collator?: Intl.CollatorOptions;
};
type CompareableStatus = 'ready' | 'comparing' | 'compared';
declare class Compareable {
    constructor(string: string, options?: CompareableOptions);
    private computedStatus;
    private ready;
    get string(): string;
    set string(string: string);
    get status(): CompareableStatus;
    private computedCollator;
    get collator(): Intl.Collator;
    private computedComparison;
    get comparison(): 0 | 1 | -1;
    private computedString;
    setString(string: string): this;
    compare(compared: string): this;
    private comparing;
    private compared;
}

type CompleteableOptions = {
    segment?: {
        from?: 'start' | 'selection' | 'divider';
        to?: 'end' | 'selection' | 'divider';
    };
    divider?: RegExp;
    initialSelection?: {
        start: number;
        end: number;
        direction: 'forward' | 'backward' | 'none';
    };
};
type CompleteableStatus = 'constructing' | 'ready' | 'completing' | 'completed';
type CompleteOptions = {
    select?: 'completion' | 'completionEnd' | (({ before, completion, after }: {
        before: string;
        completion: string;
        after: string;
    }) => Completeable['selection']);
};
/**
 * [Docs](https://baleada.dev/docs/logic/classes/completeable)
 */
declare class Completeable {
    private segmentFrom;
    private segmentTo;
    private divider;
    private computedDividerIndices;
    constructor(string: string, options?: CompleteableOptions);
    private constructing;
    private computedStatus;
    private ready;
    get string(): string;
    set string(string: string);
    get selection(): {
        start: number;
        end: number;
        direction: "forward" | "backward" | "none";
    };
    set selection(selection: {
        start: number;
        end: number;
        direction: "forward" | "backward" | "none";
    });
    get status(): CompleteableStatus;
    get segment(): string;
    get dividerIndices(): {
        before: number;
        after: number;
    };
    private getSegmentStartIndex;
    private getSegmentEndIndex;
    private computedString;
    setString(string: string): this;
    private computedSelection;
    setSelection(selection: {
        start: number;
        end: number;
        direction: 'forward' | 'backward' | 'none';
    }): this;
    private setDividerIndices;
    private toPreviousMatch;
    private toNextMatch;
    complete(completion: string, options?: CompleteOptions): this;
    private getBefore;
    private getAfter;
    private completing;
    private completed;
}

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;
    private cutListenable;
    private copyAndCutEffect;
    constructor(string: string, options?: CopyableOptions);
    private computedStatus;
    private ready;
    get string(): string;
    set string(string: string);
    get status(): CopyableStatus;
    get isClipboardText(): boolean;
    get response(): undefined;
    get error(): Error;
    private computedString;
    setString(string: string): this;
    private computedResponse;
    private computedError;
    copy(options?: {
        kind: 'clipboard' | 'deprecated';
    }): Promise<this>;
    private copying;
    private copied;
    private errored;
    listenForClipboardEvents(): void;
    stop(): void;
}

type DelayableOptions = {
    delay?: number;
    executions?: number | true;
};
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);
    private computedStatus;
    private ready;
    get effect(): DelayableEffect;
    set effect(effect: DelayableEffect);
    get status(): DelayableStatus;
    get executions(): number;
    get time(): {
        elapsed: number;
        remaining: number;
    };
    get progress(): number;
    private computedEffect;
    setEffect(effect: DelayableEffect): this;
    private frameEffect;
    private setFrameEffect;
    private delaying;
    private delayed;
    delay(): this;
    pause(): this;
    private paused;
    resume(): this;
    seek(timeProgress: number): this;
    private sought;
    stop(): this;
    private stopped;
}

type DrawableStroke = ReturnType<typeof getStroke>;
type DrawableOptions = {
    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: DrawableStroke, options?: DrawableOptions);
    computedStatus: DrawableStatus;
    private ready;
    get stroke(): perfect_freehand.Vec2[];
    set stroke(stroke: perfect_freehand.Vec2[]);
    get status(): DrawableStatus;
    get d(): string;
    private computedStroke;
    setStroke(stroke: DrawableStroke): this;
    draw(points: Parameters<typeof getStroke>[0], options?: StrokeOptions): this;
    private drawing;
    private drawn;
}
declare function toD(stroke: number[][]): string;
declare function toFlattenedD(stroke: number[][]): string;

type ResolveableOptions = Record<never, never>;
type ResolveableStatus = 'ready' | 'resolving' | 'resolved' | 'errored';
/**
 * [Docs](https://baleada.dev/docs/logic/classes/resolveable)
 */
declare class Resolveable<Value> {
    constructor(getPromise: () => Promise<Value>, options?: ResolveableOptions);
    private computedStatus;
    private ready;
    get getPromise(): () => Promise<Value>;
    set getPromise(getPromise: () => Promise<Value>);
    get status(): ResolveableStatus;
    get value(): Value;
    get error(): Error;
    private computedGetPromise;
    setGetPromise(getPromise: () => Promise<Value>): this;
    private computedValue;
    private computedError;
    resolve(): Promise<this>;
    private resolving;
    private resolved;
    private errored;
}

type FetchableOptions = {
    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<ResolveableValue> {
    private computedArrayBuffer;
    private computedBlob;
    private computedFormData;
    private computedJson;
    private computedText;
    constructor(resource: string, options?: FetchableOptions);
    private computedStatus;
    private ready;
    get resource(): string;
    set resource(resource: string);
    get status(): FetchableStatus;
    private computedKy;
    get ky(): KyInstance;
    private computedAbortController;
    get abortController(): AbortController;
    private computedRetryCount;
    get retryCount(): number;
    get response(): Response;
    get error(): Error;
    get arrayBuffer(): Resolveable<ArrayBuffer>;
    get blob(): Resolveable<Blob>;
    get formData(): Resolveable<FormData>;
    get json(): Resolveable<ResolveableValue>;
    get text(): Resolveable<string>;
    private computedResource;
    setResource(resource: string): this;
    private computedResponse;
    private computedError;
    fetch(options?: FetchOptions): Promise<this>;
    private fetching;
    private retrying;
    private fetched;
    private aborted;
    private errored;
    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;
    private ready;
    get getElement(): (...args: any[]) => ElementType;
    set getElement(getElement: (...args: any[]) => ElementType);
    get status(): FullscreenableStatus;
    get element(): ElementType;
    get error(): Error;
    private computedGetElement;
    setGetElement(getElement: ((...args: any[]) => ElementType)): this;
    enter(options?: FullscreenOptions): Promise<this>;
    private computedError;
    fullscreen(options?: FullscreenOptions): Promise<this>;
    private fullscreened;
    private errored;
    exit(): Promise<this>;
    private exited;
}

type GrantableOptions = Record<never, never>;
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(): PermissionDescriptor;
    set descriptor(descriptor: PermissionDescriptor);
    get permission(): PermissionStatus;
    get error(): Error;
    get status(): GrantableStatus;
    private computedDescriptor;
    setDescriptor(descriptor: PermissionDescriptor): this;
    private computedPermission;
    private computedError;
    grant(): Promise<this>;
    private granting;
    private granted;
    private errored;
}

type NavigateableOptions = {
    initialLocation?: number;
};
type NavigateableStatus = 'ready' | 'navigated' | 'navigated to next' | 'navigated to previous' | 'navigated to random' | 'navigated to first' | 'navigated to last';
type NavigateOptions = {
    allow?: 'possible' | 'any';
};
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;
    private ready;
    private computedArray;
    get array(): Item[];
    set array(value: Item[]);
    private computedLocation;
    get location(): number;
    set location(location: number);
    get status(): NavigateableStatus;
    get item(): Item;
    setArray(array: Item[]): this;
    setLocation(location: number): this;
    navigate(location: number, options?: NavigateOptions): this;
    private navigated;
    private _navigate;
    next(options?: NextAndPreviousOptions): this;
    private nexted;
    previous(options?: NextAndPreviousOptions): this;
    private previoused;
    random(): this;
    private randomed;
    first(): this;
    private firsted;
    last(): this;
    private lasted;
}

type OperateableOptions = Record<never, never>;
type OperateableStatus = ('ready' | 'operating' | 'operated' | 'errored');
type OperationAdd<StoredObject extends Record<any, any> = Record<any, any>> = {
    operation: 'add';
    value: StoredObject;
    key?: IDBValidKey;
};
type OperationPut<StoredObject extends Record<any, any> = Record<any, any>> = {
    operation: 'put';
    value: StoredObject;
    key?: IDBValidKey;
};
type OperationGet<StoredObject extends Record<any, any> = Record<any, any>> = {
    operation: 'get';
    query: IDBValidKey | IDBKeyRange;
    effect?: (result: StoredObject) => void;
};
type OperationGetKey = {
    operation: 'getKey';
    query: IDBValidKey | IDBKeyRange;
    effect?: (result: IDBValidKey | undefined) => void;
};
type OperationGetAll<StoredObject extends Record<any, any> = Record<any, any>> = {
    operation: 'getAll';
    query?: IDBValidKey | IDBKeyRange | null;
    count?: number;
    effect?: (result: StoredObject) => void;
};
type OperationGetAllKeys = {
    operation: 'getAllKeys';
    query?: IDBValidKey | IDBKeyRange | null;
    count?: number;
    effect?: (result: IDBValidKey[]) => void;
};
type OperationGetAllRecords<StoredObject extends Record<any, any> = Record<any, any>> = {
    operation: 'getAllRecords';
    query?: IDBValidKey | IDBKeyRange | null;
    count?: number;
    effect?: (result: StoredObject) => void;
};
type OperationDelete = {
    operation: 'delete';
    query: IDBValidKey | IDBKeyRange;
};
type OperationClear = {
    operation: 'clear';
};
type OperationCount = {
    operation: 'count';
    query?: IDBValidKey | IDBKeyRange;
    effect?: (result: number) => void;
};
type OperationOpenCursor<StoredObject extends Record<any, any> = Record<any, any>> = {
    operation: 'openCursor';
    query?: IDBValidKey | IDBKeyRange | null;
    direction?: IDBCursorDirection;
    effect?: (cursor: DefinedIDBCursorWithValue<StoredObject> | null) => void;
};
type DefinedIDBCursorWithValue<StoredObject extends Record<any, any> = Record<any, any>> = (Omit<IDBCursorWithValue, 'value'> & {
    value: StoredObject;
});
type OperationOpenKeyCursor = {
    operation: 'openKeyCursor';
    query?: IDBValidKey | IDBKeyRange | null;
    direction?: IDBCursorDirection;
    effect?: (cursor: IDBCursor | null) => void;
};
type OperationDescriptor<StoredObject extends Record<any, any> = Record<any, any>, O extends Operation = Operation> = O extends 'add' ? OperationAdd<StoredObject> : O extends 'put' ? OperationPut<StoredObject> : O extends 'get' ? OperationGet<StoredObject> : O extends 'getKey' ? OperationGetKey : O extends 'getAll' ? OperationGetAll<StoredObject> : O extends 'getAllKeys' ? OperationGetAllKeys : O extends 'getAllRecords' ? OperationGetAllRecords<StoredObject> : O extends 'delete' ? OperationDelete : O extends 'clear' ? OperationClear : O extends 'count' ? OperationCount : O extends 'openCursor' ? OperationOpenCursor<StoredObject> : O extends 'openKeyCursor' ? OperationOpenKeyCursor : never;
type Operation = ('add' | 'put' | 'get' | 'getKey' | 'getAll' | 'getAllKeys' | 'getAllRecords' | 'delete' | 'clear' | 'count' | 'openCursor' | 'openKeyCursor');
type DefinedIDBObjectStore<StoredObject extends Record<any, any>> = (Omit<IDBObjectStore, 'get'> & {
    get(query: IDBValidKey | IDBKeyRange): IDBRequest<StoredObject>;
});
declare function createDefineObjectStore<StoredObjectsByStoreName extends Record<string, any>>(): <StoreName extends keyof StoredObjectsByStoreName>(transaction: IDBTransaction, storeName: StoreName) => DefinedIDBObjectStore<StoredObjectsByStoreName[StoreName]>;
declare class Operateable<StoredObject extends Record<any, any>> {
    constructor(objectStore: DefinedIDBObjectStore<StoredObject>, options?: OperateableOptions);
    private listenables;
    private ready;
    private computedObjectStore;
    get objectStore(): DefinedIDBObjectStore<StoredObject>;
    set objectStore(objectStore: DefinedIDBObjectStore<StoredObject>);
    private computedStatus;
    get status(): OperateableStatus;
    private computedError;
    get error(): Error;
    setObjectStore(objectStore: DefinedIDBObjectStore<StoredObject>): this;
    operate(descriptors: OperationDescriptor<StoredObject, Operation>[]): this;
    private operating;
    private operated;
    private errored;
    add(descriptor: Omit<OperationDescriptor<StoredObject, 'add'>, 'operation'>): this;
    put(descriptor: Omit<OperationDescriptor<StoredObject, 'put'>, 'operation'>): this;
    get(descriptor: Omit<OperationDescriptor<StoredObject, 'get'>, 'operation'>): this;
    getKey(descriptor: Omit<OperationDescriptor<StoredObject, 'getKey'>, 'operation'>): this;
    getAll(descriptor: Omit<OperationDescriptor<StoredObject, 'getAll'>, 'operation'>): this;
    getAllKeys(descriptor: Omit<OperationDescriptor<StoredObject, 'getAllKeys'>, 'operation'>): this;
    getAllRecords(descriptor: Omit<OperationDescriptor<StoredObject, 'getAllRecords'>, 'operation'>): this;
    delete(descriptor: Omit<OperationDescriptor<StoredObject, 'delete'>, 'operation'>): this;
    clear(descriptor: Omit<OperationDescriptor<StoredObject, 'clear'>, 'operation'>): this;
    count(descriptor: Omit<OperationDescriptor<StoredObject, 'count'>, 'operation'>): this;
    openCursor(descriptor: Omit<OperationDescriptor<StoredObject, 'openCursor'>, 'operation'>): this;
    openKeyCursor(descriptor: Omit<OperationDescriptor<StoredObject, 'openKeyCursor'>, 'operation'>): this;
    stop(): this;
    private stopListenables;
}

type PickableOptions = {
    initialPicks?: number | number[];
};
type PickableStatus = 'ready' | 'picked' | 'omitted';
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;
    private ready;
    private computedArray;
    get array(): Item[];
    set array(array: Item[]);
    private computedPicks;
    get picks(): number[];
    set picks(indices: number[]);
    computedFirst: number;
    get first(): number;
    computedLast: number;
    get last(): number;
    get oldest(): number;
    get newest(): number;
    get items(): Item[];
    private toItems;
    computedMultiple: boolean;
    get multiple(): boolean;
    get status(): PickableStatus;
    private toPossiblePicks;
    setArray(array: Item[]): this;
    setPicks(indexOrIndices: number | number[]): this;
    pick(indexOrIndices: number | number[], options?: PickOptions): this;
    private picked;
    omit(indexOrIndices?: number | number[], options?: {
        reference?: 'array' | 'picks';
    }): this;
    private omitted;
}

type ShareableOptions = Record<never, never>;
type ShareableStatus = 'ready' | 'sharing' | 'shared' | 'errored';
/**
 * [Docs](https://baleada.dev/docs/logic/classes/shareable)
 */
declare class Shareable {
    constructor(shareData: ShareData, options?: ShareableOptions);
    private computedStatus;
    private ready;
    get shareData(): ShareData;
    set shareData(shareData: ShareData);
    get status(): ShareableStatus;
    private computedCan;
    get can(): Resolveable<boolean>;
    private computedError;
    get error(): Error;
    private computedState;
    setShareData(shareData: ShareData): this;
    share(): Promise<this>;
    private sharing;
    private shared;
    private errored;
}

type StoreableOptions = {
    kind?: 'local' | 'session';
    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;
    constructor(key: string, options?: StoreableOptions);
    private constructing;
    private computedStatus;
    private ready;
    get key(): string;
    set key(key: string);
    get status(): StoreableStatus;
    get storage(): Storage;
    get string(): String;
    get error(): Error;
    private computedKey;
    private computedStatusKey;
    setKey(key: string): this;
    private computedString;
    private computedError;
    store(string: String): this;
    private stored;
    private errored;
    private storeStatus;
    remove(): this;
    private removed;
    removeStatus(): this;
}

type TransactableOptions = Record<never, never>;
type TransactableStatus = ('constructing' | 'ready' | 'opening' | 'opened' | 'openblocked' | 'openerrored' | 'upgradeneeded' | 'closing' | 'closed' | 'transacting' | 'transacted' | 'transacterrored' | 'transactaborted' | 'deleting' | 'deleteerrored' | 'deleted');
type TransactEffect = (transaction: IDBTransaction) => any;
type OpenOptions = {
    version?: number;
    upgradeEffect?: (db: IDBDatabase) => void;
};
type TransactOptions = ({
    effect?: TransactEffect;
    storeNames?: Parameters<IDBDatabase['transaction']>[0];
    mode?: Parameters<IDBDatabase['transaction']>[1];
} & IDBTransactionOptions);
declare class Transactable {
    constructor(name: string, options?: TransactableOptions);
    private constructing;
    private computedStatus;
    private listenables;
    private ready;
    get name(): string;
    set name(name: string);
    private computedDb;
    get db(): IDBDatabase;
    private computedError;
    get error(): Error;
    get status(): TransactableStatus;
    private computedName;
    setName(name: string): this;
    open(options?: OpenOptions): this;
    private requestOpen;
    private opening;
    private opened;
    private openblocked;
    private openerrored;
    private upgradeneeded;
    transact(effect: TransactEffect, options?: TransactOptions): this;
    private transacted;
    private transacterrored;
    private transactaborted;
    private transacting;
    readonly(effect: TransactEffect, options?: Omit<TransactOptions, 'mode'>): this;
    readwrite(effect: TransactEffect, options?: Omit<TransactOptions, 'mode'>): this;
    versionchange(effect: TransactEffect, options?: Omit<TransactOptions, 'mode'>): this;
    close(): this;
    private closing;
    private closed;
    delete(): this;
    private requestDelete;
    private deleting;
    private deleteerrored;
    private deleted;
    stop(): this;
    private stopListenables;
}

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 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>;

declare function createDepthPathConfig<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata> | GraphAsync<Id, Metadata>): CreatePathConfig<Id, Metadata>;

declare function createBreadthPathConfig<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata> | GraphAsync<Id, Metadata>): CreatePathConfig<Id, Metadata>;

type KeypressType = 'keydown' | 'keyup' | 'visibilitychange';
type KeypressMetadata = {
    keycombo: string;
} & KeyboardTimeMetadata;
type KeypressOptions = CreateKeycomboMatchOptions$1 & {
    minDuration?: number;
    preventsDefaultUnlessDenied?: boolean;
    onDown?: KeypressHook;
    onUp?: KeypressHook;
    onVisibilitychange?: KeypressHook;
};
type KeypressHook = (api: KeypressHookApi) => any;
type KeypressHookApi = HookApi<KeypressType, KeypressMetadata>;
declare function createKeypress(keycomboOrKeycombos: string | string[], options?: KeypressOptions): {
    keydown: {
        effect: RecognizeableEffect<"keydown", KeypressMetadata>;
        stop: () => void;
    };
    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 = {
    keycombo: string;
} & KeyboardTimeMetadata;
type KeyreleaseOptions = CreateKeycomboMatchOptions$1 & {
    minDuration?: number;
    preventsDefaultUnlessDenied?: boolean;
    onDown?: KeyreleaseHook;
    onUp?: KeyreleaseHook;
    onVisibilitychange?: KeyreleaseHook;
};
type KeyreleaseHook = (api: KeyreleaseHookApi) => any;
type KeyreleaseHookApi = HookApi<KeyreleaseType, KeyreleaseMetadata>;
declare function createKeyrelease(keycomboOrKeycombos: string | string[], options?: KeyreleaseOptions): {
    keydown: {
        effect: RecognizeableEffect<"keydown", KeyreleaseMetadata>;
        stop: () => void;
    };
    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: ({
        keycombo: string;
    } & KeyboardTimeMetadata)[];
};
type KeychordOptions = CreateKeycomboMatchOptions$1 & {
    minDuration?: number;
    maxInterval?: number;
    preventsDefaultUnlessDenied?: boolean;
    onDown?: KeychordHook;
    onUp?: KeychordHook;
    onVisibilitychange?: KeychordHook;
};
type KeychordHook = (api: KeychordHookApi) => any;
type KeychordHookApi = HookApi<KeychordType, KeychordMetadata>;
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): {
    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 PointerpressType = 'pointerdown' | 'pointerout' | 'pointerup';
type PointerpressMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
type PointerpressOptions = {
    minDuration?: number;
    minDistance?: number;
    onDown?: PointerpressHook;
    onMove?: PointerpressHook;
    onOut?: PointerpressHook;
    onUp?: PointerpressHook;
};
type PointerpressHook = (api: PointerpressHookApi) => any;
type PointerpressHookApi = HookApi<PointerpressType, PointerpressMetadata>;
/**
 * [Docs](https://baleada.dev/docs/logic/factories/pointerpress)
 */
declare function createPointerpress(options?: PointerpressOptions): {
    pointerdown: {
        effect: RecognizeableEffect<"pointerdown", PointerpressMetadata>;
        stop: (target: RecognizeableStopTarget<PointerpressType>) => void;
    };
    pointerout: RecognizeableEffect<"pointerout", PointerpressMetadata>;
    pointerup: RecognizeableEffect<"pointerup", PointerpressMetadata>;
};
declare class Pointerpress extends Listenable<PointerpressType, PointerpressMetadata> {
    constructor(options?: PointerpressOptions);
    get metadata(): PointerpressMetadata;
}

type PointerhoverType = 'pointerover' | 'pointerout';
type PointerhoverMetadata = (PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata);
type PointerhoverOptions = {
    minDuration?: number;
    onOver?: PointerhoverHook;
    onOut?: PointerhoverHook;
};
type PointerhoverHook = (api: PointerhoverHookApi) => any;
type PointerhoverHookApi = HookApi<PointerhoverType, PointerhoverMetadata>;
/**
 * [Docs](https://baleada.dev/docs/logic/factories/pointerhover)
 */
declare function createPointerhover(options?: PointerhoverOptions): {
    pointerover: {
        effect: RecognizeableEffect<"pointerover", PointerhoverMetadata>;
        stop: () => void;
    };
    pointerout: RecognizeableEffect<"pointerout", PointerhoverMetadata>;
};
declare class Pointerhover extends Listenable<PointerhoverType, PointerhoverMetadata> {
    constructor(options?: PointerhoverOptions);
    get metadata(): PointerhoverMetadata;
}

export { type AnimateFrame, type AnimateFrameEffect, type AnimateOptions, Animateable, type AnimateableKeyframe, type AnimateableOptions, type AnimateableStatus, type AssociativeArray, Broadcastable, type BroadcastableOptions, type BroadcastableStatus, type ColorInterpolationMethod, Compareable, type CompareableOptions, type CompareableStatus, type CompleteOptions, Completeable, type CompleteableOptions, type CompleteableStatus, Copyable, type CopyableOptions, type CopyableStatus, type CreateStepsOptions$1 as CreateDirectedAcyclicStepsOptions, type CreateFocusableOptions, type CreateGraphOptions, type CreateKeycomboMatchOptions, type CreateMixOptions, type CreatePathConfig, type CreateResultsOptions, type DefinedIDBObjectStore, Delayable, type DelayableEffect, type DelayableOptions, type DelayableStatus, Drawable, type DrawableOptions, type DrawableStatus, type DrawableStroke, Fetchable, type FetchableOptions, type FetchableStatus, Fullscreenable, type FullscreenableGetElement, type FullscreenableOptions, type FullscreenableStatus, Grantable, type GrantableOptions, type GrantableStatus, type Graph, type GraphAsync, type GraphAsyncEdge, type GraphCommonAncestor, type GraphEdge, type GraphNode, type GraphPath, type GraphState, type GraphStep, type GraphTree, type GraphTreeNode, type KeyboardEventDescriptor, Keychord, type KeychordHook, type KeychordHookApi, type KeychordMetadata, type KeychordOptions, type KeychordType, Keypress, type KeypressHook, type KeypressHookApi, type KeypressMetadata, type KeypressOptions, type KeypressType, Keyrelease, type KeyreleaseHook, type KeyreleaseHookApi, type KeyreleaseMetadata, type KeyreleaseOptions, type KeyreleaseType, Konami, type KonamiHook, type KonamiHookApi, type KonamiMetadata, type KonamiOptions, type KonamiType, type ListenEffect, type ListenEffectParam, type ListenOptions, Listenable, type ListenableActive, type ListenableKeycombo, type ListenableMousecombo, type ListenableOptions, type ListenablePointercombo, type ListenableStatus, type ListenableSupportedEventType, type ListenableSupportedType, type MixColor, Navigateable, type NavigateableOptions, type NavigateableStatus, type NextAndPreviousOptions, type OpenOptions, Operateable, type OperateableOptions, type OperateableStatus, type OperationDescriptor, type PickOptions, Pickable, type PickableOptions, type PickableStatus, Pointerhover, type PointerhoverHook, type PointerhoverHookApi, type PointerhoverMetadata, type PointerhoverOptions, type PointerhoverType, Pointerpress, type PointerpressHook, type PointerpressHookApi, type PointerpressMetadata, type PointerpressOptions, type PointerpressType, type Potentiality, type RecognizeOptions, Recognizeable, type RecognizeableEffect, type RecognizeableEffectConfig, type RecognizeableOptions, type RecognizeableStatus, type RecognizeableStopTarget, Resolveable, type ResolveableOptions, type ResolveableStatus, Shareable, type ShareableOptions, type ShareableStatus, Storeable, type StoreableOptions, type StoreableStatus, type ToGraphYielded, type TransactEffect, type TransactOptions, Transactable, type TransactableOptions, type TransactableStatus, createFormat$2 as createArrayFormat, 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, createFormat$1 as createDateFormat, 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, createDefineObjectStore, 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, createNumber, createFormat as createNumberFormat, createOmit, createOnlyChild, createOutdegree, createOutgoing, createPick, createPointerhover, createPointerpress, createReduce, createReduceAsync, createRemove, createReorder, createReplace, createResults, createReverse, createRoot, createSanitize, createSet, createShuffle, createSiblings, createSlice, createSlug, createSome, createSort, createSwap, createTerminal, createTotalSiblings, createFind as createTreeFind, createTry, createTryAsync, createUnique, createValue, defineAnimateableKeyframes, defineAssociativeArray, defineGraph, defineGraphAsync, defineGraphAsyncEdge, defineGraphAsyncEdges, 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, fromAliasToCode, fromCodeToAliases, fromKeyboardEventDescriptorToAliases, fromShorthandAliasToLonghandAlias, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };