@witchcraft/spellcraft 0.0.1

package/dist/runtime/composables/useLabeledByKeyboardLayoutMap.d.ts

@@ -0,0 +1,9 @@
+import { type Ref } from "vue";
+import { labelWithKeyboardMap } from "../../helpers/labelWithKeyboardMap.js.js";
+import type { Manager } from "../../types/manager.js.js";
+/**
+ * Sets up {@link getKeyboardLayoutMap} and {@link onKeyboardLayoutChange} to use {@link labelWithKeyboardMap}.
+ *
+ * Returns a ref of the latest key labels to have been set.
+ */
+export declare function useLabeledByKeyboardLayoutMap(manager: Manager): Ref<ReturnType<typeof labelWithKeyboardMap> | undefined>;

package/dist/runtime/composables/useLabeledByKeyboardLayoutMap.js

@@ -0,0 +1,19 @@
+import { ref } from "vue";
+import { getKeyboardLayoutMap } from "../../helpers/getKeyboardLayoutMap.js";
+import { labelWithKeyboardMap } from "../../helpers/labelWithKeyboardMap.js";
+import { onKeyboardLayoutChange } from "../../helpers/onKeyboardLayoutChange.js";
+export function useLabeledByKeyboardLayoutMap(manager) {
+  const labeledByMap = ref();
+  void getKeyboardLayoutMap().then((map) => {
+    if (map) {
+      labeledByMap.value = labelWithKeyboardMap(manager, { map });
+    }
+  });
+  void onKeyboardLayoutChange(async () => {
+    const map = await getKeyboardLayoutMap();
+    if (map) {
+      labeledByMap.value = labelWithKeyboardMap(manager, { map });
+    }
+  });
+  return labeledByMap;
+}

package/dist/runtime/composables/usePointerCoords.d.ts

@@ -0,0 +1,32 @@
+import { type ComputedRef } from "vue";
+/**
+ * Returns a set of coordinates that includes an initial offset.
+ *
+ * For use with drag or similar events.
+ *
+ * `setInitialOffset` should be called at drag start.
+ *
+ * `setPointerCoords` can then be called on drag move.
+ *
+ * And `coords` will reflect the coordinates of the event + the initial offset.
+ *
+ * This can then be used to position an element and it won't jump, it will stay grabbed from where the user initially grabbed it.
+ */
+export declare const usePointerCoords: () => {
+    pointerCoords: {
+        x: number;
+        y: number;
+    };
+    coords: ComputedRef<{
+        x: number;
+        y: number;
+    }>;
+    setPointerCoords: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+    setInitialPointerOffset: (e: {
+        clientX: number;
+        clientY: number;
+    }, el: HTMLElement) => void;
+};

package/dist/runtime/composables/usePointerCoords.js

@@ -0,0 +1,17 @@
+import { computed, reactive } from "vue";
+export const usePointerCoords = () => {
+  const pointerCoords = reactive({ x: 0, y: 0 });
+  const offsetCoords = reactive({ x: 0, y: 0 });
+  const coords = computed(() => ({ x: pointerCoords.x - offsetCoords.x, y: pointerCoords.y - offsetCoords.y }));
+  const setPointerCoords = (e) => {
+    pointerCoords.x = e.clientX;
+    pointerCoords.y = e.clientY;
+  };
+  const setInitialPointerOffset = (e, el) => {
+    setPointerCoords(e);
+    const clientRect = el.getBoundingClientRect();
+    offsetCoords.x = pointerCoords.x - clientRect.x;
+    offsetCoords.y = pointerCoords.y - clientRect.y;
+  };
+  return { pointerCoords, coords, setPointerCoords, setInitialPointerOffset };
+};

package/dist/runtime/composables/useShortcutManagerContextCount.d.ts

@@ -0,0 +1,14 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { Manager } from "../../types/manager.js.js";
+import type { ContextInfo } from "../types.js.js";
+/**
+ * Updates the count of the ctx variables depending on how many shortcuts are using the variable. Requires shortcuts use the expressit library to set the ast property of conditions.
+ *
+ * Useful to know if we can delete a ctx.
+ */
+export declare function useShortcutManagerContextCount(manager: Ref<Manager> | ComputedRef<Manager>, context: Ref<ContextInfo>): {
+    addContext(ctx: string): void;
+    removeContext(ctx: string): void;
+    activateContext(ctx: string): void;
+    deactivateContext(ctx: string): void;
+};

