### Install InputSimulator via NuGet

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Command to install the InputSimulator package into a .NET project using the NuGet Package Manager Console.

```bash
Install-Package InputSimulator
```

--------------------------------

### Simulate Mouse Button Clicks and Drag Operations

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Explains how to trigger click, double-click, and hold/release events for left, right, and X buttons. Includes a practical example for implementing a drag-and-drop operation.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Left mouse button
simulator.Mouse.LeftButtonClick();
simulator.Mouse.LeftButtonDoubleClick();
simulator.Mouse.LeftButtonDown();
simulator.Mouse.LeftButtonUp();

// Right mouse button
simulator.Mouse.RightButtonClick();
simulator.Mouse.RightButtonDoubleClick();

// X buttons
simulator.Mouse.XButtonClick(1);
simulator.Mouse.XButtonClick(2);

// Drag and drop example
simulator.Mouse
    .MoveMouseTo(10000, 10000)
    .Sleep(100)
    .LeftButtonDown()
    .Sleep(100)
    .MoveMouseTo(50000, 50000)
    .Sleep(100)
    .LeftButtonUp();
```

--------------------------------

### Simulate Mouse Wheel Scrolling

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Shows how to perform vertical and horizontal scrolling using positive and negative integer values. Includes a loop example to simulate smooth scrolling through a document.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Vertical scroll
simulator.Mouse.VerticalScroll(3);
simulator.Mouse.VerticalScroll(-3);

// Horizontal scroll
simulator.Mouse.HorizontalScroll(2);
simulator.Mouse.HorizontalScroll(-2);

// Scroll through a document
for (int i = 0; i < 10; i++)
{
    simulator.Mouse.VerticalScroll(-1);
    simulator.Mouse.Sleep(200);
}
```

--------------------------------

### VirtualKeyCode Enumeration Reference

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

A reference guide for the VirtualKeyCode enum values used to represent physical keys on a Windows keyboard.

```APIDOC
## VirtualKeyCode Reference

### Description
The `VirtualKeyCode` enumeration provides a set of constants representing keys on a Windows keyboard, used by the `IKeyboardSimulator` to trigger specific input events.

### Categories
- **Modifier Keys**: SHIFT, CONTROL, MENU (Alt), LWIN, RWIN
- **Alphanumeric**: VK_A through VK_Z, VK_0 through VK_9
- **Function Keys**: F1 through F24
- **Navigation**: TAB, RETURN, ESCAPE, SPACE, BACK, DELETE, INSERT, HOME, END, PRIOR (PgUp), NEXT (PgDn), LEFT, UP, RIGHT, DOWN
- **Toggle Keys**: CAPITAL (Caps Lock), NUMLOCK, SCROLL
- **Numpad**: NUMPAD0-9, MULTIPLY, ADD, SUBTRACT, DECIMAL, DIVIDE
- **Media/Browser**: VOLUME_UP/DOWN/MUTE, MEDIA_PLAY_PAUSE, BROWSER_BACK, BROWSER_FORWARD, etc.

### Usage Example
```csharp
// Simulate pressing the Enter key
inputSimulator.Keyboard.KeyPress(VirtualKeyCode.RETURN);

// Simulate a keyboard shortcut (Ctrl + C)
inputSimulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_C);
```
```

--------------------------------

### Determine Key State in C#

Source: https://github.com/michaelnoonan/inputsimulator/blob/master/README.md

Provides examples of how to check the current state of keyboard keys, including whether a key is currently held down or if a toggle key like Caps Lock is active. This is useful for conditional logic based on keyboard state.

```csharp
public void GetKeyStatus()
{
  // Determines if the shift key is currently down
  var isShiftKeyDown = InputSimulator.IsKeyDown(VirtualKeyCode.SHIFT);

  // Determines if the caps lock key is currently in effect (toggled on)
  var isCapsLockOn = InputSimulator.IsTogglingKeyInEffect(VirtualKeyCode.CAPITAL);
}
```

--------------------------------

### InputSimulator Class Initialization

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Demonstrates how to create an instance of the InputSimulator and access its keyboard, mouse, and input device state functionalities.

```APIDOC
## InputSimulator Class

The main entry point that provides access to keyboard and mouse simulation through its `Keyboard` and `Mouse` properties. Create an instance to begin simulating input.

### Request Example
```csharp
using WindowsInput;
using WindowsInput.Native;

