export declare const accessibilityVariable: {
    readonly roleString: "accessibility.focused_ui_element.role_string";
    readonly subroleString: "accessibility.focused_ui_element.subrole_string";
    readonly titleString: "accessibility.focused_ui_element.title_string";
    readonly windowPositionX: "accessibility.focused_ui_element.window_position_x";
    readonly windowPositionY: "accessibility.focused_ui_element.window_position_y";
    readonly windowSizeHeight: "accessibility.focused_ui_element.window_size_height";
    readonly windowSizeWidth: "accessibility.focused_ui_element.window_size_width";
};

export declare type ArrowKeyAlias = keyof typeof arrowKeyAliases;

export declare let arrowKeyAliases: {
    readonly '\u2191': "up_arrow";
    readonly '\u2193': "down_arrow";
    readonly '\u2190': "left_arrow";
    readonly '\u2192': "right_arrow";
    readonly '\u21DE': "page_up";
    readonly '\u21DF': "page_down";
    readonly '\u2196\uFE0E': "home";
    readonly '\u2198\uFE0E': "end";
};

export declare type ArrowKeyCode = (typeof arrowKeyCodes)[number];

export declare let arrowKeyCodes: readonly ["up_arrow", "down_arrow", "left_arrow", "right_arrow", "page_up", "page_down", "home", "end"];

export declare type BasicManipulator = {
    type: 'basic';
    from: FromEvent;
    to?: ToEvent[];
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-if-alone/ */
    to_if_alone?: ToEvent[];
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-if-held-down/ */
    to_if_held_down?: ToEvent[];
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-after-key-up/ */
    to_after_key_up?: ToEvent[];
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-delayed-action/ */
    to_delayed_action?: ToDelayedAction;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-if-other-key-pressed/ */
    to_if_other_key_pressed?: ToIfOtherKeyPressed[];
    parameters?: BasicParameters;
    conditions?: Condition[];
    description?: string;
};

export declare class BasicManipulatorBuilder implements ManipulatorBuilder {
    protected readonly manipulator: BasicManipulator;
    constructor(from: FromEvent);
    /** The FromEvent of the Manipulator. */
    get from(): FromEvent;
    /** Set or add ToEvent(s) to the Manipulator. */
    to(event: ToEvent | ToEvent[]): this;
    /** Set or add a ToEvent with a key_code. */
    to(key: ToKeyParam, modifiers?: ModifierParam, options?: ToEventOptions): this;
    /** To Hyper key ⌘⌥⌃⇧ */
    toHyper(options?: ToEventOptions): this;
    /** To Meh key ⌥⌃⇧ */
    toMeh(options?: ToEventOptions): this;
    /** To SuperHyper key ⌘⌥⌃⇧fn */
    toSuperHyper(options?: ToEventOptions): this;
    /** To vk_none (Disable this key) */
    toNone(options?: ToEventOptions): this;
    /** To { consumer_key_code } */
    toConsumerKey(code: ToConsumerKeyCode, modifiers?: ModifierParam, options?: ToEventOptions): this;
    /** To { generic_desktop } */
    toGenericDesktop(code: number, modifiers?: ModifierParam, options?: ToEventOptions): this;
    /** Map to mouse button */
    toPointingButton(button: PointingButton, modifiers?: ModifierParam, options?: ToEventOptions): this;
    /** Map to shell command */
    to$(shell_command: string): this;
    /** Map to `$ open -a {app}.app` */
    toApp(app: string): this;
    /** Map to paste {text} via clipboard */
    toPaste(text: string): this;
    /** To change the current input source */
    toInputSource(inputSource: ToInputSource): this;
    /** Map to setting a variable */
    toVar(name: string, value?: ToVariable['value'], key_up_value?: ToVariable['key_up_value'], type?: ToVariable['type']): this;
    /** Map to setting a variable using expressions */
    toVarExpression(name: string, options: {
        expression: string;
        key_up_expression?: string;
    }): this;
    /** Map to unsetting a variable */
    toUnsetVar(name: string): this;
    /** To set or remove (set text to '') the notification message */
    toNotificationMessage(id: string, text: string): this;
    /** To remove the notification message */
    toRemoveNotificationMessage(id: string): this;
    /** Move mouse cursor by delta */
    toMouseKey(mouse_key: ToMouseKey): this;
    /** Changes to a sticky modifier key */
    toStickyModifier(key: StickyModifierKeyCode, value?: 'on' | 'off' | 'toggle'): this;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/software_function/cg_event_double_click/ */
    toCgEventDoubleClick(button: number): this;
    /** Set mouse cursor position */
    toMouseCursorPosition(p: ToMouseCursorPosition): this;
    /** To causes a system sleep */
    toSleepSystem(delay?: number): this;
    /** Map to send_user_command */
    toSendUserCommand(payload: unknown, endpoint?: string): this;
    /** Pass through the from event as-is */
    toFromEvent(): this;
    /** To type a string of keys */
    toTypeSequence(src: string, map?: Record<string, ToEvent>): this;
    toIfAlone(event: ToEvent | ToEvent[]): this;
    toIfAlone(key: ToKeyParam, modifiers?: ModifierParam, options?: ToEventOptions): this;
    toIfHeldDown(event: ToEvent | ToEvent[]): this;
    toIfHeldDown(key: ToKeyParam, modifiers?: ModifierParam, options?: ToEventOptions): this;
    toAfterKeyUp(event: ToEvent | ToEvent[]): this;
    toAfterKeyUp(key: ToKeyParam, modifiers?: ModifierParam, options?: ToEventOptions): this;
    toDelayedAction(ifInvoked: ToEvent | ToEvent[], ifCanceled: ToEvent | ToEvent[]): this;
    /** Map to to_if_other_key_pressed */
    toIfOtherKeyPressed(otherKeys: (FromKeyType & {
        modifiers?: FromModifiers;
    })[], to: ToEvent | ToEvent[]): this;
    /** Map to to_if_other_key_pressed */
    toIfOtherKeyPressed(otherKeys: (FromKeyType & {
        modifiers?: FromModifiers;
    })[], key: ToKeyParam, modifiers?: ModifierParam, options?: ToEventOptions): this;
    description(v: string): this;
    condition(...v: Array<Condition | ConditionBuilder>): this;
    parameters(v: BasicParameters): this;
    build(_?: BuildContext): BasicManipulator[];
    protected addToEvent(event: ToEvent | ToEvent[]): void;
    protected pushOrCreateList<TListHolder extends {}, TItem>(obj: TListHolder, key: keyof TListHolder, item: TItem | TItem[]): void;
}

