Keyboard

:none
                     | :per_row
                     | :per_key

DebounceNone
                      | DebouncePerRow
                      | DebouncePerKey

:matrix
                      | :direct

RGB
                   | RotaryEncoder
                   | VIA
                   | Joystick
                   | Mouse
                   | Sounder
                   | DebounceNone
                   | DebouncePerRow
                   | DebouncePerKey

:left
                   | :right

:standard_split
                        | :right_side_flipped_split

{
    on_release:        Integer | Array[Integer] | Proc | nil,
    on_hold:           Integer | Symbol | Proc,
    release_threshold: Integer,
    repush_threshold:  Integer
  }

{
    prev_state:  Symbol,
    pushed_at:   Integer,
    released_at: Integer,
    layers:      Hash[Symbol, layer_t]
  }

Keyboard.autoreload_off() -> void

Keyboard.autoreload_ready?() -> bool

Keyboard.new-> instance

Keyboard.reload_keymap() -> void

Keyboard.restart() -> void

Keyboard.wait_keymap() -> void

instance.action_on_release(Integer | Array[Integer] | Proc | nil mode_key) -> void

instance.add_layer(Symbol name, Array[ Symbol | Array[Symbol] ] map) -> void

instance.anchor?-> bool

instance.append(append_type feature) -> void

instance.before_report() { (Keyboard) -> void } -> void

instance.bootsel!-> void

instance.calculate_col_position(Integer col_index) -> Integer

instance.convert_composite_keys(Array[Symbol] keys) -> Array[Integer]

instance.define_composite_key(Symbol key_name, Array[Symbol] keys) -> void

instance.define_mode_key(Symbol key_name, [Symbol | Array[Symbol] | Proc | nil, Symbol | Proc | nil, Integer?, Integer?] param, ?bool from_via) -> void

instance.delete_mode_keys(Symbol layer_name) -> void

instance.entire_cols_size() -> Integer

instance.eval(String) -> void

instance.find_keycode_index(Symbol key) -> (Integer | Symbol)

instance.get_layer(Symbol | nil name, Integer num) -> ( Array[Array[Integer | Symbol | Proc]] | nil )

instance.init_direct_pins(Array[Integer] pins) -> void

instance.init_matrix_pins(Array[Array[Array[Integer] | nil]] matrix) -> void

instance.init_pins(Array[Integer] rows, Array[Integer] cols) -> void

instance.init_uart() -> void

instance.inject_switch(Integer col, Integer row) -> void

instance.invert_sft-> void

instance.key_pressed?() -> bool

instance.keys_include?(Symbol key) -> bool

instance.lock_layer(Symbol layer_name) -> void

instance.lower_layer-> void

instance.macro(String text, ?::Array[Symbol] opt) -> void

instance.mutual_uart_at_my_own_risk=(bool) -> void

instance.on_start() { (Keyboard) -> void } -> void

instance.output_report_changed() { (Integer) -> void} -> void

instance.raise_layer-> void

instance.resolve_key_alias(Symbol sym) -> Symbol

instance.ruby() -> void

instance.scan_direct!() -> void

instance.scan_matrix!() -> void

instance.send_key(*untyped) -> void

instance.set_anchor(anchor_type val) -> void

instance.set_debounce(debounce_type type) -> void

instance.set_debounce_threshold(Integer val) -> void

instance.set_scan_mode(scan_mode_type mode) -> void

instance.signal_partner(Symbol key) { (Keyboard) -> void } -> void

instance.skip_position?(Integer row_index, Integer col_index) -> bool

instance.split_style=(Symbol style) -> void

instance.start!-> void

instance.start_features-> void

instance.uart_anchor(Integer) -> Integer

instance.uart_anchor_init(Integer) -> void

instance.uart_partner() -> Integer

instance.uart_partner_init(Integer) -> void

instance.uart_partner_push8(Integer) -> void

instance.unlock_layer() -> void

instance.via=(bool val) -> void

instance.via_layer_count=(Integer count) -> void

instance.split -> bool

instance.uart_pin -> Integer

instance.default_layer -> Symbol

instance.sounder -> Sounder

instance.modifier -> Integer

instance.layer -> Symbol | nil

instance.split_style -> split_style_type

instance.cols_size -> Integer

instance.rows_size -> Integer

instance.keycodes -> Array[Integer]