package/dist/runtime/composables/useShortcutManagerContextCount.js

@@ -0,0 +1,61 @@
+import { keys } from "@alanscodelog/utils/keys";
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { extractTokens } from "@witchcraft/expressit/utils/extractTokens";
+import { watch } from "vue";
+export function useShortcutManagerContextCount(manager, context) {
+  watch(() => manager.value.shortcuts.entries, (newShortcuts) => {
+    const rc = {};
+    for (const shortcut of newShortcuts) {
+      if (!("ast" in shortcut.condition)) continue;
+      const c = shortcut.condition.ast;
+      if (c) {
+        const tokens = extractTokens(c);
+        const seen = [];
+        for (const token of tokens) {
+          if (token.type === "VALUE") {
+            if (seen.includes(token.value)) continue;
+            seen.push(token.value);
+            rc[token.value] = rc[token.value] ? rc[token.value] + 1 : 1;
+          }
+        }
+      }
+    }
+    for (const ctx of keys(context.value)) {
+      context.value.count[ctx] = rc[ctx] ?? 0;
+    }
+    for (const ctx of keys(rc)) {
+      if (!context.value.isActive[ctx]) {
+        context.value.isActive[ctx] = false;
+        context.value.count[ctx] = rc[ctx];
+      }
+    }
+  }, { deep: true, immediate: true });
+  function addContext(ctx) {
+    if (!context.value.isActive[ctx]) {
+      context.value.isActive[ctx] = true;
+      context.value.count[ctx] = 0;
+    } else {
+      unreachable();
+    }
+  }
+  function removeContext(ctx) {
+    if (context.value.count[ctx] === 0) {
+      delete context.value.isActive[ctx];
+      delete context.value.count[ctx];
+    } else {
+      unreachable();
+    }
+  }
+  function activateContext(ctx) {
+    context.value.isActive[ctx] ||= true;
+  }
+  function deactivateContext(ctx) {
+    context.value.isActive[ctx] &&= false;
+  }
+  return {
+    addContext,
+    removeContext,
+    activateContext,
+    deactivateContext
+  };
+}

package/dist/runtime/composables/useShortcutManagerKeysLayout.d.ts

@@ -0,0 +1,18 @@
+import { type Ref } from "vue";
+import type { Keys } from "../../types/keys.js.js";
+/**
+ * Watches Keys.layout.x/y and listens to resize changes on the element containing the keys to update what the pixel height of the element should be and what the pixel keyWidth.
+ *
+ * While it also returns the width and the ratio, you should not set the element to them.
+ *
+ */
+export declare const useShortcutManagerKeysLayout: (keys: Keys, keyboardEl: Ref<HTMLElement | null>) => {
+    width: Ref<number>;
+    height: Ref<number>;
+    ratio: Ref<number>;
+    keyWidth: Ref<number>;
+    layout: {
+        x: number;
+        y: number;
+    };
+};

package/dist/runtime/composables/useShortcutManagerKeysLayout.js

@@ -0,0 +1,22 @@
+import { useGlobalResizeObserver } from "@witchcraft/ui/composables/useGlobalResizeObserver";
+import { computed, reactive, ref, watch } from "vue";
+export const useShortcutManagerKeysLayout = (keys, keyboardEl) => {
+  const layout = reactive({ x: keys.layout.x, y: keys.layout.y });
+  watch([() => keys.layout.x, () => keys.layout.y], ([x, y]) => {
+    layout.x = x;
+    layout.y = y;
+  });
+  const width = ref(0);
+  const keyWidth = computed(() => {
+    const val = width.value / layout.x;
+    return Number.isNaN(val) ? 1 : val;
+  });
+  const ratio = computed(() => layout.x / layout.y);
+  const height = computed(() => width.value / ratio.value);
+  useGlobalResizeObserver(keyboardEl, function updateSize() {
+    if (keyboardEl.value) {
+      width.value = Math.max(keyboardEl.value.offsetWidth, 1e3);
+    }
+  });
+  return { width, height, ratio, keyWidth, layout };
+};