export declare type BasicParameters = {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/simultaneous/#change-threshold-milliseconds */
    'basic.simultaneous_threshold_milliseconds'?: number;
    'basic.to_if_alone_timeout_milliseconds'?: number;
    'basic.to_if_held_down_threshold_milliseconds'?: number;
    'basic.to_delayed_action_delay_milliseconds'?: number;
};

declare class BasicRuleBuilder implements RuleBuilder {
    protected ruleDescription: string;
    protected readonly conditions: Array<Condition | ConditionBuilder>;
    protected readonly manipulatorSources: Array<Manipulator | ManipulatorBuilder | ManipulatorMap>;
    protected allowEmptyManipulators: boolean;
    constructor(ruleDescription: string, ...conditions: Array<Condition | ConditionBuilder>);
    manipulators(src: ManipulatorMap | Array<Manipulator | ManipulatorBuilder | ManipulatorMap>): this;
    condition(...v: Array<Condition | ConditionBuilder>): this;
    description(v: string): this;
    build(context?: BuildContext): Rule;
}

export declare function buildCondition(src: Condition | ConditionBuilder): Condition;

export declare class BuildContext {
    private readonly parameters;
    private readonly cache;
    setParameters<TDefaults extends {}>(v: Partial<TDefaults>): void;
    getParameters<TDefaults extends {}>(defaults: TDefaults): TDefaults;
    getCache<T>(key: string): T;
    setCache<T>(key: string, value: T): void;
}

export declare type ComplexModifications = {
    parameters: ComplexModificationsParameters;
    rules: Rule[];
};

export declare function complexModifications(rules: Array<Rule | RuleBuilder>, parameters?: ModificationParameters): ComplexModifications;

export declare type ComplexModificationsParameters = BasicParameters & MouseMotionToScrollParameters;

export declare type Condition = {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/frontmost-application/ */
    type: 'frontmost_application_if' | 'frontmost_application_unless';
    description?: string;
    bundle_identifiers?: string[];
    file_paths?: string[];
} | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/device/ */
    type: 'device_if' | 'device_unless' | 'device_exists_if' | 'device_exists_unless';
    identifiers: DeviceIdentifier[];
    description?: string;
} | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/keyboard-type/ */
    type: 'keyboard_type_if' | 'keyboard_type_unless';
    keyboard_types: KeyboardType[];
    description?: string;
} | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/input-source/ */
    type: 'input_source_if' | 'input_source_unless';
    input_sources: InputSource[];
    description?: string;
} | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/variable/ */
    type: 'variable_if' | 'variable_unless';
    name: string;
    value: number | boolean | string;
    description?: string;
} | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/expression/ */
    type: 'expression_if' | 'expression_unless';
    expression: string;
    description?: string;
} | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/event-changed/ */
    type: 'event_changed_if' | 'event_changed_unless';
    value: boolean;
    description?: string;
};

export declare class ConditionBuilder {
    private readonly condition;
    constructor(condition: Condition);
    /** Switch type {condition}_if to {condition}_unless, and vice versa */
    unless(): ConditionBuilder;
    build(): Condition;
}

export declare type ConsumerKeyCode = FromAndToConsumerKeyCode | FromOnlyConsumerKeyCode | ToOnlyConsumerKeyCode;

export declare type ControlOrSymbolKeyAlias = keyof typeof controlOrSymbolKeyAliases;

export declare let controlOrSymbolKeyAliases: {
    readonly '\u23CE': "return_or_enter";
    readonly '\u238B': "escape";
    readonly '\u232B': "delete_or_backspace";
    readonly '\u2326': "delete_forward";
    readonly '\u21E5': "tab";
    readonly '\u2423': "spacebar";
    readonly '-': "hyphen";
    readonly '=': "equal_sign";
    readonly '[': "open_bracket";
    readonly ']': "close_bracket";
    readonly '\\': "backslash";
    readonly ';': "semicolon";
    readonly "'": "quote";
    readonly '`': "grave_accent_and_tilde";
    readonly ',': "comma";
    readonly '.': "period";
    readonly '/': "slash";
};

export declare type ControlOrSymbolKeyCode = (typeof controlOrSymbolKeyCodes)[number];

export declare let controlOrSymbolKeyCodes: readonly ["return_or_enter", "escape", "delete_or_backspace", "delete_forward", "tab", "spacebar", "hyphen", "equal_sign", "open_bracket", "close_bracket", "backslash", "non_us_pound", "semicolon", "quote", "grave_accent_and_tilde", "comma", "period", "slash", "non_us_backslash"];

export declare let defaultComplexModificationsParameters: ComplexModificationsParameters;

export declare let defaultDoubleTapParameters: {
    'double_tap.delay_milliseconds': number;
};

export declare let defaultDuoLayerParameters: {
    'duo_layer.threshold_milliseconds': number;
    'duo_layer.notification': boolean | string;
    'duo_layer.delay_by_default': boolean;
    'duo_layer.delay_milliseconds': number;
};

export declare let defaultLayerParameters: {
    'layer.delay_by_default': boolean;
    'layer.delay_milliseconds': number;
};

export declare let defaultSimlayerParameters: {
    'simlayer.threshold_milliseconds': number;
};

export declare type DeviceIdentifier = {
    vendor_id?: number;
    product_id?: number;
    location_id?: number;
    device_address?: string;
    is_keyboard?: boolean;
    is_pointing_device?: boolean;
    is_touch_bar?: boolean;
    is_built_in_keyboard?: boolean;
};

declare class DoubleTapManipulatorBuilder extends BasicManipulatorBuilder {
    private singleTapEvent?;
    private delayParam?;
    constructor(from: FromKeyCodeEvent & {
        key_code: FromAndToKeyCode;
    });
    /** Set single tap which is from key by default; null to disable */
    singleTap(v: ToEvent | null): this;
    /** Set the delay parameter */
    delay(v: number): this;
    build(context?: BuildContext): BasicManipulator[];
}

export declare type DoubleTapParam = FromAndToKeyCode | KeyAlias | NumberKeyValue;

export declare function duoLayer(key1: LayerKeyParam, key2: LayerKeyParam, varName?: string, onValue?: ToVariable['value'], offValue?: ToVariable['value']): DuoLayerRuleBuilder;

