Mouse

@staticmethod
def are_buttons_swapped() -> bool:
    """Flag to indicate if the buttons are swapped (left-handed)."""
    return CSMouse.AreButtonsSwapped

@staticmethod
def click(
    point: Optional[Point] = None,
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Clicks the specified mouse button at the current location.

    :param point:The position to move to before clicking.
    :param mouse_button: The mouse button to click. Defaults to the left button, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.Click(mouse_button.value) if point is None else CSMouse.Click(point.raw_value, mouse_button.value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def double_click(
    point: Optional[Point] = None,
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Double-Clicks the specified mouse button at the current location.

    :param point:The position to move to before clicking.
    :param mouse_button: The mouse button to click. Defaults to the left button, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.DoubleClick(mouse_button.value) if point is None else CSMouse.DoubleClick(
        point.raw_value, mouse_button.value
    )
    Mouse._apply_post_wait(post_wait)

@staticmethod
def down(
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Sends a mouse down command for the specified mouse button.

    :param mouse_button: The mouse button to press, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.Down(mouse_button.value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def drag(
    starting_point: Point,
    ending_point: Optional[Point] = None,
    distance_x: Optional[int] = None,
    distance_y: Optional[int] = None,
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Drags the mouse from starting point to ending point or by distance.

    :param starting_point: Starting point of the drag
    :param ending_point: Ending point of the drag (if using point-to-point drag)
    :param distance_x: The x distance to drag, + for right, - for left
    :param distance_y: The y distance to drag, + for right, - for left
    :param mouse_button: The mouse button to use for dragging, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    if ending_point is not None:
        CSMouse.Drag(starting_point.raw_value, ending_point.raw_value, mouse_button.value)
    elif distance_x is not None and distance_y is not None:
        CSMouse.Drag(starting_point.raw_value, distance_x, distance_y, mouse_button.value)
    else:
        raise ValueError("`ending_point or (distance_x and distance_y) must be provided to drag the mouse.")
    Mouse._apply_post_wait(post_wait)

@staticmethod
def drag_horizontally(
    starting_point: Point,
    distance: int,
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Drags the mouse horizontally.

    :param starting_point: Starting point of the drag
    :param distance: The distance to drag, + for right, - for left
    :param mouse_button: The mouse button to use for dragging, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.DragHorizontally(starting_point.raw_value, distance, mouse_button.value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def drag_vertically(
    starting_point: Point,
    distance: int,
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Drags the mouse vertically.

    :param starting_point: Starting point of the drag
    :param distance: The distance to drag, + for right, - for left
    :param mouse_button: The mouse button to use for dragging, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.DragVertically(starting_point.raw_value, distance, mouse_button.value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def horizontal_scroll(lines: int, post_wait: Optional[Union[bool, float, Callable[[], None]]] = None) -> None:
    """Simulates horizontal scrolling of the mouse wheel left or right.

    :param lines: Lines to scroll horizontally
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.HorizontalScroll(lines)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def left_click(point: Optional[Point], post_wait: Optional[Union[bool, float, Callable[[], None]]] = None) -> None:
    """Performs a left click.

    :param point: The position to move before clicking.
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.LeftClick() if point is None else CSMouse.LeftClick(point.raw_value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def left_double_click(
    point: Optional[Point], post_wait: Optional[Union[bool, float, Callable[[], None]]] = None
) -> None:
    """Performs a left double click.

    :param point: The position to move before clicking.
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.LeftDoubleClick() if point is None else CSMouse.LeftDoubleClick(point.raw_value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def move_by(
    delta_x: int,
    delta_y: int,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Moves the mouse by a given delta from the current position.

    :param delta_x: The delta for the x-axis
    :param delta_y: The delta for y-axis
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.MoveBy(delta_x, delta_y)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def move_to(
    new_x: Optional[int] = None,
    new_y: Optional[int] = None,
    new_position: Optional[Point] = None,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Moves the mouse to a new position.

    :param new_x: The new position on x-axis
    :param new_y: The new position on y-axis
    :param new_position: The new position for the mouse.
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    if (new_x is not None and new_y is not None) or new_position is not None:
        CSMouse.MoveTo(new_position.raw_value) if new_position is not None else CSMouse.MoveTo(new_x, new_y)
    else:
        raise ValueError(
            "`new_x, new_y or new_position argument needs to be sent for the Mouse to move to a new position`"
        )
    Mouse._apply_post_wait(post_wait)

@staticmethod
def right_click(point: Optional[Point], post_wait: Optional[Union[bool, float, Callable[[], None]]] = None) -> None:
    """Performs a right click.

    :param point: The position to move before clicking.
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.RightClick() if point is None else CSMouse.RightClick(point.raw_value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def right_double_click(
    point: Optional[Point], post_wait: Optional[Union[bool, float, Callable[[], None]]] = None
) -> None:
    """Performs a right double click.

    :param point: The position to move before clicking.
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.RightDoubleClick() if point is None else CSMouse.RightDoubleClick(point.raw_value)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def scroll(lines: int, post_wait: Optional[Union[bool, float, Callable[[], None]]] = None) -> None:
    """Simulates scrolling of the mouse wheel up or down.

    :param lines: Lines to scroll
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.Scroll(lines)
    Mouse._apply_post_wait(post_wait)

@staticmethod
def up(
    mouse_button: MouseButton = MouseButton.Left,
    post_wait: Optional[Union[bool, float, Callable[[], None]]] = None,
) -> None:
    """Sends a mouse up command for the specified mouse button.

    :param mouse_button: The mouse button to press, defaults to MouseButton.Left
    :param post_wait: Optional wait after operation. True=100ms, float=custom seconds, callable=custom function
    """
    CSMouse.Up(mouse_button.value)
    Mouse._apply_post_wait(post_wait)