// Create a new InputSimulator instance
var simulator = new InputSimulator();

// Access keyboard simulation
IKeyboardSimulator keyboard = simulator.Keyboard;

// Access mouse simulation
IMouseSimulator mouse = simulator.Mouse;

// Access device state detection
IInputDeviceStateAdaptor state = simulator.InputDeviceState;

// Check if a key is currently pressed
bool isShiftDown = simulator.InputDeviceState.IsKeyDown(VirtualKeyCode.SHIFT);
bool isCapsLockOn = simulator.InputDeviceState.IsTogglingKeyInEffect(VirtualKeyCode.CAPITAL);
```
```

--------------------------------

### Initialize InputSimulator and Access Devices

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Demonstrates how to instantiate the InputSimulator class and access its keyboard, mouse, and input device state interfaces to monitor key states.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();
IKeyboardSimulator keyboard = simulator.Keyboard;
IMouseSimulator mouse = simulator.Mouse;
IInputDeviceStateAdaptor state = simulator.InputDeviceState;

bool isShiftDown = simulator.InputDeviceState.IsKeyDown(VirtualKeyCode.SHIFT);
bool isCapsLockOn = simulator.InputDeviceState.IsTogglingKeyInEffect(VirtualKeyCode.CAPITAL);
```

--------------------------------

### Execute Fluent API Chaining for Input Operations

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Shows how to chain multiple keyboard and mouse operations using the fluent API. The simulator instance allows switching between keyboard and mouse properties to build complex automation sequences.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Chain keyboard operations
simulator.Keyboard
    .KeyPress(VirtualKeyCode.VK_H)
    .KeyPress(VirtualKeyCode.VK_I)
    .Sleep(500)
    .TextEntry(" there!")
    .ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_A)
    .ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_C);

// Chain mouse operations
simulator.Mouse
    .MoveMouseTo(10000, 10000)
    .Sleep(100)
    .LeftButtonClick()
    .Sleep(100)
    .MoveMouseTo(50000, 50000)
    .RightButtonClick();

// Switch between keyboard and mouse mid-chain
simulator.Keyboard
    .ModifiedKeyStroke(VirtualKeyCode.LWIN, VirtualKeyCode.VK_R)
    .Sleep(1000)
    .TextEntry("mspaint")
    .Sleep(1000)
    .KeyPress(VirtualKeyCode.RETURN)
    .Sleep(2000)
    .Mouse
    .MoveMouseTo(20000, 20000)
    .LeftButtonDown()
    .MoveMouseToPositionOnVirtualDesktop(40000, 40000)
    .LeftButtonUp()
    .Keyboard
    .ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_S);
```

--------------------------------

### Simulate Single Key Press in C#

Source: https://github.com/michaelnoonan/inputsimulator/blob/master/README.md

Demonstrates how to simulate a single key press, such as the spacebar, using the InputSimulator library. This is useful for triggering actions that require a specific key input.

```csharp
public void PressTheSpacebar()
{
  InputSimulator.SimulateKeyPress(VirtualKeyCode.SPACE);
}
```

--------------------------------

### Simulate Mouse Movement with InputSimulator

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Demonstrates how to move the mouse cursor using relative pixel offsets or absolute normalized coordinates (0-65535). It also shows how to perform movements across virtual desktops and chain commands with delays.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Move mouse by relative offset (pixels from current position)
simulator.Mouse.MoveMouseBy(100, 50);
simulator.Mouse.MoveMouseBy(-50, -25);

// Move mouse to absolute position on primary display
simulator.Mouse.MoveMouseTo(0, 0);
simulator.Mouse.MoveMouseTo(65535, 65535);
simulator.Mouse.MoveMouseTo(32767, 32767);

// Move mouse on virtual desktop
simulator.Mouse.MoveMouseToPositionOnVirtualDesktop(32767, 32767);

// Example: Move to corners of screen with delays
simulator.Mouse
    .MoveMouseTo(0, 0)
    .Sleep(1000)
    .MoveMouseTo(65535, 0)
    .Sleep(1000)
    .MoveMouseTo(65535, 65535)
    .Sleep(1000)
    .MoveMouseTo(0, 65535)
    .Sleep(1000)
    .MoveMouseTo(32767, 32767);