declare class DuoLayerRuleBuilder extends BasicRuleBuilder {
    private readonly key1;
    private readonly key2;
    private readonly onValue;
    private readonly offValue;
    private readonly varName;
    private readonly layerCondition;
    private readonly simultaneousOptions;
    private simultaneousThreshold?;
    private layerNotification?;
    private ifActivated;
    private ifDeactivated;
    private leaderModeOptions?;
    private delayed;
    constructor(key1: LayerKeyParam, key2: LayerKeyParam, varName?: string, onValue?: ToVariable['value'], offValue?: ToVariable['value']);
    threshold(v: number): this;
    options(v: SimultaneousOptions): this;
    /** Set the notification when the layer is active. */
    notification(v?: boolean | string): this;
    /** The ToEvents to trigger when the layer is activated */
    toIfActivated(event: ToEvent): this;
    /** The ToEvents to trigger when the layer is deactivated */
    toIfDeactivated(event: ToEvent): this;
    /** Set leader mode. Default escape keys: ['escape', 'caps_lock']. */
    leaderMode(v?: boolean | LeaderModeOptions): this;
    /** Set delay mode (and delay_milliseconds). */
    delay(v?: boolean | number): this;
    build(context?: BuildContext): Rule;
}

export declare type EventChangedCondition = Extract<Condition, {
    type: 'variable_if' | 'variable_unless';
}>;

export declare type ExpressionCondition = Extract<Condition, {
    type: 'expression_if' | 'expression_unless';
}>;

export declare type FromAndToConsumerKeyCode = (typeof fromAndToConsumerKeyCodes)[number];

export declare let fromAndToConsumerKeyCodes: readonly ["rewind", "play_or_pause", "fast_forward", "mute", "volume_decrement", "volume_increment", "al_terminal_lock_or_screensaver", "eject", "scan_previous_track", "scan_next_track", "al_word_processor", "al_text_editor", "al_spreadsheet", "al_presentation_app", "al_email_reader", "al_calculator", "al_local_machine_browser", "al_internet_browser", "al_dictionary", "fastforward"];

export declare type FromAndToKeyCode = ModifierKeyCode | ControlOrSymbolKeyCode | ArrowKeyCode | LetterKeyCode | NumberKeyCode | FunctionKeyCode | KeypadKeyCode | PcKeyboardKeyCode | InternationalKeyCode | JapaneseKeyCode | OtherKeyCode;

export declare type FromAnyKeyEvent = Extract<FromEvent, {
    any: 'key_code' | 'consumer_key_code' | 'pointing_button';
}>;

export declare type FromConsumerKeyCode = FromAndToConsumerKeyCode | FromOnlyConsumerKeyCode;

export declare type FromConsumerKeyCodeEvent = Extract<FromEvent, {
    consumer_key_code: string | number;
}>;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/ */
export declare type FromEvent = (FromKeyType | {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/simultaneous/ */
    simultaneous: FromKeyType[];
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/simultaneous-options/ */
    simultaneous_options?: SimultaneousOptions;
}) & {
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/modifiers/ */
    modifiers?: FromModifiers;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/integer-value/ */
    integer_value?: number;
};

export declare type FromKeyCode = FromAndToKeyCode | FromOnlyKeyCode;

export declare type FromKeyCodeEvent = Extract<FromEvent, {
    key_code: FromKeyCode | number;
}>;

export declare type FromKeyParam = FromKeyCode | KeyAlias | NumberKeyValue | SideModifierAlias;

export declare type FromKeyType = {
    key_code: FromKeyCode | number;
} | {
    consumer_key_code: FromConsumerKeyCode | number;
} | {
    pointing_button: PointingButton | number;
} | {
    any: 'key_code' | 'consumer_key_code' | 'pointing_button';
};

declare type FromModifierOverloadParam = FromModifierParam | '' | null | FromOptionalModifierParam;

export declare type FromModifierParam = ModifierParam | 'any';

export declare type FromModifiers = {
    mandatory?: Modifier[] | ['any'];
    optional?: Modifier[] | ['any'];
};

export declare type FromOnlyConsumerKeyCode = (typeof fromOnlyConsumerKeyCodes)[number];

export declare let fromOnlyConsumerKeyCodes: readonly ["menu", "stop", "microphone", "selection", "bass_boost", "loudness", "bass_increment", "bass_decrement", "al_graphics_editor", "al_database_app", "al_newsreader", "al_voicemail", "al_contacts_or_address_book", "al_Calendar_Or_Schedule", "al_task_or_project_manager", "al_log_or_journal_or_timecard", "al_checkbook_or_finance", "al_a_or_v_capture_or_playback", "al_lan_or_wan_browser", "al_remote_networking_or_isp_connect", "al_network_conference", "al_network_chat", "al_telephony_or_dialer", "al_logon", "al_logoff", "al_logon_or_logoff", "al_control_panel", "al_command_line_processor_or_run", "al_process_or_task_manager", "al_select_task_or_application", "al_next_task_or_application", "al_previous_task_or_application", "al_preemptive_halt_task_or_application", "al_integrated_help_center", "al_documents", "al_thesaurus", "al_desktop", "al_spell_check", "al_grammer_check", "al_wireless_status", "al_keyboard_layout", "al_virus_protection", "al_encryption", "al_screen_saver", "al_alarms", "al_clock", "al_file_browser", "al_power_status", "al_image_browser", "al_audio_browser", "al_movie_browser", "al_digital_rights_manager", "al_digital_wallet", "al_instant_messaging", "al_oem_feature_browser", "al_oem_help", "al_online_community", "al_entertainment_content_browser", "al_online_shopping_browswer", "al_smart_card_information_or_help", "al_market_monitor_or_finance_browser", "al_customized_corporate_news_browser", "al_online_activity_browswer", "al_research_or_search_browswer", "al_audio_player", "al_message_status", "al_contact_sync", "al_navigation", "al_contextaware_desktop_assistant", "ac_home", "ac_back", "ac_forward", "ac_refresh", "ac_bookmarks", "ac_search", "ac_zoom_out", "ac_zoom_in", "menu_pick", "menu_up", "menu_down", "menu_left", "menu_right", "menu_escape", "menu_value_increase", "menu_value_decrease", "data_on_screen", "closed_caption", "closed_caption_select", "vcr_or_tv", "broadcast_mode", "snapshot", "still", "picture_in_picture_toggle", "picture_in_picture_swap", "red_menu_button", "green_menu_button", "blue_menu_button", "yellow_menu_button", "aspect", "three_dimensional_mode_select"];

export declare type FromOnlyKeyCode = (typeof fromOnlyKeyCodes)[number];

export declare let fromOnlyKeyCodes: readonly ["f21", "f22", "f23", "f24", "execute", "menu", "select", "stop", "again", "undo", "cut", "copy", "paste", "find", "international2", "international4", "international5", "international6", "international7", "international8", "international9", "lang3", "lang4", "lang5", "lang6", "lang7", "lang8", "lang9", "japanese_pc_nfer", "japanese_pc_xfer", "japanese_pc_katakana", "keypad_equal_sign_as400", "locking_caps_lock", "locking_num_lock", "locking_scroll_lock", "alternate_erase", "sys_req_or_attention", "cancel", "clear", "prior", "return", "separator", "out", "oper", "clear_or_again", "cr_sel_or_props", "ex_sel"];