package/dist/runtime/composables/useShortcutManagerVirtualPress.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from "vue";
+import type { ManagerListener } from "../../types/index.js.js";
+export declare function useShortcutManagerVirtualPress(): {
+    virtuallyPressedKeys: Ref<Record<string, boolean>>;
+    updateVirtuallyPressed: ManagerListener;
+};

package/dist/runtime/composables/useShortcutManagerVirtualPress.js

@@ -0,0 +1,24 @@
+import { ref } from "vue";
+export function useShortcutManagerVirtualPress() {
+  const virtuallyPressedKeys = ref({});
+  function updateVirtuallyPressed(arg) {
+    const { event, keys, isKeydown } = arg;
+    if (!event) {
+      for (const key of keys) {
+        if (isKeydown) {
+          virtuallyPressedKeys.value[key] = true;
+        } else {
+          delete virtuallyPressedKeys.value[key];
+        }
+      }
+    } else {
+      for (const key of keys) {
+        delete virtuallyPressedKeys.value[key];
+      }
+    }
+  }
+  return {
+    virtuallyPressedKeys,
+    updateVirtuallyPressed
+  };
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,10 @@
+export interface Register {
+}
+type ExtendedContextInfo = Register extends {
+    ExtendedContextInfo: infer T;
+} ? T : unknown;
+export type ContextInfo = ExtendedContextInfo & {
+    count: Record<string, number>;
+    isActive: Record<string, boolean>;
+};
+export {};

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/utils/shortcutToId.d.ts

@@ -0,0 +1,5 @@
+import type { PickManager } from "../../types/general.js.js";
+import type { Manager } from "../../types/manager.js.js";
+import type { Shortcut } from "../../types/shortcuts.js.js";
+/** Turns a shortcut into an id to use in a v-for loop. */
+export declare const shortcutToId: (shortcut: Shortcut, manager: PickManager<"options", "stringifier"> & Pick<Manager, "keys">) => string;

package/dist/runtime/utils/shortcutToId.js

@@ -0,0 +1,6 @@
+export const shortcutToId = (shortcut, manager) => [
+  shortcut.enabled,
+  manager.options.stringifier.stringify(shortcut.chain, manager),
+  shortcut.command ?? "",
+  shortcut.condition.text
+].join("--");

package/dist/types/commands.d.ts

@@ -0,0 +1,113 @@
+import type { Condition } from "./condition.js";
+import type { Context } from "./context.js";
+import type { SHORTCUT_ERROR } from "./enums.js";
+import type { PickManager } from "./general.js";
+import type { AnyInputEvent, Manager, MinimalInputEvent } from "./manager.js";
+import type { Shortcut } from "./shortcuts.js";
+export type RawCommand<TName extends string = string> = Pick<Command<TName>, "name"> & Partial<Command<TName>>;
+export type CommandExecute<TName extends string = string> = <T extends AnyInputEvent | MinimalInputEvent = AnyInputEvent | MinimalInputEvent>(args: {
+    isKeydown: boolean;
+    command: Command<TName>;
+    shortcut?: Shortcut<TName> | undefined;
+    /**
+     * The event that triggered the command. It might be undefined if a virtual event triggered the key. It's typed as {@link AnyInputEvent} because you might also receive Emulated events from the {@link Emulator} if you use it. If you don't you can safely ignore the {@link EmulatedEvent} type or type the execute function as `CommandExecute<AnyInputEvent>`
+     */
+    event?: T;
+    /**
+     * The manager might be undefined. This is to allow calling the command manually without it.
+     */
+    manager?: Manager;
+    context: Context;
+}) => void;
+export interface Command<TName extends string = string, TExec extends CommandExecute<string> = CommandExecute<string>, TCondition extends Condition = Condition> {
+    readonly type: "command";
+    /**
+     * Unique string to identify the command by.
+     *
+     * Note that when changing a command's name, it is not an error for the old command to not exist in the manager. This is to allow for easier checking if a command can be added. If you need it to be an error, you can add a canSetCommand hook.
+     *
+     * @RequiresSet @OnHookable @CanHookable
+     */
+    readonly name: TName;
+    /**
+     * The function to execute when a shortcut triggers it's command. It is executed both on keydown and keyup (of the first released key) so be sure to check the isKeydown parameter so you don't trigger commands twice.
+     *
+     * The command itself is passed to it, and if it is managed by a manager it is also passed the shortcut, the manager itself, and the event of the last key that triggered it. Note the event might not exist when the manager needs to emulate a key release. See {@link Manager.autoReleaseDelay}.
+     *
+     * You should do `e.preventDefault` if you need it or haven't done so from {@link Manager.eventFilter}.
+     *
+     * You should also do {@link safeSetManagerChain} on keyup for most regular shortcuts. See it for details.
+     *
+     * See {@link Manager}.
+     *
+     * @RequiresSet @OnHookable @CanHookable
+     */
+    readonly execute?: TExec;
+    /**
+     * Commands may have an additional condition that must be met, apart from the shortcut's that triggered it.
+     *
+     * If the command is created without a condition, it is assigned a blank condition. If you are using a custom condition class, you should probably always pass a blank condition.
+     *
+     * @RequiresSet @OnHookable @CanHookable
+     */
+    readonly condition: TCondition;
+    /**
+     * A description of what the command does.
+     *
+     * @RequiresSet @OnHookable @CanHookable
+     */
+    readonly description: string;
+}
+export type Commands<TEntries extends Record<string, Command> = Record<string, Command>> = {
+    type: "commands";
+    /**
+     * The command entries.
+     *
+     * To add/remove entries you should {@link addCommand}/{@link removeCommand} or {@link setCommandsProp} with the synthetic `entries@add/remove` properties.
+     *
+     * The synthetic properties can be hooked into with {@link Manager.hooks}.
+     *
+     * @RequiresSet @OnHookable @Managed
+     */
+    entries: TEntries;
+};
+export type RawCommands = Pick<Commands, "entries"> & Partial<Commands>;
+type GetCommandHooks<T extends keyof CommandSetEntries | keyof CommandsSetEntries> = T extends CanHookCommandProps ? Partial<Pick<NonNullable<Manager["hooks"]>, "canSetCommandProp" | "onSetCommandProp">> : T extends OnHookCommandProps ? Partial<Pick<NonNullable<Manager["hooks"]>, "onSetCommandProp">> : T extends CanHookCommandsProps ? Partial<Pick<NonNullable<Manager["hooks"]>, "canSetCommandsProp" | "onSetCommandsProp">> : Partial<Pick<NonNullable<Manager["hooks"]>, "onSetCommandsProp">>;
+type Unmanaged<T extends keyof Command & keyof CommandSetEntries> = {
+    val: Command[T];
+    manager: never;
+    hooks: GetCommandHooks<T>;
+    error: never;
+};
+export type CommandSetEntries = {
+    condition: Unmanaged<"condition">;
+    execute: Unmanaged<"execute">;
+    description: Unmanaged<"description">;
+    name: {
+        val: string;
+        manager: Pick<Manager, "commands" | "shortcuts" | "keys"> & PickManager<"options", "stringifier">;
+        hooks: GetCommandHooks<"name">;
+        error: typeof SHORTCUT_ERROR.COMMAND_IN_USE | typeof SHORTCUT_ERROR.DUPLICATE_COMMAND | typeof SHORTCUT_ERROR.MULTIPLE_ERRORS;
+    };
+};
+export type OnHookCommandProps = "condition" | "execute" | "description";
+export type CanHookCommandProps = OnHookCommandProps;
+type BaseCommandsManager = PickManager<"options", "stringifier"> & Record<any, any> & Pick<Manager, "commands">;
+export type CommandsSetEntries = {
+    "entries@add": {
+        val: Command;
+        hooks: GetCommandHooks<`entries@add`>;
+        manager: BaseCommandsManager;
+        error: typeof SHORTCUT_ERROR.DUPLICATE_COMMAND;
+    };
+    "entries@remove": {
+        val: Command;
+        hooks: GetCommandHooks<`entries@remove`>;
+        manager: BaseCommandsManager & Pick<Manager, "shortcuts" | "keys">;
+        error: typeof SHORTCUT_ERROR.COMMAND_IN_USE | typeof SHORTCUT_ERROR.MISSING;
+    };
+};
+export type SyntheticOnHookCommandsProps = "entries@add" | "entries@remove";
+export type CanHookCommandsProps = SyntheticOnHookCommandsProps;
+export type OnHookCommandsProps = SyntheticOnHookCommandsProps;
+export {};

package/dist/types/condition.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from "./context.js";
+export type RawCondition = string;
+/**
+    * This just describes a condition. No logic to parse/evaluate them is provided and a third party library should be used. The {@link ConditionEvaluator} can then be used to specify how to evaluate them.
+    */
+export interface Condition {
+    type: "condition";
+    /**
+     * The main text representation of the condition. Note that this is NOT a unique identifier for conditions and cannot be used to compare them if you are using boolean expressions for your conditions. See {@link Condition.constructor} for an explanation.
+     */
+    text: string;
+}
+/**
+ * Returns whether the condition passed is equal to this one.
+ *
+ * The default method does a simplistic check of the `text` property for equality. If you override the method you will likely want it to just always return false.
+ *
+ * Why? Because unless you're using simple single variable conditions that you can presort to make them uniquely identifiable (i.e. not boolean expressions, but something like `!a b !c`), this will return A LOT of false negatives.
+ *
+ * Why the false negatives? Because two conditions might be functionally equal but have differing representations (e.g: `a && b`, `b && a`). You might think, lets normalize them all, but normalizing boolean expressions (converting them to CNF) can be dangerous with very long expressions because it can take exponential time.
+ *
+ * Now the main reason for checking the equality of two conditions is to check if two shortcuts might conflict. If we're using boolean expressions it just can't be done safely.
+ *
+ * This is a personal preference, but if we have a method that gives false negatives it can be confusing that some shortcuts immediately error when added because their conditions are simple, while others don't until triggered. The simpler, more consistent alternative is to only have them error on triggering. Aditionally conflicting conditions can be shown on the keyboard layout when then user picks contexts to check against.
+ *
+ * Why use the default implementation at all then? Well, shortcuts aren't the only ones that have conditions, commands can too, but unlike shortcuts, usually it's developers who are in charge of assigning a command's condition, and since they are usually simple, it's more possible to make sure the conditions are unique (e.g. tests could enforce they're unique by converting them all to CNF and pre-checking them for equality).
+ */
+export type ConditionComparer = (conditionA?: Condition, conditionB?: Condition) => boolean;
+export type ConditionEvaluator<TContext extends Context<any>> = (condition: Condition, context: TContext) => boolean;

package/dist/types/context.d.ts

@@ -0,0 +1,18 @@
+export interface RecursiveRecord {
+    [key: string]: any | RecursiveRecord;
+}
+/**
+ * # Context
+ *
+ * Like {@link Condition}, provides a way to describe contexts. How contexts look and work is up to you.
+ *
+ * Contexts describe the relevant application state. They are what {@link Condition}s are evaluated against.
+ *
+ * @template TValue **@internal** Captures the type of the context value.
+ */
+export type Context<TValue extends object = any> = {
+    type: "context";
+    /** Where the context object is stored. */
+    value: TValue;
+};
+export type RawContext = Pick<Context, "value"> & Partial<Context>;

package/dist/types/enums.d.ts

@@ -0,0 +1,186 @@
+import type { EnumLike } from "@alanscodelog/utils";
+import type { Command, Commands } from "./commands.js";
+import type { Key, Keys } from "./keys.js";
+import type { AnyInputEvent } from "./manager.js";
+import type { Shortcut, Shortcuts } from "./shortcuts.js";
+import type { KnownError } from "../helpers/index.js";
+/**
+ * All possible errors.
+ */
+export declare const SHORTCUT_ERROR: {
+    CHORD_W_ONLY_MODIFIERS: "CHORD_W_ONLY_MODIFIERS";
+    CHORD_W_MULTIPLE_TRIGGER_KEYS: "CHORD_W_MULTIPLE_TRIGGER_KEYS";
+    CHORD_W_MULTIPLE_WHEEL_KEYS: "CHORD_W_MULTIPLE_WHEEL_KEYS";
+    CHORD_W_DUPLICATE_KEY: "CHORD_W_DUPLICATE_KEY";
+    IMPOSSIBLE_TOGGLE_SEQUENCE: "IMPOSSIBLE_TOGGLE_SEQUENCE";
+    MISSING: "MISSING";
+    INVALID_VARIANT: "INVALID_VARIANT";
+    INVALID_VARIANT_PAIR: "INVALID_VARIANT_PAIR";
+    DUPLICATE_KEY: "DUPLICATE_KEY";
+    DUPLICATE_COMMAND: "DUPLICATE_COMMAND";
+    DUPLICATE_SHORTCUT: "DUPLICATE_SHORTCUT";
+    INVALID_SWAP_CHORDS: "INVALID_SWAP_CHORDS";
+    CANNOT_SET_WHILE_DISABLED: "CANNOT_SET_WHILE_DISABLED";
+    MULTIPLE_MATCHING_SHORTCUTS: "MULTIPLE_MATCHING_SHORTCUTS";
+    INCORRECT_TOGGLE_STATE: "INCORRECT_TOGGLE_STATE";
+    NO_MATCHING_SHORTCUT: "NO_MATCHING_SHORTCUT";
+    UNKNOWN_KEY: "UNKNOWN_KEY";
+    UNKNOWN_KEY_ID: "UNKNOWN_KEY_ID";
+    UNKNOWN_COMMAND: "UNKNOWN_COMMAND";
+    KEY_IN_USE: "KEY_IN_USE";
+    COMMAND_IN_USE: "COMMAND_IN_USE";
+    UNKNOWN_KEY_EVENT: "UNKNOWN_KEY_EVENT";
+    MULTIPLE_ERRORS: "MULTIPLE_ERRORS";
+    INVALID_MANAGER: "INVALID_MANAGER";
+};
+export type ShortcutError = EnumLike<typeof SHORTCUT_ERROR>;
+export type ChainError = typeof SHORTCUT_ERROR.UNKNOWN_KEY | typeof SHORTCUT_ERROR.CHORD_W_DUPLICATE_KEY | typeof SHORTCUT_ERROR.CHORD_W_ONLY_MODIFIERS | typeof SHORTCUT_ERROR.CHORD_W_MULTIPLE_TRIGGER_KEYS | typeof SHORTCUT_ERROR.CHORD_W_MULTIPLE_WHEEL_KEYS | typeof SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE;
+/** Errors that will throw since they should be caught at production. */
+export declare const TYPE_ERROR: {
+    ILLEGAL_OPERATION: "ILLEGAL_OPERATION";
+    HOOK_OR_LISTENER_DOES_NOT_EXIST: "HOOK_OR_LISTENER_DOES_NOT_EXIST";
+    FILTER_DOES_NOT_EXIST: "FILTER_DOES_NOT_EXIST";
+};
+export type TypeError = EnumLike<typeof TYPE_ERROR>;
+/**
+ * Defines the properties attached to each error.
+ *
+ * Makes it easy to define the properties attached to each error by just allowing passing the error (regardless of error type) as T in [[KnownError]] and [[InternalError]].
+ */
+export type ErrorInfo<T extends ShortcutError | TypeError> = T extends ShortcutError ? ERROR_Info[T] : never;
+/** Type multiple {@link KnownError} errors to work like a discriminated union. */
+export type MultipleErrors<T extends ShortcutError | TypeError> = {
+    [k in T]: KnownError<k>;
+}[T];
+type ERROR_Info = {
+    [SHORTCUT_ERROR.CHORD_W_ONLY_MODIFIERS]: {
+        chord: string[];
+        i: number;
+        keys: string[];
+    };
+    [SHORTCUT_ERROR.CHORD_W_MULTIPLE_TRIGGER_KEYS]: {
+        chord: string[];
+        i: number;
+        keys: string[];
+    };
+    [SHORTCUT_ERROR.CHORD_W_MULTIPLE_WHEEL_KEYS]: {
+        chord: string[];
+        i: number;
+        keys: string[];
+    };
+    [SHORTCUT_ERROR.CHORD_W_DUPLICATE_KEY]: {
+        chord: string[];
+        i: number;
+        keys: string[];
+    };
+    [SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE]: {
+        chain: string[][];
+        i: number;
+        key: Key;
+    };
+    [SHORTCUT_ERROR.MISSING]: {
+        entry: Key | Shortcut | Command | string;
+        self: Keys | Shortcuts | Commands;
+    };
+    [SHORTCUT_ERROR.INVALID_VARIANT]: {
+        variants: string[];
+        id: string;
+    };
+    [SHORTCUT_ERROR.INVALID_VARIANT_PAIR]: {
+        variants: Key[];
+        key: Key;
+        otherKey: Key;
+    };
+    [SHORTCUT_ERROR.DUPLICATE_KEY]: {
+        existing: Key;
+        self: Keys;
+    };
+    [SHORTCUT_ERROR.DUPLICATE_SHORTCUT]: {
+        existing: Shortcut;
+        self: Shortcuts;
+        /** If the error is caused by a change, key and value will contain the new key and value. */
+        key?: string;
+        value?: any;
+    };
+    [SHORTCUT_ERROR.DUPLICATE_COMMAND]: {
+        existing: Command;
+        self: Commands;
+    };
+    [SHORTCUT_ERROR.INVALID_SWAP_CHORDS]: {
+        chord: string[][];
+    } | {
+        chordsA: string[][];
+        chordsB: string[][];
+    };
+    [SHORTCUT_ERROR.CANNOT_SET_WHILE_DISABLED]: {
+        key: Key;
+    };
+    [SHORTCUT_ERROR.MULTIPLE_MATCHING_SHORTCUTS]: {
+        shortcuts: Shortcut[];
+    };
+    [SHORTCUT_ERROR.INCORRECT_TOGGLE_STATE]: {
+        key: Key;
+    };
+    [SHORTCUT_ERROR.NO_MATCHING_SHORTCUT]: {
+        chain: string[][];
+    };
+    [SHORTCUT_ERROR.UNKNOWN_KEY]: {
+        shortcut?: Pick<Shortcut, "chain">;
+        keys: string[] | Keys;
+    };
+    [SHORTCUT_ERROR.UNKNOWN_COMMAND]: {
+        shortcut?: Pick<Shortcut, "chain" | "command">;
+        command: string;
+        commands: string[] | Commands;
+    };
+    [SHORTCUT_ERROR.MULTIPLE_ERRORS]: {
+        errors: Error[];
+    };
+    [SHORTCUT_ERROR.KEY_IN_USE]: {
+        inUseShortcuts: Shortcut[];
+    };
+    [SHORTCUT_ERROR.COMMAND_IN_USE]: {
+        inUseShortcuts: Shortcut[];
+    };
+    [SHORTCUT_ERROR.UNKNOWN_KEY_EVENT]: {
+        e: AnyInputEvent;
+        button?: string;
+        code?: string;
+        key?: string;
+        deltaY?: number | string;
+    };
+    [SHORTCUT_ERROR.UNKNOWN_KEY_ID]: {
+        id: string;
+    };
+    [SHORTCUT_ERROR.INVALID_MANAGER]: {
+        keys: string[];
+    };
+};
+export declare const MOUSE: {
+    R: "R";
+    M: "M";
+    L: "L";
+    BACK: "BACK";
+    FORWARD: "FORWARD";
+};
+export type Mouse = EnumLike<typeof MOUSE>;
+export declare const WHEEL: {
+    down: "down";
+    up: "up";
+};
+export type Wheel = EnumLike<typeof WHEEL>;
+export declare const KEY_SORT_POS: {
+    mod: number;
+    modmouse: number;
+    modwheel: number;
+    modtoggle: number;
+    modtogglemouse: number;
+    modtogglewheel: number;
+    normal: number;
+    mouse: number;
+    wheel: number;
+    toggle: number;
+    togglemouse: number;
+    togglewheel: number;
+};
+export {};