```

--------------------------------

### Simulate Key Down, Key Up, and Text Entry in C#

Source: https://github.com/michaelnoonan/inputsimulator/blob/master/README.md

Illustrates simulating individual key down and key up events to form a sequence, and alternatively, simulating text entry directly. This is useful for typing strings or performing actions that involve holding modifier keys.

```csharp
public void ShoutHello()
{
  // Simulate each key stroke
  InputSimulator.SimulateKeyDown(VirtualKeyCode.SHIFT);
  InputSimulator.SimulateKeyPress(VirtualKeyCode.VK_H);
  InputSimulator.SimulateKeyPress(VirtualKeyCode.VK_E);
  InputSimulator.SimulateKeyPress(VirtualKeyCode.VK_L);
  InputSimulator.SimulateKeyPress(VirtualKeyCode.VK_L);
  InputSimulator.SimulateKeyPress(VirtualKeyCode.VK_O);
  InputSimulator.SimulateKeyPress(VirtualKeyCode.VK_1);
  InputSimulator.SimulateKeyUp(VirtualKeyCode.SHIFT);

  // Alternatively you can simulate text entry to acheive the same end result
  InputSimulator.SimulateTextEntry("HELLO!");
}
```

--------------------------------

### Fluent API Chaining

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Enables fluent chaining of multiple keyboard and mouse operations using the InputSimulator instance.

```APIDOC
## POST /input/chain

### Description
Executes a sequence of keyboard and mouse operations using a fluent interface.

### Method
POST

### Endpoint
/input/chain

### Request Body
- **actions** (array) - Required - A list of operations to perform (e.g., KeyPress, MoveMouseTo, TextEntry).

### Request Example
{
  "actions": [
    {"type": "KeyPress", "key": "VK_H"},
    {"type": "TextEntry", "text": "Hello"},
    {"type": "Sleep", "duration": 500}
  ]
}

### Response
#### Success Response (200)
- **status** (string) - Indicates the completion status of the operation chain.

### Response Example
{
  "status": "success"
}
```

--------------------------------

### Simulate Key Hold and Release Operations

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Demonstrates how to hold modifier keys like SHIFT using KeyDown and release them with KeyUp, allowing for complex keystroke sequences.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();
simulator.Keyboard.KeyDown(VirtualKeyCode.SHIFT);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_H);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_E);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_L);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_L);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_O);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_1);
simulator.Keyboard.KeyUp(VirtualKeyCode.SHIFT);
```

--------------------------------