declare type FromOptionalModifierParam = OptionalAnyAlias | {
    optional: FromModifierParam;
} | OptionalModifierAlias;

export declare type FromPointingButtonEvent = Extract<FromEvent, {
    pointing_button: string | number;
}>;

export declare type FromSimultaneousEvent = Extract<FromEvent, {
    simultaneous: FromKeyType[];
}>;

export declare type FrontmostApplicationCondition = Extract<Condition, {
    type: 'frontmost_application_if' | 'frontmost_application_unless';
}>;

export declare type FunctionKeyCode = (typeof functionKeyCodes)[number];

export declare let functionKeyCodes: readonly ["f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20"];

export declare function getKeyWithAlias<T extends KeyCode = KeyCode>(key: KeyCode | KeyAlias | NumberKeyValue | SideModifierAlias, excludeKeys?: readonly KeyCode[], excludeLabel?: string): T;

export declare function hyperLayer(key: LayerKeyParam | LayerKeyParam[], varName?: string, onValue?: ToVariable['value'], offValue?: ToVariable['value']): LayerRuleBuilder;

export declare function ifApp(bundleId: string | RegExp | Array<string | RegExp>, description?: string): ConditionBuilder;

export declare function ifApp(app: {
    file_paths?: Array<string | RegExp>;
    bundle_identifiers?: Array<string | RegExp>;
    description?: string;
}): ConditionBuilder;

export declare function ifDevice(identifier: DeviceIdentifier | DeviceIdentifier[], description?: string): ConditionBuilder;

export declare function ifDeviceExists(identifier: DeviceIdentifier | DeviceIdentifier[], description?: string): ConditionBuilder;

export declare function ifEventChanged(value?: boolean, description?: string): ConditionBuilder;

export declare function ifExpression(expression: string, description?: string): ConditionBuilder;

export declare function ifInputSource(inputSource: InputSource | InputSource[], description?: string): ConditionBuilder;

export declare function ifKeyboardType(keyboardType: KeyboardType | KeyboardType[], description?: string): ConditionBuilder;

export declare function ifVar(name: string, value?: ToVariable['value'], description?: string): ConditionBuilder;

/**
 * Imports from a JSON file.
 *
 * @param filePath - The path to the JSON file to import.
 */
export declare function importJson(filePath: string): RuleBuilder;

/**
 * Import from karabiner config profile
 *
 * @param name        The profile name in the config JSON
 * @param configFile  The config JSON file path. Default ~/.config/karabiner/karabiner.json
 */
export declare function importProfile(name: string, configFile?: string): RuleBuilder;

export declare type InputSource = {
    language?: string;
    input_source_id?: string;
    input_mode_id?: string;
};

export declare type InputSourceCondition = Extract<Condition, {
    type: 'keyboard_type_if' | 'keyboard_type_unless';
}>;

export declare type InternationalKeyCode = (typeof internationalKeyCodes)[number];

export declare let internationalKeyCodes: readonly ["international1", "international3", "lang1", "lang2"];

export declare function isConditionBuilder(src: Condition | ConditionBuilder): src is ConditionBuilder;

export declare function isSideMultiModifierAlias(src: string): src is SideMultiModifierAlias;

export declare type JapaneseKeyCode = (typeof japaneseKeyCodes)[number];

export declare let japaneseKeyCodes: readonly ["japanese_eisuu", "japanese_kana"];

export declare type KarabinerConfig = {
    global?: {
        check_for_updates_on_startup?: boolean;
        show_in_menu_bar?: boolean;
        show_profile_name_in_menu_bar?: boolean;
    };
    profiles: [KarabinerProfile];
};

export declare type KarabinerProfile = {
    name: string;
    selected: boolean;
    complex_modifications: ComplexModifications;
    simple_modifications?: SimpleManipulator[];
};

export declare type KeyAlias = ArrowKeyAlias | ControlOrSymbolKeyAlias | '⇪';

export declare type KeyboardType = 'ansi' | 'iso' | 'jis';

export declare type KeyboardTypeCondition = Extract<Condition, {
    type: 'device_if' | 'device_unless' | 'device_exists_if' | 'device_exists_unless';
}>;

export declare type KeyCode = FromAndToKeyCode | FromOnlyKeyCode | ToOnlyKeyCode;

export declare type KeypadKeyCode = (typeof keypadKeyCodes)[number];

export declare let keypadKeyCodes: readonly ["keypad_num_lock", "keypad_slash", "keypad_asterisk", "keypad_hyphen", "keypad_plus", "keypad_enter", "keypad_1", "keypad_2", "keypad_3", "keypad_4", "keypad_5", "keypad_6", "keypad_7", "keypad_8", "keypad_9", "keypad_0", "keypad_period", "keypad_equal_sign", "keypad_comma"];

/** @see https://github.com/yqrashawn/GokuRakuJoudo/blob/master/tutorial.md#advance3 */
export declare function layer(key: LayerKeyParam | LayerKeyParam[], varName?: string, onValue?: ToVariable['value'], offValue?: ToVariable['value']): LayerRuleBuilder;

export declare type LayerKeyCode = Exclude<FromKeyCode, FromOnlyKeyCode | StickyModifierKeyCode>;

export declare type LayerKeyParam = Exclude<FromKeyParam, FromOnlyKeyCode | StickyModifierKeyCode | ModifierKeyAlias | SideModifierAlias> | '⇪';

declare class LayerRuleBuilder extends BasicRuleBuilder {
    private readonly onValue;
    private readonly offValue;
    private readonly keys;
    private readonly varName;
    private readonly layerCondition;
    private layerKeyManipulator?;
    private replaceLayerKeyToIfAlone;
    private layerModifiers?;
    private layerNotification?;
    private leaderModeOptions?;
    private delayed;
    constructor(key: LayerKeyParam | LayerKeyParam[], varName?: string, onValue?: ToVariable['value'], offValue?: ToVariable['value']);
    /** Set the layer modifiers. */
    modifiers(mandatoryModifiers?: FromModifierOverloadParam, optionalModifiers?: FromModifierParam): this;
    /** Set the layer modifiers to { optional: [...]} */
    modifiers(modifiers: FromOptionalModifierParam): this;
    /** Config the layer key. */
    configKey(config: (manipulator: Omit<BasicManipulatorBuilder, 'description' | 'condition' | 'parameters' | 'build'>) => void, replaceToIfAlone?: boolean): this;
    /** Set the notification when the layer is active. */
    notification(v?: boolean | string): this;
    /** Set leader mode. Default escape keys: ['escape', 'caps_lock']. */
    leaderMode(v?: boolean | LeaderModeOptions): this;
    /** Set delay mode (and delay_milliseconds). */
    delay(v?: boolean | number): this;
    build(context?: BuildContext): Rule;
    private addModifierAnyToManipulator;
}

