type GamepadButtonDurationEntry derive(
@moonbitlang/core/debug.Debug
Debug)

type GamepadButtonKey derive(
@moonbitlang/core/debug.Debug
Debug)

type GamepadDurationEntry derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct GamepadInputState {
  prev_gamepad_ids : Array[Int]
  gamepad_ids : Array[Int]
  just_connected_gamepad_ids : Array[Int]
  just_disconnected_gamepad_ids : Array[Int]
  durations : Array[GamepadDurationEntry]
  prev_pressed_buttons : Array[GamepadButtonKey]
  pressed_buttons : Array[GamepadButtonKey]
  just_pressed_buttons : Array[GamepadButtonKey]
  just_released_buttons : Array[GamepadButtonKey]
  button_durations : Array[GamepadButtonDurationEntry]
}

pub struct InputHelper {
  key_state : KeyInputState
  mouse_state : MouseButtonInputState
  touch_state : TouchInputState
}

type KeyDurationEntry derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct KeyInputState {
  prev_pressed_keys : Array[Int]
  pressed_keys : Array[Int]
  just_pressed_keys : Array[Int]
  just_released_keys : Array[Int]
  durations : Array[KeyDurationEntry]
}

type MouseButtonDurationEntry derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct MouseButtonInputState {
  prev_pressed_buttons : Array[Int]
  pressed_buttons : Array[Int]
  just_pressed_buttons : Array[Int]
  just_released_buttons : Array[Int]
  durations : Array[MouseButtonDurationEntry]
}

type TouchDurationEntry derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct TouchInputState {
  prev_touch_ids : Array[Int]
  touch_ids : Array[Int]
  just_pressed_touch_ids : Array[Int]
  just_released_touch_ids : Array[Int]
  durations : Array[TouchDurationEntry]
}

fn append_connected_gamepad_ids(state : GamepadInputState, dst : Array[Int]) -> Array[Int]

fn append_just_connected_gamepad_ids(state : GamepadInputState, dst : Array[Int]) -> Array[Int]

fn append_just_disconnected_gamepad_ids(state : GamepadInputState, dst : Array[Int]) -> Array[Int]

fn append_just_pressed_keys(state : KeyInputState, dst : Array[Int]) -> Array[Int]

fn append_just_pressed_mouse_buttons(state : MouseButtonInputState, dst : Array[Int]) -> Array[Int]

fn append_just_pressed_touch_ids(state : TouchInputState, dst : Array[Int]) -> Array[Int]

fn append_just_released_keys(state : KeyInputState, dst : Array[Int]) -> Array[Int]

fn append_just_released_mouse_buttons(state : MouseButtonInputState, dst : Array[Int]) -> Array[Int]

fn append_just_released_touch_ids(state : TouchInputState, dst : Array[Int]) -> Array[Int]

fn append_pressed_keys(state : KeyInputState, dst : Array[Int]) -> Array[Int]

fn append_pressed_mouse_buttons(state : MouseButtonInputState, dst : Array[Int]) -> Array[Int]

fn append_touch_ids(state : TouchInputState, dst : Array[Int]) -> Array[Int]

fn gamepad_button_press_duration(state : GamepadInputState, gamepad_id : Int, button_id : Int) -> Int

fn gamepad_connection_duration(state : GamepadInputState, id : Int) -> Int

fn gamepad_just_pressed_button_count(state : GamepadInputState) -> Int

fn gamepad_just_released_button_count(state : GamepadInputState) -> Int

fn gamepad_pressed_button_count(state : GamepadInputState) -> Int

fn is_any_action_just_pressed(helper : InputHelper, _input : 
@mizchi/kagura_core.InputSnapshot
InputSnapshot) -> Bool

fn is_confirm_just_pressed(helper : InputHelper) -> Bool

fn is_down_just_pressed(helper : InputHelper) -> Bool

fn is_gamepad_button_just_pressed(state : GamepadInputState, gamepad_id : Int, button_id : Int) -> Bool

fn is_gamepad_button_just_released(state : GamepadInputState, gamepad_id : Int, button_id : Int) -> Bool

fn is_gamepad_button_pressed(state : GamepadInputState, gamepad_id : Int, button_id : Int) -> Bool

fn is_gamepad_connected(state : GamepadInputState, id : Int) -> Bool

fn is_gamepad_just_connected(state : GamepadInputState, id : Int) -> Bool

fn is_gamepad_just_disconnected(state : GamepadInputState, id : Int) -> Bool

fn is_key_just_pressed(state : KeyInputState, key : Int) -> Bool

fn is_key_just_released(state : KeyInputState, key : Int) -> Bool

fn is_key_pressed(state : KeyInputState, key : Int) -> Bool

fn is_mouse_button_just_pressed(state : MouseButtonInputState, button : Int) -> Bool

fn is_mouse_button_just_released(state : MouseButtonInputState, button : Int) -> Bool

fn is_mouse_button_pressed(state : MouseButtonInputState, button : Int) -> Bool

fn is_move_down(key_state : KeyInputState) -> Bool

fn is_move_left(key_state : KeyInputState) -> Bool

fn is_move_right(key_state : KeyInputState) -> Bool

fn is_move_up(key_state : KeyInputState) -> Bool

fn is_touch_just_pressed(state : TouchInputState, id : Int) -> Bool

fn is_touch_just_released(state : TouchInputState, id : Int) -> Bool

fn is_touch_pressed(state : TouchInputState, id : Int) -> Bool

fn is_up_just_pressed(helper : InputHelper) -> Bool

let key_a : Int

let key_comma : Int

let key_d : Int

let key_down_glfw : Int

let key_down_web : Int

let key_e : Int

let key_enter_glfw : Int

let key_enter_web : Int

let key_left_glfw : Int

let key_left_web : Int

let key_o : Int

fn key_press_duration(state : KeyInputState, key : Int) -> Int

let key_right_glfw : Int

let key_right_web : Int

let key_s : Int

let key_space : Int

let key_up_glfw : Int

let key_up_web : Int

let key_w : Int

fn mouse_button_press_duration(state : MouseButtonInputState, button : Int) -> Int

fn new_gamepad_input_state() -> GamepadInputState

fn new_input_helper() -> InputHelper

fn new_key_input_state() -> KeyInputState

fn new_mouse_input_state() -> MouseButtonInputState

fn new_touch_input_state() -> TouchInputState

fn touch_press_duration(state : TouchInputState, id : Int) -> Int

fn update_gamepad_input_state(state : GamepadInputState, snapshot : 
@mizchi/kagura_core.InputSnapshot
InputSnapshot) -> Unit

fn update_input_helper(helper : InputHelper, snapshot : 
@mizchi/kagura_core.InputSnapshot
InputSnapshot) -> Unit

fn update_key_input_state(state : KeyInputState, snapshot : 
@mizchi/kagura_core.InputSnapshot
InputSnapshot) -> Unit

fn update_mouse_input_state(state : MouseButtonInputState, snapshot : 
@mizchi/kagura_core.InputSnapshot
InputSnapshot) -> Unit

fn update_touch_input_state(state : TouchInputState, snapshot : 
@mizchi/kagura_core.InputSnapshot
InputSnapshot) -> Unit