### Simulate Single Key Presses

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Shows how to simulate individual key presses, including special keys like Space, Enter, Tab, and function keys, using the KeyPress method.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();
simulator.Keyboard.KeyPress(VirtualKeyCode.SPACE);
simulator.Keyboard.KeyPress(VirtualKeyCode.RETURN);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_H, VirtualKeyCode.VK_E, VirtualKeyCode.VK_L, VirtualKeyCode.VK_L, VirtualKeyCode.VK_O);
simulator.Keyboard.KeyPress(VirtualKeyCode.F5);
simulator.Keyboard.KeyPress(VirtualKeyCode.TAB);
simulator.Keyboard.KeyPress(VirtualKeyCode.ESCAPE);
```

--------------------------------

### Simulate Text Entry in C#

Source: https://github.com/michaelnoonan/inputsimulator/blob/master/README.md

Demonstrates the simplest way to simulate typing a string of text. This method is convenient for entering sentences or phrases directly into an active input field.

```csharp
public void SayHello()
{
  InputSimulator.SimulateTextEntry("Say hello!");
}
```

--------------------------------

### Simulate Modified Keystrokes and Chords in C#

Source: https://github.com/michaelnoonan/inputsimulator/blob/master/README.md

Shows how to simulate modified keystrokes, such as CTRL+C, and complex key chords involving multiple modifier keys and sequential key presses. This is essential for simulating shortcuts and complex command sequences.

```csharp
public void SimulateSomeModifiedKeystrokes()
{
  // CTRL-C (effectively a copy command in many situations)
  InputSimulator.SimulateModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_C);

  // You can simulate chords with multiple modifiers
  // For example CTRL-K-C whic is simulated as
  // CTRL-down, K, C, CTRL-up
  InputSimulator.SimulateModifiedKeyStroke(VirtualKeyCode.CONTROL, new [] {VirtualKeyCode.VK_K, VirtualKeyCode.VK_C});

  // You can simulate complex chords with multiple modifiers and key presses
  // For example CTRL-ALT-SHIFT-ESC-K which is simulated as
  // CTRL-down, ALT-down, SHIFT-down, press ESC, press K, SHIFT-up, ALT-up, CTRL-up
  InputSimulator.SimulateModifiedKeyStroke(
    new[] { VirtualKeyCode.CONTROL, VirtualKeyCode.MENU, VirtualKeyCode.SHIFT },
    new[] { VirtualKeyCode.ESCAPE, VirtualKeyCode.VK_K });
}
```

--------------------------------

### Detect Keyboard and Mouse Device States

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Demonstrates how to query the current state of keyboard keys and toggle keys, as well as hardware-level mouse and keyboard button states. It uses the InputDeviceState property to determine if keys are pressed or toggled on.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Check if a key is currently down (message queue state)
bool isShiftDown = simulator.InputDeviceState.IsKeyDown(VirtualKeyCode.SHIFT);
bool isCtrlDown = simulator.InputDeviceState.IsKeyDown(VirtualKeyCode.CONTROL);
bool isAltDown = simulator.InputDeviceState.IsKeyDown(VirtualKeyCode.MENU);

// Check if a key is up
bool isSpaceUp = simulator.InputDeviceState.IsKeyUp(VirtualKeyCode.SPACE);

// Check hardware key state (interrupt-level, regardless of message pump)
bool isLeftMouseDown = simulator.InputDeviceState.IsHardwareKeyDown(VirtualKeyCode.LBUTTON);
bool isKeyboardAPressed = simulator.InputDeviceState.IsHardwareKeyDown(VirtualKeyCode.VK_A);
bool isKeyUp = simulator.InputDeviceState.IsHardwareKeyUp(VirtualKeyCode.VK_A);

// Check toggle key states
bool isCapsLockOn = simulator.InputDeviceState.IsTogglingKeyInEffect(VirtualKeyCode.CAPITAL);
bool isNumLockOn = simulator.InputDeviceState.IsTogglingKeyInEffect(VirtualKeyCode.NUMLOCK);
bool isScrollLockOn = simulator.InputDeviceState.IsTogglingKeyInEffect(VirtualKeyCode.SCROLL);

// Conditional input based on current state
if (!simulator.InputDeviceState.IsTogglingKeyInEffect(VirtualKeyCode.CAPITAL))
{
    simulator.Keyboard.KeyPress(VirtualKeyCode.CAPITAL);
}
```

--------------------------------

### KeyPress - Single Key Press

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Simulates a complete key press (key down followed by key up) for a single key or a sequence of keys. The method returns the simulator instance for chaining operations.

```APIDOC
## KeyPress - Single Key Press

Simulates a complete key press (key down followed by key up) for a single key or sequence of keys. Returns the simulator instance for method chaining.

### Request Example
```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Press the spacebar
simulator.Keyboard.KeyPress(VirtualKeyCode.SPACE);

// Press Enter key
simulator.Keyboard.KeyPress(VirtualKeyCode.RETURN);

// Press multiple keys in sequence
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_H, VirtualKeyCode.VK_E, VirtualKeyCode.VK_L, VirtualKeyCode.VK_L, VirtualKeyCode.VK_O);

// Press function keys
simulator.Keyboard.KeyPress(VirtualKeyCode.F5);  // Refresh in many applications

// Press navigation keys
simulator.Keyboard.KeyPress(VirtualKeyCode.TAB);
simulator.Keyboard.KeyPress(VirtualKeyCode.ESCAPE);
```
```

--------------------------------

### Type Text Strings with TextEntry

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Simulates typing text strings using Unicode character input, allowing for any character to be typed without relying on the current keyboard layout. This is useful for entering text into applications, including special characters and multi-line content.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Type a simple string
simulator.Keyboard.TextEntry("Hello, World!");

// Type a single character
simulator.Keyboard.TextEntry('A');

// Type special characters and Unicode
simulator.Keyboard.TextEntry("Special chars: @#$%^&*()");
simulator.Keyboard.TextEntry("Unicode: \u00e9\u00e8\u00ea"); // é è ê

// Type multi-line text
simulator.Keyboard.TextEntry("Line 1\nLine 2\nLine 3");

// Practical example: Open Notepad and type a message
simulator.Keyboard
    .ModifiedKeyStroke(VirtualKeyCode.LWIN, VirtualKeyCode.VK_R)  // Open Run dialog
    .Sleep(500)
    .TextEntry("notepad")
    .Sleep(500)
    .KeyPress(VirtualKeyCode.RETURN)  // Press Enter
    .Sleep(1000)
    .TextEntry("This text was typed automatically by Windows Input Simulator!");