declare type LeaderModeOptions = {
    /** Default ['escape', 'caps_lock']. */
    escape?: FromKeyParam | FromEvent | Array<FromKeyParam | FromEvent>;
    /** Keep layer on until one of the `escape` keys pressed. */
    sticky?: boolean;
};

export declare type LeftModifierFlag = 'left' | 'l' | '<' | '‹';

export declare type LetterKeyCode = (typeof letterKeyCodes)[number];

export declare let letterKeyCodes: readonly ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/ */
export declare type Manipulator = BasicManipulator | MouseMotionToScrollManipulator;

export declare interface ManipulatorBuilder {
    build(context?: BuildContext): Manipulator[];
}

export declare type ManipulatorMap = Partial<Record<string | number, ToEvent | ToEvent[]>>;

/** Start a manipulator with a FromEvent */
export declare function map(from: FromEvent): BasicManipulatorBuilder;

/** Start a manipulator with a from.key_code and modifiers */
export declare function map(key: FromKeyParam, mandatoryModifiers?: FromModifierParam | '' | null, optionalModifiers?: FromModifierParam): BasicManipulatorBuilder;

/** Start a manipulator with a from.key_code and optional modifiers */
export declare function map(key: FromKeyParam, modifiers: FromOptionalModifierParam): BasicManipulatorBuilder;

/** Start a manipulator with from.consumer_key_code and modifiers */
export declare function mapConsumerKey(code: FromConsumerKeyCode, mandatoryModifiers?: FromModifierOverloadParam, optionalModifiers?: FromModifierParam): BasicManipulatorBuilder;

/** Start a manipulator for double-tapping a key with modifiers */
export declare function mapDoubleTap(key: DoubleTapParam, mandatoryModifiers: FromModifierParam | '' | null, optionalModifiers?: FromModifierParam, delay?: number): DoubleTapManipulatorBuilder;

/** Start a manipulator for double-tapping a key with modifiers */
export declare function mapDoubleTap(key: DoubleTapParam, modifiers: FromModifierParam | FromOptionalModifierParam, delay?: number): DoubleTapManipulatorBuilder;

/** Start a manipulator for double-tapping a key */
export declare function mapDoubleTap(key: DoubleTapParam, delay?: number): DoubleTapManipulatorBuilder;

/**
 * Start a manipulator with from.pointing_button and modifiers
 *
 * **Caution**
 * Be careful using "pointing_button": "button1" and "any": "pointing_button".
 * You may lose the left click button and system will be unusable.
 */
export declare function mapPointingButton(button: PointingButton, mandatoryModifiers?: FromModifierOverloadParam, optionalModifiers?: FromModifierParam): BasicManipulatorBuilder;

/** Start a manipulator with from.simultaneous */
export declare function mapSimultaneous(keys: Array<FromKeyParam | FromKeyType>, options?: SimultaneousOptions, threshold?: number): SimultaneousManipulatorBuilder;

export declare type ModificationParameters = ComplexModificationsParameters & Partial<typeof defaultDoubleTapParameters> & Partial<typeof defaultLayerParameters> & Partial<typeof defaultSimlayerParameters> & Partial<typeof defaultDuoLayerParameters>;

export declare type Modifier = ModifierKeyCode | 'command' | 'control' | 'option' | 'shift';

export declare type ModifierKeyAlias = keyof typeof modifierKeyAliases;

export declare let modifierKeyAliases: {
    readonly '\u2318': "command";
    readonly '\u2325': "option";
    readonly '\u2303': "control";
    readonly '\u21E7': "shift";
    readonly '\u21EA': "caps_lock";
};

export declare type ModifierKeyCode = (typeof modifierKeyCodes)[number];

export declare let modifierKeyCodes: readonly ["left_control", "left_shift", "left_option", "left_command", "right_control", "right_shift", "right_option", "right_command", "fn", "caps_lock"];

export declare function modifierLayer(modifiers: ModifierParam, key: LayerKeyParam | LayerKeyParam[], varName?: string, onValue?: ToVariable['value'], offValue?: ToVariable['value']): LayerRuleBuilder;

export declare type ModifierParam = Modifier | ModifierKeyAlias | Array<Modifier | ModifierKeyAlias> | MultiModifierAlias | {
    left?: ModifierParam;
    right?: ModifierParam;
} | {
    l?: ModifierParam;
    r?: ModifierParam;
} | SideMultiModifierAlias | SideMultiModifierAlias[];

export declare function mouseMotionToScroll(): MouseMotionToScrollManipulatorBuilder;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/other-types/mouse-motion-to-scroll/ */
export declare type MouseMotionToScrollManipulator = {
    type: 'mouse_motion_to_scroll';
    from?: {
        modifiers?: FromModifiers;
    };
    conditions?: BasicManipulator['conditions'];
    options?: MouseMotionToScrollOptions;
};

declare class MouseMotionToScrollManipulatorBuilder implements ManipulatorBuilder {
    private readonly manipulator;
    modifiers(mandatoryModifiers?: FromModifierOverloadParam, optionalModifiers?: FromModifierParam): this;
    modifiers(modifiers: FromOptionalModifierParam): this;
    condition(...v: Array<Condition | ConditionBuilder>): this;
    options(v: MouseMotionToScrollOptions): this;
    build(_?: BuildContext): Manipulator[];
}

export declare type MouseMotionToScrollOptions = {
    momentum_scroll_enabled?: boolean;
    speed_multiplier?: number;
};

export declare type MouseMotionToScrollParameters = {
    'mouse_motion_to_scroll.speed'?: number;
};

export declare type MultiModifierAlias = keyof typeof multiModifierAliases;

export declare let multiModifierAliases: {
    readonly Meh: ["option", "control", "shift"];
    readonly Hyper: ["command", "option", "control", "shift"];
    readonly SuperHyper: ["command", "option", "control", "shift", "fn"];
    readonly '\u2318\u21E7': ["command", "shift"];
    readonly '\u2325\u21E7': ["option", "shift"];
    readonly '\u2303\u21E7': ["control", "shift"];
    readonly '\u2318\u2325': ["command", "option"];
    readonly '\u2318\u2303': ["command", "control"];
    readonly '\u2325\u2303': ["option", "control"];
    readonly '\u2318\u2325\u2303': ["command", "option", "control"];
    readonly '\u2318\u2325\u21E7': ["command", "option", "shift"];
    readonly '\u2318\u2303\u21E7': ["command", "control", "shift"];
    readonly '\u2325\u2303\u21E7': ["option", "control", "shift"];
    readonly '\u2318\u2325\u2303\u21E7': ["command", "option", "control", "shift"];
};