```

--------------------------------

### Device State Detection

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Methods to query the current state of keyboard keys, mouse buttons, and toggle keys like Caps Lock.

```APIDOC
## GET /device/state

### Description
Queries the current state of keyboard keys, mouse buttons, and toggle keys to determine if they are pressed or active.

### Method
GET

### Endpoint
/device/state

### Parameters
#### Query Parameters
- **key** (VirtualKeyCode) - Required - The specific key or button to check.

### Response
#### Success Response (200)
- **isPressed** (boolean) - Returns true if the key/button is currently down.
- **isToggled** (boolean) - Returns true if the toggle key (e.g., Caps Lock) is active.

### Response Example
{
  "isPressed": true,
  "isToggled": false
}
```

--------------------------------

### KeyDown / KeyUp - Hold and Release Keys

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Simulates pressing a key down and releasing it separately. This is useful for holding modifier keys (like SHIFT or CTRL) while performing other actions, such as typing uppercase letters or using keyboard shortcuts.

```APIDOC
## KeyDown / KeyUp - Hold and Release Keys

Simulates pressing a key down and releasing it separately, useful for holding modifier keys while pressing other keys.

### Request Example
```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Hold SHIFT while typing to produce uppercase letters
simulator.Keyboard.KeyDown(VirtualKeyCode.SHIFT);
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_H);  // Types 'H'
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_E);  // Types 'E'
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_L);  // Types 'L'
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_L);  // Types 'L'
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_O);  // Types 'O'
simulator.Keyboard.KeyPress(VirtualKeyCode.VK_1);  // Types '!' (SHIFT+1)
simulator.Keyboard.KeyUp(VirtualKeyCode.SHIFT);

// Result: "HELLO!"
```
```

--------------------------------

### Simulate Keyboard Shortcuts with ModifiedKeyStroke

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Simulates keyboard shortcuts involving one or more modifier keys. It ensures the correct sequence of pressing and releasing modifier keys along with the main key(s). This method is useful for triggering application commands like copy, paste, save, or opening system dialogs.

```csharp
using WindowsInput;
using WindowsInput.Native;

var simulator = new InputSimulator();

// Single modifier + single key: CTRL+C (Copy)
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_C);

// Single modifier + single key: CTRL+V (Paste)
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_V);

// Single modifier + single key: CTRL+S (Save)
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_S);

// Single modifier + multiple keys: CTRL+K, C (Visual Studio comment)
// Simulates: CTRL down, K press, C press, CTRL up
simulator.Keyboard.ModifiedKeyStroke(
    VirtualKeyCode.CONTROL,
    new[] { VirtualKeyCode.VK_K, VirtualKeyCode.VK_C }
);

// Multiple modifiers + single key: CTRL+SHIFT+S (Save As)
simulator.Keyboard.ModifiedKeyStroke(
    new[] { VirtualKeyCode.CONTROL, VirtualKeyCode.SHIFT },
    VirtualKeyCode.VK_S
);

// Multiple modifiers + multiple keys: CTRL+ALT+SHIFT+ESC, K
// Simulates: CTRL down, ALT down, SHIFT down, ESC press, K press, SHIFT up, ALT up, CTRL up
simulator.Keyboard.ModifiedKeyStroke(
    new[] { VirtualKeyCode.CONTROL, VirtualKeyCode.MENU, VirtualKeyCode.SHIFT },
    new[] { VirtualKeyCode.ESCAPE, VirtualKeyCode.VK_K }
);

// Open Windows Explorer: WIN+E
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.LWIN, VirtualKeyCode.VK_E);

// Open Run dialog: WIN+R
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.LWIN, VirtualKeyCode.VK_R);

// Alt+Tab to switch windows
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.MENU, VirtualKeyCode.TAB);

// Alt+F4 to close window
simulator.Keyboard.ModifiedKeyStroke(VirtualKeyCode.MENU, VirtualKeyCode.F4);
```

--------------------------------

### Common Virtual Key Codes in C#

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

This snippet lists common virtual key codes from the WindowsInput.Native.VirtualKeyCode enum. These codes are essential for simulating keyboard input, such as pressing modifier keys, letter keys, numbers, function keys, navigation controls, and media playback keys.

```csharp
using WindowsInput.Native;

// Modifier keys
VirtualKeyCode.SHIFT      // Shift key
VirtualKeyCode.CONTROL    // Ctrl key
VirtualKeyCode.MENU       // Alt key
VirtualKeyCode.LWIN       // Left Windows key
VirtualKeyCode.RWIN       // Right Windows key

// Letter keys (A-Z)
VirtualKeyCode.VK_A       // through VK_Z

// Number keys (0-9)
VirtualKeyCode.VK_0       // through VK_9

// Function keys
VirtualKeyCode.F1         // through F24

// Navigation keys
VirtualKeyCode.TAB
VirtualKeyCode.RETURN     // Enter
VirtualKeyCode.ESCAPE
VirtualKeyCode.SPACE
VirtualKeyCode.BACK       // Backspace
VirtualKeyCode.DELETE
VirtualKeyCode.INSERT
VirtualKeyCode.HOME
VirtualKeyCode.END
VirtualKeyCode.PRIOR      // Page Up
VirtualKeyCode.NEXT       // Page Down
VirtualKeyCode.LEFT       // Arrow keys
VirtualKeyCode.UP
VirtualKeyCode.RIGHT
VirtualKeyCode.DOWN

// Toggle keys
VirtualKeyCode.CAPITAL    // Caps Lock
VirtualKeyCode.NUMLOCK
VirtualKeyCode.SCROLL     // Scroll Lock

// Numpad keys
VirtualKeyCode.NUMPAD0    // through NUMPAD9
VirtualKeyCode.MULTIPLY   // *
VirtualKeyCode.ADD        // +
VirtualKeyCode.SUBTRACT   // -
VirtualKeyCode.DECIMAL    // .
VirtualKeyCode.DIVIDE     // /

// Media keys
VirtualKeyCode.VOLUME_UP
VirtualKeyCode.VOLUME_DOWN
VirtualKeyCode.VOLUME_MUTE
VirtualKeyCode.MEDIA_PLAY_PAUSE
VirtualKeyCode.MEDIA_NEXT_TRACK
VirtualKeyCode.MEDIA_PREV_TRACK
VirtualKeyCode.MEDIA_STOP

// Browser keys
VirtualKeyCode.BROWSER_BACK
VirtualKeyCode.BROWSER_FORWARD
VirtualKeyCode.BROWSER_REFRESH
VirtualKeyCode.BROWSER_HOME
VirtualKeyCode.BROWSER_SEARCH
VirtualKeyCode.BROWSER_FAVORITES

// OEM keys (vary by keyboard layout)
VirtualKeyCode.OEM_1      // ;: key
VirtualKeyCode.OEM_PLUS   // + key
VirtualKeyCode.OEM_COMMA  // , key
VirtualKeyCode.OEM_MINUS  // - key
VirtualKeyCode.OEM_PERIOD // . key
```

--------------------------------

### Add Delays Between Inputs with Sleep

Source: https://context7.com/michaelnoonan/inputsimulator/llms.txt

Introduces pauses in the execution thread to create delays between simulated keyboard inputs. This is crucial for ensuring that applications have enough time to process previous inputs before the next one is sent, preventing race conditions and ensuring reliable automation.

```csharp
using WindowsInput;
using WindowsInput.Native;
using System;

var simulator = new InputSimulator();

// Sleep with milliseconds
simulator.Keyboard
    .KeyPress(VirtualKeyCode.VK_A)
    .Sleep(100)  // Wait 100ms
    .KeyPress(VirtualKeyCode.VK_B)
    .Sleep(100)
    .KeyPress(VirtualKeyCode.VK_C);

// Sleep with TimeSpan
simulator.Keyboard
    .TextEntry("Processing...")
    .Sleep(TimeSpan.FromSeconds(2))
    .TextEntry("Done!");

// Practical automation example
simulator.Keyboard
    .ModifiedKeyStroke(VirtualKeyCode.LWIN, VirtualKeyCode.VK_R)
    .Sleep(1000)                        // Wait for Run dialog
    .TextEntry("calc")
    .Sleep(500)
    .KeyPress(VirtualKeyCode.RETURN)
    .Sleep(1000)                        // Wait for Calculator to open
    .KeyPress(VirtualKeyCode.VK_5)
    .KeyPress(VirtualKeyCode.MULTIPLY)
    .KeyPress(VirtualKeyCode.VK_5)
    .KeyPress(VirtualKeyCode.RETURN);   // Calculate 5 * 5
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.