export declare type NamedMultiModifierAlias = keyof typeof namedMultiModifierAliases;

export declare let namedMultiModifierAliases: {
    readonly Meh: ["option", "control", "shift"];
    readonly Hyper: ["command", "option", "control", "shift"];
    readonly SuperHyper: ["command", "option", "control", "shift", "fn"];
};

export declare type NumberKeyCode = (typeof numberKeyCodes)[number];

export declare let numberKeyCodes: readonly ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"];

export declare type NumberKeyValue = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

declare type OptionalAnyAlias = (typeof optionalAnyAliases)[number];

declare let optionalAnyAliases: readonly ["optionalAny", "?any", "??"];

declare type OptionalModifierAlias = `?${ModifierKeyAlias | Exclude<MultiModifierAlias, NamedMultiModifierAlias> | SideMultiModifierAlias}`;

export declare type OtherKeyCode = (typeof otherKeyCodes)[number];

export declare let otherKeyCodes: readonly ["volume_down", "volume_up", "mute", "volume_decrement", "volume_increment"];

export declare function parseFromModifierParams(mandatoryParam?: FromModifierParam | '' | null, optionalParam?: FromModifierParam): FromModifiers | undefined;

export declare function parseModifierParam(src?: ModifierParam): Modifier[] | undefined;

export declare function parseSideMultiModifierAlias(src: SideMultiModifierAlias): Modifier[] | undefined;

export declare type PcKeyboardKeyCode = (typeof pcKeyboardKeyCodes)[number];

export declare let pcKeyboardKeyCodes: readonly ["print_screen", "scroll_lock", "pause", "insert", "application", "help", "power"];

export declare type PointingButton = (typeof pointingButtons)[number];

export declare let pointingButtons: readonly ["button1", "button2", "button3", "button4", "button5", "button6", "button7", "button8", "button9", "button10", "button11", "button12", "button13", "button14", "button15", "button16", "button17", "button18", "button19", "button20", "button21", "button22", "button23", "button24", "button25", "button26", "button27", "button28", "button29", "button30", "button31", "button32"];

export declare type RightModifierFlag = 'right' | 'r' | '>' | '›';

export declare type Rule = {
    description: string;
    manipulators: Manipulator[];
};

export declare function rule(description: string, ...conditions: Array<Condition | ConditionBuilder>): BasicRuleBuilder;

export declare interface RuleBuilder {
    build(context?: BuildContext): Rule;
}

export declare type SideModifierAlias = `${SideModifierFlag}${Exclude<ModifierKeyAlias, '⇪'>}`;

export declare type SideModifierFlag = LeftModifierFlag | RightModifierFlag;

export declare type SideMultiModifierAlias = `${SideModifierFlag}${Exclude<ModifierKeyAlias, '⇪'> | Exclude<MultiModifierAlias, NamedMultiModifierAlias>}`;

/** @see https://github.com/yqrashawn/GokuRakuJoudo/blob/master/tutorial.md#advance3 */
export declare function simlayer(key: LayerKeyParam | LayerKeyParam[], varName?: string, threshold?: number, onValue?: ToVariable['value'], offValue?: ToVariable['value']): SimlayerRuleBuilder;

declare class SimlayerRuleBuilder extends BasicRuleBuilder {
    private readonly threshold?;
    private readonly onValue;
    private readonly offValue;
    private readonly keys;
    private readonly varName;
    private readonly layerCondition;
    private readonly sharedLayerKeys;
    private readonly simultaneousOptions;
    private layerModifiers?;
    private ifActivated;
    private ifDeactivated;
    constructor(key: LayerKeyParam | LayerKeyParam[], varName?: string, threshold?: number | undefined, onValue?: ToVariable['value'], offValue?: ToVariable['value']);
    /** Set the simlayer modifiers. Default optionalAny. Set to null to remove. */
    modifiers(mandatoryModifiers?: FromModifierOverloadParam, optionalModifiers?: FromModifierParam): this;
    /** Set the simlayer modifiers to { optional: [...]} (default optionalAny) */
    modifiers(modifiers: FromOptionalModifierParam): this;
    /** Set simultaneous_options on the simlayer toggle manipulator */
    options(v: Partial<SimultaneousOptions>): this;
    /** Enable layer with the same variable and manipulators with this simlayer */
    enableLayer(...key: LayerKeyParam[]): this;
    /** The ToEvents to trigger when the layer is activated */
    toIfActivated(event: ToEvent): this;
    /** The ToEvents to trigger when the layer is deactivated */
    toIfDeactivated(event: ToEvent): this;
    build(context?: BuildContext): Rule;
}

export declare type SimpleManipulator = Pick<BasicManipulator, 'from' | 'to'>;

/**
 * Builds and verifies the given manipulators are "simple" and returns them as SimpleManipulators,
 * for a profile's `simple_modifications`.
 *
 * Throws if any aren't "simple" (i.e. "basic" type with only `to` & `from`).
 */
export declare function simpleModifications(manipulatorSources: Array<Manipulator | ManipulatorBuilder | ManipulatorMap>): SimpleManipulator[];

declare class SimultaneousManipulatorBuilder extends BasicManipulatorBuilder {
    constructor(from: FromEvent);
    /** Set the from.modifiers */
    modifiers(mandatoryModifiers?: FromModifierOverloadParam, optionalModifiers?: FromModifierParam): this;
    /** Set the from.modifiers */
    modifiers(modifiers: FromOptionalModifierParam): this;
}

export declare type SimultaneousOptions = {
    detect_key_down_uninterruptedly?: boolean;
    key_down_order?: 'insensitive' | 'strict' | 'strict_inverse';
    key_up_order?: 'insensitive' | 'strict' | 'strict_inverse';
    key_up_when?: 'any' | 'all';
    to_after_key_up?: ToEvent[];
};

export declare type StickyModifierKeyCode = (typeof stickyModifierKeyCodes)[number];

export declare let stickyModifierKeyCodes: readonly ["left_control", "left_shift", "left_option", "left_command", "right_control", "right_shift", "right_option", "right_command", "fn"];

export declare type SystemSounds = (typeof systemSounds)[number];

export declare let systemSounds: readonly ["Tink", "Submarine", "Sosumi", "Morse", "Ping", "Pop", "Purr", "Glass", "Hero", "Frog", "Funk", "Blow", "Bottle", "Basso"];

/** Create ToEvent with shell_command */
export declare function to$(shell_command: string): ToEvent;

/** Create ToEvent with shell_command `open -a {app}.app` */
export declare function toApp(app: string): ToEvent;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/software_function/cg_event_double_click/ */
declare type ToCgEventDoubleClick = {
    button: number;
};

/** Create ToEvent with software_function.cg_event_double_click */
export declare function toCgEventDoubleClick(button: number): ToEvent;

/** Create ToEvent with consumer_key_code */
export declare function toConsumerKey(code: ToConsumerKeyCode, modifiers?: ModifierParam, options?: ToEventOptions): ToEvent;

export declare type ToConsumerKeyCode = FromAndToConsumerKeyCode | ToOnlyConsumerKeyCode;

export declare type ToConsumerKeyCodeEvent = Extract<ToEvent, {
    consumer_key_code: string;
}>;

declare type ToDelayedAction = {
    to_if_invoked: ToEvent[];
    to_if_canceled: ToEvent[];
};

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/ */
export declare type ToEvent = ({
    key_code: ToKeyCode | number;
} | {
    consumer_key_code: ToConsumerKeyCode | number;
} | {
    pointing_button: PointingButton | number;
} | {
    shell_command: string;
} | {
    select_input_source: ToInputSource;
} | {
    set_variable: ToVariable;
} | {
    set_notification_message: ToNotificationMessage;
} | {
    mouse_key: ToMouseKey;
} | {
    sticky_modifier: ToStickyModifier;
} | {
    software_function: ToSoftwareFunction;
} | {
    generic_desktop: number;
} | {
    send_user_command: ToSendUserCommand;
} | {
    from_event: boolean;
}) & ToEventOptions;

export declare type ToEventOptions = {
    modifiers?: Modifier[];
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/lazy/ */
    lazy?: boolean;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/repeat/ */
    repeat?: boolean;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/halt/ */
    halt?: boolean;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/hold-down-milliseconds/ */
    hold_down_milliseconds?: number;
    /** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/to-conditions/ */
    conditions?: Condition[];
};

export declare type ToFromEvent = Extract<ToEvent, {
    from_event: boolean;
}>;

/** Create ToEvent with from_event */
export declare function toFromEvent(): ToEvent;

/** Create ToEvent with generic_desktop code */
export declare function toGenericDesktop(code: number, modifiers?: ModifierParam, options?: ToEventOptions): ToEvent;

/** Create ToEvent with key_code ⌘⌥⌃⇧ */
export declare function toHyper(options?: ToEventOptions): ToEvent;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-if-other-key-pressed/ */
export declare type ToIfOtherKeyPressed = {
    other_keys: (FromKeyType & {
        modifiers?: FromModifiers;
    })[];
    to: ToEvent[];
};

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/select-input-source/ */
export declare type ToInputSource = {
    language?: string;
    input_source_id?: string;
    input_mode_id?: string;
};

/** Create ToEvent with select_input_source */
export declare function toInputSource(inputSource: ToInputSource): ToEvent;

/** Create ToEvent with key_code */
export declare function toKey(key: ToKeyParam, modifiers?: ModifierParam, options?: ToEventOptions): ToEvent;

export declare type ToKeyCode = FromAndToKeyCode | ToOnlyKeyCode;

export declare type ToKeyCodeEvent = Extract<ToEvent, {
    key_code: ToKeyCode;
}>;

export declare type ToKeyParam = ToKeyCode | KeyAlias | NumberKeyValue | SideModifierAlias;

/** Create ToEvent with key_code ⌥⌃⇧ */
export declare function toMeh(options?: ToEventOptions): ToEvent;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/software_function/set_mouse_cursor_position/ */
export declare type ToMouseCursorPosition = {
    x: number | `${number}%`;
    y: number | `${number}%`;
    screen?: number;
    relative_to?: string;
    fallback_to?: string;
};

/** Create ToEvent with software_function.set_mouse_cursor_position */
export declare function toMouseCursorPosition(p: ToMouseCursorPosition): ToEvent;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/mouse-key/ */
export declare type ToMouseKey = {
    x?: number;
    y?: number;
    vertical_wheel?: number;
    horizontal_wheel?: number;
    speed_multiplier?: number;
};

/** Create ToEvent with mouse_key */
export declare function toMouseKey(mouse_key: ToMouseKey): ToEvent;

export declare type ToMouseKeyEvent = Extract<ToEvent, {
    mouse_key: ToMouseKey;
}>;

/** Create ToEvent with key_code vk_none (Disable this key) */
export declare function toNone(options?: ToEventOptions): ToEvent;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/set-notification-message/ */
export declare type ToNotificationMessage = {
    id: string;
    text: string;
};

/** Create ToEvent with set_notification_message */
export declare function toNotificationMessage(id: string, text: string): ToEvent;

export declare type ToOnlyConsumerKeyCode = (typeof toOnlyConsumerKeyCodes)[number];

export declare let toOnlyConsumerKeyCodes: readonly ["display_brightness_decrement", "display_brightness_increment", "dictation"];

export declare type ToOnlyKeyCode = (typeof toOnlyKeyCodes)[number];

export declare let toOnlyKeyCodes: readonly ["vk_none", "vk_consumer_brightness_down", "vk_consumer_brightness_up", "vk_mission_control", "vk_launchpad", "vk_dashboard", "vk_consumer_illumination_down", "vk_consumer_illumination_up", "vk_consumer_previous", "vk_consumer_play", "vk_consumer_next", "display_brightness_decrement", "display_brightness_increment", "rewind", "play_or_pause", "fastforward", "apple_display_brightness_decrement", "apple_display_brightness_increment", "dashboard", "launchpad", "mission_control", "apple_top_case_display_brightness_decrement", "apple_top_case_display_brightness_increment", "illumination_decrement", "illumination_increment"];

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/software_function/open_application/ */
export declare type ToOpenApplication = {
    bundle_identifier: string;
} | {
    file_path: string;
} | {
    frontmost_application_history_index: number;
    frontmost_application_history_exclusion_bundle_identifiers?: string[];
    frontmost_application_history_exclusion_file_paths?: string[];
};

/** Create ToEvent with shell_command to paste {text} */
export declare function toPaste(text: string): ToEvent;

/** Play a system sound from /System/Library/Sounds/ */
export declare function toPlaySound(systemSound: SystemSounds): ToEvent;

/** Play a sound file with afplay. */
export declare function toPlaySound(soundFile: string): ToEvent;

/** Create ToEvent with pointing_button */
export declare function toPointingButton(button: PointingButton, modifiers?: ModifierParam, options?: ToEventOptions): ToEvent;

export declare type ToPointingButtonEvent = Extract<ToEvent, {
    pointing_button: string;
}>;

/** Create ToEvent with set_notification_message text:'' */
export declare function toRemoveNotificationMessage(id: string): ToEvent;

export declare type ToSelectInputSourceEvent = Extract<ToEvent, {
    select_input_source: ToInputSource;
}>;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/send-user-command/ */
export declare type ToSendUserCommand = {
    endpoint?: string;
    payload: unknown;
};

/** Create ToEvent with send_user_command */
export declare function toSendUserCommand(payload: unknown, endpoint?: string): ToEvent;

export declare type ToSendUserCommandEvent = Extract<ToEvent, {
    send_user_command: ToSendUserCommand;
}>;

export declare type ToSetNotificationMessageEvent = Extract<ToEvent, {
    set_notification_message: ToNotificationMessage;
}>;

/** Create ToEvent with set_variable */
export declare function toSetVar(name: string, value?: ToVariable['value'], key_up_value?: ToVariable['key_up_value'], type?: ToVariable['type']): ToEvent;

/** Create ToEvent with set_variable using expressions */
export declare function toSetVarExpression(name: string, options: {
    expression: string;
    key_up_expression?: string;
}): ToEvent;

export declare type ToSetVariableEvent = Extract<ToEvent, {
    set_variable: ToVariable;
}>;

export declare type ToShellCommandEvent = Extract<ToEvent, {
    shell_command: string;
}>;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/software_function/iokit_power_management_sleep_system/ */
export declare type ToSleepSystem = {
    delay_milliseconds?: number;
};

/** Create ToEvent with software_function.iokit_power_management_sleep_system */
export declare function toSleepSystem(delay?: number): ToEvent;

export declare type ToSoftwareFunction = {
    cg_event_double_click: ToCgEventDoubleClick;
} | {
    set_mouse_cursor_position: ToMouseCursorPosition;
} | {
    iokit_power_management_sleep_system: ToSleepSystem;
} | {
    open_application: ToOpenApplication;
};

export declare type ToSoftwareFunctionEvent = Extract<ToEvent, {
    software_function: ToSoftwareFunction;
}>;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/sticky-modifier/ */
export declare type ToStickyModifier = Partial<Record<StickyModifierKeyCode, 'on' | 'off' | 'toggle'>>;

/** Create ToEvent with sticky_modifier */
export declare function toStickyModifier(key: StickyModifierKeyCode, value?: 'on' | 'off' | 'toggle'): ToEvent;

export declare type ToStickyModifierEvent = Extract<ToEvent, {
    sticky_modifier: ToStickyModifier;
}>;

/** Create ToEvent with key_code ⌘⌥⌃⇧fn */
export declare function toSuperHyper(options?: ToEventOptions): ToEvent;

/** Create an array of ToEvent to type a string of keys */
export declare function toTypeSequence(src: string, map?: Record<string, ToEvent>): ToEvent[];

/** Create ToEvent with set_variable: { type: 'unset' } */
export declare function toUnsetVar(name: string): ToEvent;

/** @see https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to/set-variable/ */
export declare type ToVariable = {
    name: string;
    value?: number | boolean | string;
    key_up_value?: number | boolean | string;
    expression?: string;
    key_up_expression?: string;
    type?: 'set' | 'unset';
};

export declare type VariableCondition = Extract<Condition, {
    type: 'input_source_if' | 'input_source_unless';
}>;

/**
 * A higher-order function to add condition to a group of manipulators
 * Note: The `Manipulator[]` return type is deprecated and will be removed in v2.
 *       Please use the ManipulatorBuilder return type.
 *
 * @example
 * withCondition(ifVar('v1'), ifVar('v2'))([
 *  //...
 * ])
 */
export declare function withCondition(...conditions: Array<Condition | ConditionBuilder>): (manipulators: ManipulatorMap | Array<Manipulator | ManipulatorBuilder | ManipulatorMap>) => Manipulator[] & ManipulatorBuilder;

/**
 *  A higher-order function to map an array of keys.
 *
 *  @example
 *    withMapper([1, 2, 3])(
 *      (key) => map(key).to(key, '⌘⌥')
 *    )
 */
export declare function withMapper<const T>(src: readonly T[]): (mapper: (key: T, index: number) => Manipulator | ManipulatorBuilder) => ManipulatorBuilder;

/**
 *  A higher-order function to map a group of key-value pairs.
 *
 *  @example
 *    withMapper({1: 'a', 2: 'b'})(
 *      (k, v) => map(k).to(v)
 *    )
 */
export declare function withMapper<const K extends string | number, const V>(src: Partial<Record<K, V>>): (mapper: (key: K, value: V) => Manipulator | ManipulatorBuilder) => ManipulatorBuilder;

/**
 * A higher-order function to add modifiers to a group of manipulators
 *
 * @example
 *   withModifier('⌘⌥')([
 *     map(1).to(2), // ⌘⌥1 => 2
 *     map(3).to(4)  // ⌘⌥3 => 4
 *   ])
 */
export declare function withModifier(mandatoryModifiers: FromModifierParam, optionalModifiers?: FromModifierParam): (manipulators: ManipulatorMap | Array<Manipulator | ManipulatorBuilder | ManipulatorMap>) => ManipulatorBuilder;

/**
 * A higher-order function to add optional modifiers to a group of manipulators
 *
 * @example
 *   withModifier('optionalAny')([
 *     map(1).to(2), // 1+{optional:['any']} => 2+{}
 *     map(3).to(4)  // 3+{optional:['any']} => 4+{}
 *   ])
 */
export declare function withModifier(modifiers: FromOptionalModifierParam): (manipulators: ManipulatorMap | Array<Manipulator | ManipulatorBuilder | ManipulatorMap>) => ManipulatorBuilder;

declare interface WriteTarget {
    name: string;
    dryRun?: boolean;
    karabinerJsonPath?: string;
}

/** Write global settings of ~/.config/karabiner/karabiner.json */
export declare function writeToGlobal(global: KarabinerConfig['global'], karabinerJsonPath?: string): void;

/**
 * Write complex_modifications rules to a profile inside ~/.config/karabiner/karabiner.json
 *
 * @param writeTarget The profile name or a WriteTarget describing the profile and where to write the output.
 *                    Use '--dry-run' to print the config json into console.
 * @param rules       The complex_modifications rules
 * @param parameters  Extra complex_modifications parameters
 * @param extras      Optional extras. If simple_modifications is given, verifies the given
 *                    manipulators are "simple" and overwrites the profile's simple_modifications.
 *
 * @see https://karabiner-elements.pqrs.org/docs/json/root-data-structure/
 */
export declare function writeToProfile(writeTarget: '--dry-run' | string | WriteTarget, rules: Array<Rule | RuleBuilder>, parameters?: ModificationParameters, extras?: {
    simple_modifications?: Array<Manipulator | ManipulatorBuilder | ManipulatorMap>;
}): void;

export { }