> ## Documentation Index
> Fetch the complete documentation index at: https://luau.limerence.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Types

> Luau export types for the script API.

A complete set of Luau type annotations for the whole `api`. Drop these at the top of your script if you want autocomplete and type-checking in an editor that understands Luau.

These types are a **superset across all games**: they list every field any game can provide. The game you're actually in only populates the universal namespaces plus that game's specific ones (see [Game support](/game-support)), so a field being in the type doesn't guarantee it exists at runtime. Guard game-specific calls with `if api.x.y then`.

## UI types

### KeyMode

```luau theme={null}
export type KeyMode = "onPress" | "onRelease" | "onHold" | "toggle"
```

### GradientAnimation

```luau theme={null}
export type GradientAnimation = "none" | "shimmer" | "rainbow" | "blink"
```

### CurvePoint

```luau theme={null}
export type CurvePoint = { x: number, y: number }
```

### ListItem

```luau theme={null}
export type ListItem = { id: string, name: string?, icon: string? }
```

### ColorSnapshot

```luau theme={null}
export type ColorSnapshot = {
    color: Color3,
    gradient: ColorSequence,
    transparency: number,
    rotation: number,
}
```

### OverrideHandle

```luau theme={null}
export type OverrideHandle = {
    Release: (self: OverrideHandle) -> (),
    IsReleased: (self: OverrideHandle) -> boolean,
    GetValue: (self: OverrideHandle) -> any,
    GetPriority: (self: OverrideHandle) -> number,
    SetValue: (self: OverrideHandle, value: any) -> (),
    SetPriority: (self: OverrideHandle, priority: number) -> (),
}
```

See [Overrides](/overrides/overview).

### ElementHandle

```luau theme={null}
export type ElementHandle = {
    id: string?,
    GetValue: (self: ElementHandle) -> any,
    SetValue: (self: ElementHandle, value: any) -> (),
    OnChange: (self: ElementHandle, callback: (value: any) -> ()) -> () -> (),
    GetText: (self: ElementHandle) -> string,
    SetText: (self: ElementHandle, text: string) -> (),
    Get: (self: ElementHandle, field: string) -> any,
    Set: (self: ElementHandle, field: string, value: any) -> (),
    Watch: (self: ElementHandle, field: string, callback: (value: any) -> ()) -> () -> (),
    Has: (self: ElementHandle, field: string) -> boolean,
    SetVisible: (self: ElementHandle, state: boolean) -> ElementHandle,
    IsVisible: (self: ElementHandle) -> boolean,
    OnVisibleChange: (self: ElementHandle, cb: (boolean) -> ()) -> () -> (),
    SetTip: (self: ElementHandle, tip: string | { title: string?, body: string? }?) -> ElementHandle,
    OverrideValue: (self: ElementHandle, value: any, priority: number?) -> OverrideHandle,
    IsOverridden: (self: ElementHandle) -> boolean,
    Destroy: (self: ElementHandle) -> (),
    Exists: (self: ElementHandle) -> boolean,
    [string]: any,
}
```

### ColorpickerHandle

```luau theme={null}
export type ColorpickerHandle = ElementHandle & {
    GetColor: (self: ColorpickerHandle) -> Color3,
    GetGradient: (self: ColorpickerHandle) -> ColorSequence,
    GetTransparency: (self: ColorpickerHandle) -> number,
    GetRotation: (self: ColorpickerHandle) -> number,
    GetSnapshot: (self: ColorpickerHandle) -> ColorSnapshot,
    OnUpdate: (self: ColorpickerHandle, cb: (ColorSnapshot) -> ()) -> () -> (),
    OnColorChange: (self: ColorpickerHandle, cb: (Color3 | ColorSequence) -> ()) -> () -> (),
    OnTransparencyChange: (self: ColorpickerHandle, cb: (number?) -> ()) -> () -> (),
    PeekColor: (self: ColorpickerHandle) -> Color3 | ColorSequence,
    PeekTransparency: (self: ColorpickerHandle) -> number?,
    SetState: (self: ColorpickerHandle, Color3 | ColorSequence) -> (),
    SetTransparency: (self: ColorpickerHandle, number) -> (),
    SetRotation: (self: ColorpickerHandle, number) -> (),
    SetAnimation: (self: ColorpickerHandle, GradientAnimation) -> (),
    SetSpeed: (self: ColorpickerHandle, number) -> (),
}
```

### Section

```luau theme={null}
export type Section = { [string]: any }
```

### Tab

```luau theme={null}
export type Tab = { AddSection: (self: Tab, title: string, column: number?) -> Section, [string]: any }
```

### NotifySpec

```luau theme={null}
export type NotifySpec = {
    title: string,
    subtext: string?,
    icon: string?,
    duration: number?,
    showProgress: boolean?,
    progress: number?,
    timer: boolean?,
}
```

### NotifyHandle

```luau theme={null}
export type NotifyHandle = {
    Dismiss: (self: NotifyHandle) -> (),
    Update: (self: NotifyHandle, patch: { title: string?, subtext: string?, icon: string?, progress: number? }) -> (),
    GetId: (self: NotifyHandle) -> string,
}
```

### ToastSpec

Passed to `api.ui.toast`.

```luau theme={null}
export type ToastSpec = {
    text: string,
    accent: Color3?,
    duration: number?,
}
```

### ToastHandle

Returned by `api.ui.toast`.

```luau theme={null}
export type ToastHandle = {
    Dismiss: (self: ToastHandle) -> (),
    GetId: (self: ToastHandle) -> string,
}
```

<h2 id="utility-types">
  Utility types
</h2>

### ApiSignal

Generic signal shape used by every `on*` event in the API.

```luau theme={null}
export type ApiSignal<T...> = { Connect: (self: any, cb: (T...) -> ()) -> RBXScriptConnection }
```

### FileArchive

Returned by `api.utility.loadArchive`.

```luau theme={null}
export type FileArchive = {
    path: string,
    readFile: (self: FileArchive, path: string) -> string,
    listFiles: (self: FileArchive, path: string) -> { string },
    isFile: (self: FileArchive, path: string) -> boolean,
    isFolder: (self: FileArchive, path: string) -> boolean,
}
```

## Bind types

### BindInfo

```luau theme={null}
export type BindInfo = {
    id: number,
    name: string,
    label: string,
    inputs: { string },
    inputLabels: { string },
    mode: string,
    active: boolean,
    targetValue: any,
}
```

### BindSignal

```luau theme={null}
export type BindSignal = {
    Connect: (self: BindSignal, cb: (BindInfo) -> ()) -> RBXScriptConnection,
}
```

<h2 id="legitbot-types">
  Legitbot types
</h2>

### TargetSnapshot

```luau theme={null}
export type TargetSnapshot = {
    player: Player,
    part: BasePart?,
    hitbox: string?,
    distance: number,
    pixelDist: number,
    alignment: number,
}
```

### ShotEvent

```luau theme={null}
export type ShotEvent = {
    player: Player,
    part: BasePart?,
    hitbox: string?,
    predictedDamage: number?,
    hitChance: number?,
    wallbang: boolean?,
    weapon: any?,
    source: string,
    burst: boolean,
}
```

### TargetEvent

```luau theme={null}
export type TargetEvent = { player: Player, part: BasePart?, hitbox: string? }
```

### TriggerEvent

```luau theme={null}
export type TriggerEvent = { player: Player, part: BasePart?, hitbox: string? }
```

### MagnetEvent

```luau theme={null}
export type MagnetEvent = {
    player: Player,
    part: BasePart?,
    dx: number,
    dy: number,
    strength: number,
}
```

### TargetFilterInfo

```luau theme={null}
export type TargetFilterInfo = { player: Player, weapon: any?, scope: string }
```

### ShotGateInfo

```luau theme={null}
export type ShotGateInfo = {
    player: Player,
    part: BasePart?,
    hitbox: string?,
    weapon: any?,
    predictedDamage: number?,
    hitChance: number?,
    wallbang: boolean?,
    burst: boolean,
}
```

### AimTransformInfo

```luau theme={null}
export type AimTransformInfo = {
    player: Player,
    part: BasePart?,
    hitbox: string?,
    weapon: any?,
    aimPoint: Vector3,
}
```

### RegistrationHandle

```luau theme={null}
export type RegistrationHandle = {
    Release: (self: RegistrationHandle) -> (),
    IsReleased: (self: RegistrationHandle) -> boolean,
    GetPriority: (self: RegistrationHandle) -> number,
    SetPriority: (self: RegistrationHandle, priority: number) -> (),
}
```

### ForceTargetHandle

```luau theme={null}
export type ForceTargetHandle = {
    Release: (self: ForceTargetHandle) -> (),
    IsReleased: (self: ForceTargetHandle) -> boolean,
    GetPlayer: (self: ForceTargetHandle) -> Player?,
}
```

<h2 id="ragebot-types">
  Ragebot types
</h2>

**Bloxstrike, Rivals, and Apocalypse Rising 2.** In Rivals and AR2 the `damage` field is always `0` (no damage model).

<h3 id="ragebotshotevent">
  RagebotShotEvent
</h3>

```luau theme={null}
export type RagebotShotEvent = {
    player: Player,
    part: BasePart,
    damage: number,
    wallbang: boolean,
    source: string,
    hitTarget: boolean,
}
```

<h3 id="ragebottargetevent">
  RagebotTargetEvent
</h3>

```luau theme={null}
export type RagebotTargetEvent = {
    player: Player,
    part: BasePart,
}
```

### RagebotTargetFilterInfo

```luau theme={null}
export type RagebotTargetFilterInfo = {
    player: Player,
    character: Model?,
    weapon: any?,
}
```

### RagebotShotGateInfo

```luau theme={null}
export type RagebotShotGateInfo = {
    player: Player,
    part: BasePart,
    damage: number,
    wallbang: boolean,
    weapon: any?,
    source: string,
}
```

### RagebotStrafeInfo

Rivals. Passed to `api.ragebot.setStrafeOverride`.

```luau theme={null}
export type RagebotStrafeInfo = {
    cframe: CFrame,
    position: Vector3,
    targetPosition: Vector3?,
    origin: Vector3,
    isVoid: boolean,
    distance: number,
    height: number,
    dt: number,
    angle: number,
    player: Player?,
    time: number,
}
```

## Client types

### LoadoutEntry

Bloxstrike. Used by `api.client.getWeapon()` / `getInventory()` and `onWeaponChanged`.

```luau theme={null}
export type LoadoutEntry = {
    Name: string?,
    Identifier: string?,
    Slot: number?,
    Skin: string?,
    Float: number?,
    StatTrack: number?,
    Stickers: any?,
    NameTag: string?,
    Charm: any?,
    Properties: any?,
    [string]: any,
}
```

### ArmorState

Bloxstrike. Returned by `api.client.getArmor()` and the player handle's `getArmor()`.

```luau theme={null}
export type ArmorState = { kevlar: boolean, helmet: boolean, health: number }
```

### AmmoState

Bloxstrike. Returned by `api.client.getAmmo()`.

```luau theme={null}
export type AmmoState = { rounds: number, reserve: number }
```

### EquippedItem

Rivals. Returned by `api.client.getEquipped()`.

```luau theme={null}
export type EquippedItem = { Name: string, Rounds: number?, Capacity: number? }
```

### Item

Apocalypse Rising 2. Inventory entries from `api.client.getItems()`, `getNearbyLoot()`, and `getEquipment()`. Pass an item's `id` to the action calls.

```luau theme={null}
export type Item = {
    id: any,
    name: string?,
    rawName: string?,
    type: string?,
    subType: string?,
    amount: number?,
    capacity: number?,
    caliber: any?,
    slot: string?,
    rotated: boolean,
    container: any?,   -- getNearbyLoot only
    source: string?,   -- getNearbyLoot only
    equipSlot: string?, -- getEquipment only
}
```

### HitEvent

Emitted by `api.client.onHit` (also Phantom Forces and Overkill).

```luau theme={null}
export type HitEvent = {
    player: Player,
    part: BasePart?,
    partName: string?,
    position: Vector3?,
    damage: number?,
    headshot: boolean?,
}
```

### KillEvent

Emitted by `api.client.onKill` (every game except Apocalypse Rising 2).

```luau theme={null}
export type KillEvent = {
    player: Player,
    position: Vector3?,
    headshot: boolean?,
}
```

## Players types

### PlayerHandle

```luau theme={null}
export type PlayerHandle = {
    -- Universal
    getPlayer: () -> Player,
    getCharacter: () -> Model?,
    getHumanoid: () -> Humanoid?,
    getRootPart: () -> BasePart?,
    getParts: () -> { [string]: Instance },
    isAlive: () -> boolean,
    getTeam: () -> string?,
    getHealth: () -> number,
    getMaxHealth: () -> number,
    getHealthFraction: () -> number,
    getPosition: () -> Vector3?,
    getCFrame: () -> CFrame?,
    getWeapon: () -> any?,
    getItemName: () -> string?,
    isReloading: () -> boolean,
    isBlind: () -> boolean,
    isScoped: () -> boolean,
    getState: () -> string?,
    setState: (state: string?) -> (),
    -- Bloxstrike
    isPlanting: () -> boolean,
    isDefusing: () -> boolean,
    hasC4: () -> boolean,
    getArmor: () -> ArmorState,
    hasArmor: () -> boolean,
    hasHelmet: () -> boolean,
    isRescuingHostage: () -> boolean,
    isCarryingHostage: () -> boolean,
    getMoney: () -> number,
    hasDefuseKit: () -> boolean,
    getBacktrackPosition: (partName: string) -> Vector3?,
    -- Rivals
    getEnvironmentId: () -> string,
    getItems: () -> { string },
    getVelocity: () -> Vector3,
    getLevel: () -> number,
    getWinStreak: () -> number,
    getDisplayElo: () -> number,
    isInDuel: () -> boolean,
    isSpectating: () -> boolean,
    isCrouching: () -> boolean,
    isSliding: () -> boolean,
    isFirstPerson: () -> boolean,
    isFrozen: () -> boolean,
    isInvincible: () -> boolean,
    isHidden: () -> boolean,
    isBlocking: () -> boolean,
    isDeflecting: () -> boolean,
    isHealing: () -> boolean,
    -- Bloxstrike and Apocalypse Rising 2
    getAmmo: () -> number?,
    getMaxAmmo: () -> number?,
}
```

## Game types

### BombState

Bloxstrike. Returned by `api.game.getBomb()` and the bomb signals.

```luau theme={null}
export type BombState = {
    model: Model,
    startedAt: number,
    explodeAt: number,
    duration: number,
    isDefusing: boolean,
    isDefused: boolean,
    isExploded: boolean,
}
```

### PlantingState

Bloxstrike. Returned by `api.game.getPlanting()` and the plant signals.

```luau theme={null}
export type PlantingState = {
    site: string?,
    startedAt: number,
    duration: number,
}
```

### HostageState

Bloxstrike. Returned by `api.game.getHostages()` / `getHostage()` and the hostage signals.

```luau theme={null}
export type HostageState = {
    model: Model,
    state: string,
    canRescue: boolean,
    rescuingPlayer: string?,
    carryingPlayer: string?,
    rescueStartedAt: number?,
    rescueDuration: number?,
}
```

### DroppedItem

Bloxstrike. Returned by `api.game.getDroppedItems()` / `getDroppedItem(model)` and the dropped item signals.

```luau theme={null}
export type DroppedItem = {
    model: Model,
    kind: "weapon" | "bomb" | "item",
    label: string,
    weaponName: string,
    rounds: number,
    maxRounds: number,
    position: Vector3,
}
```

### Purchase

Bloxstrike. Returned by `api.game.getPurchases()` / `getLastPurchase()` and the buy signals.

```luau theme={null}
export type Purchase = {
    player: Player,
    playerName: string,
    name: string,
    kind: string,          -- "weapon" or "equipment"
    icon: string,          -- icon asset id, empty string when unknown
    cost: number,
    refund: boolean,       -- true when the item was sold back
    friendly: boolean,     -- true when they are on your team
    isLocal: boolean,      -- true when it was you
    at: number,            -- os.clock() when it was reported
}
```

### PlaceableEntry

Rivals. Returned by `api.game.getPlaceables()` / `getPlaceable(id)`.

```luau theme={null}
export type PlaceableEntry = {
    id: string,
    kind: string,
    label: string,
    position: Vector3,
    instance: Instance,
    friendly: boolean,
}
```

### Grenade

Bloxstrike and Rivals. Returned by `api.game.getGrenades()` and the grenade signals. `position` is the predicted landing spot, `detonateAt` compares against `os.clock()`.

```luau theme={null}
export type Grenade = {
    id: string,
    name: string,
    position: Vector3,
    detonateAt: number,
    friendly: boolean,
}
```

### PfDroppedWeapon

Phantom Forces. Returned by `api.game.getDroppedWeapons()`.

```luau theme={null}
export type PfDroppedWeapon = {
    name: string,
    position: Vector3?,
    model: Instance,
}
```

### PfGrenade

Phantom Forces. Returned by `api.game.getGrenades()`.

```luau theme={null}
export type PfGrenade = {
    name: string,
    position: Vector3,
    detonateAt: number,
    blastRadius: number,
    friendly: boolean,
    mine: boolean,
}
```

### OverkillProjectile

Overkill. Returned by `api.game.getProjectiles()` and the projectile signals.

```luau theme={null}
export type OverkillProjectile = {
    id: any,
    name: string?,
    position: Vector3?,
    detonateAt: number?,
    explosive: boolean,
    radius: number?,
    friendly: boolean,
}
```

<h2 id="autoloot-types">
  Autoloot types
</h2>

Apocalypse Rising 2. Used by [api.feature.autoloot](/feature/overview#auto-loot).

### AutoLootItem

Passed to `addItemFilter`.

```luau theme={null}
export type AutoLootItem = {
    name: string?,
    rawName: string?,
    type: string?,
    caliber: any?,
    slot: string?,
}
```

### AutoLootAction

Passed to `addActionFilter` and `onAction`.

```luau theme={null}
export type AutoLootAction = {
    type: string,
    kind: string?,
    name: string?,
    caliber: any?,
    slot: string?,
}
```

### AutoLootHandle

Returned by `addItemFilter`, `addActionFilter`, `blockItem`, `blockAction`, and `forceItem`.

```luau theme={null}
export type AutoLootHandle = {
    Release: (self: AutoLootHandle) -> (),
    IsReleased: (self: AutoLootHandle) -> boolean,
    GetPriority: (self: AutoLootHandle) -> number,
    SetPriority: ((self: AutoLootHandle, priority: number) -> ())?, -- filters only, absent on forceItem handles
}
```

<h2 id="musichud-types">
  Music HUD types
</h2>

Every game. Used by `api.feature.musichud`.

### MusicTrack

```luau theme={null}
export type MusicTrack = {
    id: string,
    title: string,
    artist: string,
    album: string?,
    coverUrl: string?,
    duration: number,
}
```

### MusicPlayback

```luau theme={null}
export type MusicPlayback = {
    elapsed: number,
    duration: number,
    paused: boolean,
}
```

### MusicLyric

```luau theme={null}
export type MusicLyric = {
    time: number,
    text: string,
}
```

### MusicSourceSpec

Passed to `api.feature.musichud.setSource`.

```luau theme={null}
export type MusicSourceSpec = {
    poll: () -> (MusicSourceTrack?, MusicSourcePlayback?),
    interval: number?,
    reset: (() -> ())?,
    name: string?,
}
```

### MusicSourceTrack

```luau theme={null}
export type MusicSourceTrack = {
    id: string?,
    title: string,
    artist: string?,
    album: string?,
    coverUrl: string?,
    duration: number,
}
```

### MusicSourcePlayback

```luau theme={null}
export type MusicSourcePlayback = {
    elapsed: number,
    paused: boolean?,
}
```

<h2 id="universal-types">
  Universal mode types
</h2>

Universal mode only. Used by [api.universal](/universal/overview).

### UniversalHandle

Returned by every `api.universal.set*` call. Call `Release()` to undo that one setting early; all of them are undone when your script unloads.

```luau theme={null}
export type UniversalHandle = { Release: (self: UniversalHandle) -> () }
```

### UniversalHitReport

Passed to `api.universal.reportHit`.

```luau theme={null}
export type UniversalHitReport = {
    player: Player?,
    part: BasePart?,
    partName: string?,
    position: Vector3?,
    damage: number?,
    headshot: boolean?,
    lethal: boolean?,
}
```

### UniversalKillReport

Passed to `api.universal.reportKill`.

```luau theme={null}
export type UniversalKillReport = {
    player: Player?,
    position: Vector3?,
    headshot: boolean?,
}
```

### UniversalWeapon

Passed to `api.universal.setWeapon` and returned by `setWeaponResolver`. Per-weapon settings follow the `Name`.

```luau theme={null}
export type UniversalWeapon = { Name: string?, [string]: any }
```

### UniversalBotHandle

Returned by `api.universal.bots.add`.

```luau theme={null}
export type UniversalBotHandle = {
    setHealth: (self: UniversalBotHandle, health: number, maxHealth: number?) -> (),
    setTeam: (self: UniversalBotHandle, team: string) -> (),
    setAlive: (self: UniversalBotHandle, alive: boolean) -> (),
    getModel: (self: UniversalBotHandle) -> Model,
    remove: (self: UniversalBotHandle) -> (),
}
```

## Api

```luau theme={null}
export type Api = {
    name: string,
    getGame: () -> string,
    onUnload: (cb: () -> ()) -> (),
    ui: {
        tab: (title: string, icon: string?) -> Tab,
        find: (id: string) -> ElementHandle?,
        notify: (spec: NotifySpec) -> NotifyHandle,
        toast: (spec: string | ToastSpec) -> ToastHandle,
    },
    utility: {
        connect: (RBXScriptSignal, (...any) -> ()) -> (),
        getAsset: (string, string) -> any,
        getAssets: (string?) -> { [string]: any },
        loadArchive: (archive: string | buffer, archiveType: ("Tar" | "Zip")?) -> FileArchive,
        configLoaded: ApiSignal<string>,
    },
    world: {
        getMap: () -> string?,
        getMaps: () -> { string },
        onMapChanged: ApiSignal<string?>,
    },
    bind: {
        list: () -> { BindInfo },
        getActive: () -> { BindInfo },
        get: (id: number) -> BindInfo?,
        getInputLabel: (input: Enum.KeyCode | Enum.UserInputType | string) -> string,
        isAnyBindActive: () -> boolean,
        onCreated: BindSignal,
        onRemoved: BindSignal,
        onActivated: BindSignal,
        onDeactivated: BindSignal,
        onChanged: BindSignal,
    },
    legitbot: {
        getTarget: () -> { player: Player, part: BasePart?, hitbox: string? }?,
        getTriggerTarget: () -> { player: Player, part: BasePart?, hitbox: string? }?,
        getValidTargets: () -> { TargetSnapshot },
        getActiveScope: () -> string,
        getResolvedValue: (key: string, scopeId: string?) -> any,
        isFiring: () -> boolean,
        getBurstRemaining: () -> number?,
        getLastShotTime: () -> number?,
        addTargetFilter: ((Player, TargetFilterInfo) -> boolean, number?) -> RegistrationHandle,
        addShotGate: ((ShotGateInfo) -> boolean, number?) -> RegistrationHandle,
        addAimTransform: ((AimTransformInfo) -> Vector3?, number?) -> RegistrationHandle,
        forceTarget: (player: Player | string | number, durationSec: number?) -> ForceTargetHandle?,
        clearForcedTarget: () -> (),
        requestShot: () -> (),
        onShotFired: ApiSignal<ShotEvent>,
        onTargetAcquired: ApiSignal<TargetEvent>,
        onTargetLost: ApiSignal<TargetEvent>,
        onTriggerArmed: ApiSignal<TriggerEvent>,
        onTriggerDisarmed: ApiSignal<()>,
        onScopeChanged: ApiSignal<string>,
        onMagnetPull: ApiSignal<MagnetEvent>,
    },
    -- Bloxstrike, Rivals, and Apocalypse Rising 2.
    ragebot: {
        isEnabled: () -> boolean,
        getLastShotTime: () -> number?,
        getLastTarget: () -> { player: Player, part: BasePart? }?,
        getInFlightStats: (player: Player | string | number) -> { damage: number, shotCount: number }?,
        isPlayerCovered: (player: Player | string | number) -> boolean,
        clearInFlight: (player: Player | string | number?) -> (),
        addTargetFilter: ((Player, RagebotTargetFilterInfo) -> boolean, number?) -> RegistrationHandle,
        addShotGate: ((RagebotShotGateInfo) -> boolean, number?) -> RegistrationHandle,
        forceTarget: (player: Player | string | number, durationSec: number?) -> ForceTargetHandle?,
        clearForcedTarget: () -> (),
        getForcedTarget: () -> Player?,
        -- Rivals
        setStrafeOverride: ((RagebotStrafeInfo) -> (CFrame | Vector3)?, number?) -> RegistrationHandle,
        getStrafePosition: () -> CFrame?,
        onShotFired: ApiSignal<RagebotShotEvent>,
        onTargetChanged: ApiSignal<RagebotTargetEvent>,
    },
    client: {
        -- Universal
        getPlayer: () -> Player,
        getCharacter: () -> Model?,
        getHumanoid: () -> Humanoid?,
        getRootPart: () -> BasePart?,
        getParts: () -> { [string]: Instance },
        isAlive: () -> boolean,
        isSpectating: () -> boolean,
        getTeam: () -> string?,
        getHealth: () -> number,
        getMaxHealth: () -> number,
        getHealthFraction: () -> number,
        getPosition: () -> Vector3?,
        getCFrame: () -> CFrame?,
        getVelocity: () -> Vector3,
        getItemName: () -> string?,
        onCharacterAdded: ApiSignal<Model>,
        onCharacterRemoving: ApiSignal<Model>,
        onSpawn: ApiSignal<()>,
        onDeath: ApiSignal<()>,
        onTeamChanged: ApiSignal<string?>,
        onHealthChanged: ApiSignal<number, number>,
        onHit: ApiSignal<HitEvent>,       -- also Phantom Forces and Overkill
        onKill: ApiSignal<KillEvent>,     -- every game except Apocalypse Rising 2
        -- Bloxstrike
        getWeapon: () -> LoadoutEntry?,
        getWeaponProperties: () -> any?,
        getInventory: () -> { LoadoutEntry },
        isBlind: () -> boolean,
        isFlashed: () -> boolean,
        getFlashVisibility: () -> number,
        isScoped: () -> boolean,
        isDefusing: () -> boolean,
        isClimbing: () -> boolean,
        hasC4: () -> boolean,
        isRescuingHostage: () -> boolean,
        isCarryingHostage: () -> boolean,
        getArmor: () -> ArmorState,
        hasArmor: () -> boolean,
        hasHelmet: () -> boolean,
        getSpectatorCount: () -> number,
        isBeingSpectated: () -> boolean,
        getMoney: () -> number,
        getAmmo: () -> AmmoState?,
        onWeaponChanged: ApiSignal<LoadoutEntry?>,
        onSpectatingChanged: ApiSignal<boolean>,
        onBlindChanged: ApiSignal<boolean>,
        onFlashVisibilityChanged: ApiSignal<number>,
        onScopedChanged: ApiSignal<boolean>,
        onDefusingChanged: ApiSignal<boolean>,
        onC4Changed: ApiSignal<boolean>,
        onRescuingChanged: ApiSignal<boolean>,
        onCarryingChanged: ApiSignal<boolean>,
        onArmorChanged: ApiSignal<ArmorState>,
        onSpectatorCountChanged: ApiSignal<number>,
        onMoneyChanged: ApiSignal<number>,
        -- Rivals
        getEquipped: () -> EquippedItem?,
        getEnvironmentId: () -> string,
        isInDuel: () -> boolean,
        isCrouching: () -> boolean,
        isSliding: () -> boolean,
        isFirstPerson: () -> boolean,
        isFrozen: () -> boolean,
        isInvincible: () -> boolean,
        isHidden: () -> boolean,
        getAimCFrame: () -> CFrame,
        getControls: () -> string,
        getItems: () -> { string },
        getLevel: () -> number,
        getWinStreak: () -> number,
        getDisplayElo: () -> number,
        onEquippedChanged: ApiSignal<EquippedItem?>,
        -- Apocalypse Rising 2
        getItem: () -> string?,
        getHydration: () -> number,
        getEnergy: () -> number,
        isThirdPerson: () -> boolean,
        getVehicle: () -> Model?,
        getNearbyLoot: () -> { Item },
        getEquipment: () -> { Item },
        equipItem: (id: any, slot: any?) -> (),
        useItem: (id: any) -> (),
        dropItem: (id: any, rotated: boolean?) -> (),
        pickupItem: (id: any, containerId: any?) -> (),
        craftItem: (id: any, sourceId: any) -> (),
        fillAmmo: (id: any) -> (),
        unloadAmmo: (id: any) -> (),
        slotUtility: (id: any) -> (),
        removeAttachment: (id: any, parentId: any?) -> (),
    },
    players: {
        getAll: () -> { Player },
        get: (player: Player) -> PlayerHandle?,
        getStates: () -> { { id: string, label: string } },
        onStateChanged: ApiSignal<Player, string?>,
        -- Universal
        onPlayerAdded: ApiSignal<Player>,
        onPlayerRemoving: ApiSignal<Player>,
        onCharacterAdded: ApiSignal<Player, Model>,
        onCharacterRemoving: ApiSignal<Player, Model>,
        onSpawn: ApiSignal<Player>,
        onDeath: ApiSignal<Player>,
        onTeamChanged: ApiSignal<Player, string?>,
        onHealthChanged: ApiSignal<Player, number, number>,
        onWeaponChanged: ApiSignal<Player, any?>,
        onReloadingChanged: ApiSignal<Player, boolean>,
        onBlindChanged: ApiSignal<Player, boolean>,
        onScopedChanged: ApiSignal<Player, boolean>,
        -- Bloxstrike
        onPlantingChanged: ApiSignal<Player, boolean>,
        onDefusingChanged: ApiSignal<Player, boolean>,
        onC4Changed: ApiSignal<Player, boolean>,
        onArmorChanged: ApiSignal<Player, any>,
        onRescuingChanged: ApiSignal<Player, boolean>,
        onCarryingChanged: ApiSignal<Player, boolean>,
        onMoneyChanged: ApiSignal<Player, number>,
        -- Rivals
        onEnvironmentChanged: ApiSignal<Player, string>,
        onFrozenChanged: ApiSignal<Player, boolean>,
        onInvincibleChanged: ApiSignal<Player, boolean>,
        onDuelChanged: ApiSignal<Player, boolean>,
        onBlockingChanged: ApiSignal<Player, boolean>,
        onDeflectingChanged: ApiSignal<Player, boolean>,
        onHealingChanged: ApiSignal<Player, boolean>,
        -- Apocalypse Rising 2
        onAmmoChanged: ApiSignal<Player, number?, number?>,
    },
    -- `game` contents differ per game (Bloxstrike: bomb/hostage; Rivals: match/placeables; Apocalypse Rising 2: world pings).
    game: {
        -- Bloxstrike
        getBomb: () -> BombState?,
        getBombTime: () -> number?,
        isBombPlanted: () -> boolean,
        isBombDefusing: () -> boolean,
        isBombDefused: () -> boolean,
        isBombExploded: () -> boolean,
        getPlanting: () -> PlantingState?,
        getHostages: () -> { [string]: HostageState },
        getHostage: (key: string) -> HostageState?,
        getRescueRemaining: (hostage: HostageState) -> number?,
        getRescueProgress: (hostage: HostageState) -> number,
        onBombPlanted: ApiSignal<BombState>,
        onBombDefused: ApiSignal<BombState>,
        onBombExploded: ApiSignal<BombState>,
        onBombCleared: ApiSignal<()>,
        onPlantingStarted: ApiSignal<PlantingState>,
        onPlantingEnded: ApiSignal<PlantingState>,
        onHostageAdded: ApiSignal<string, HostageState>,
        onHostageRemoved: ApiSignal<string, HostageState>,
        onHostageChanged: ApiSignal<string, HostageState>,
        getGamemode: () -> string?,
        getServerGamemode: () -> string?,
        isBombDefusal: () -> boolean,
        isHostageRescue: () -> boolean,
        isDeathmatch: () -> boolean,
        isCompetitive: () -> boolean,
        onGamemodeChanged: ApiSignal<string?>,
        onServerGamemodeChanged: ApiSignal<string?>,
        getDroppedItems: () -> { DroppedItem },
        getDroppedItem: (model: Model) -> DroppedItem?,
        onDroppedItemAdded: ApiSignal<DroppedItem>,
        onDroppedItemRemoved: ApiSignal<DroppedItem>,
        getGrenades: () -> { Grenade },
        onGrenadeAdded: ApiSignal<Grenade>,
        onGrenadeRemoved: ApiSignal<Grenade>,
        getPurchases: () -> { Purchase },
        getLastPurchase: (player: Player?) -> Purchase?,
        getItemIcon: (name: string) -> string,
        getItemCost: (name: string) -> number,
        onPurchase: ApiSignal<Purchase>,
        onSell: ApiSignal<Purchase>,
        -- Rivals
        isInGame: () -> boolean,
        getTeamId: () -> string,
        getEnvironmentId: () -> string,
        getPlaceables: () -> { PlaceableEntry },
        getPlaceable: (id: string) -> PlaceableEntry?,
        onInGameChanged: ApiSignal<boolean>,
        onTeamChanged: ApiSignal<string>,
        onEnvironmentChanged: ApiSignal<string>,
        onPlaceableAdded: ApiSignal<string, PlaceableEntry>,
        onPlaceableRemoved: ApiSignal<string, PlaceableEntry>,
        -- Murderers vs Sheriffs Duels
        isInMatch: () -> boolean,
        getMatchId: () -> any?,
        getTeam: () -> string?,
        getGamemode: () -> string?,
        onMatchChanged: ApiSignal<any?>,
        -- Apocalypse Rising 2
        ping: (position: Vector3) -> (),
        pingPlayer: (player: Player) -> (),
        clearPing: () -> (),
        getSquad: () -> { Player },
        isSquadmate: (player: Player) -> boolean,
        getZombies: () -> { Model },
        onSquadChanged: ApiSignal<()>,
        onZombieAdded: ApiSignal<Model>,
        onZombieRemoved: ApiSignal<Model>,
        -- Phantom Forces
        isInGame: () -> boolean,
        getGamemode: () -> string?,
        getDroppedWeapons: () -> { PfDroppedWeapon },
        getGrenades: () -> { PfGrenade },
        onMatchChanged: ApiSignal<()>,
        onRoundStarted: ApiSignal<()>,
        onRoundEnded: ApiSignal<()>,
        -- Overkill
        isInMatch: () -> boolean,
        isInLobby: () -> boolean,
        getMatchId: () -> any?,
        getTeamId: () -> string?,
        getProjectiles: () -> { OverkillProjectile },
        queueMatch: (mode: string) -> (),
        cancelQueue: () -> (),
        leaveMatch: () -> (),
        onProjectileAdded: ApiSignal<OverkillProjectile>,
        onProjectileRemoved: ApiSignal<OverkillProjectile>,
    },
    feature: {
        -- Apocalypse Rising 2 only.
        autoloot: {
            isEnabled: () -> boolean,
            isActive: () -> boolean,
            scan: () -> (),
            addItemFilter: ((AutoLootItem) -> boolean, number?) -> AutoLootHandle,
            addActionFilter: ((AutoLootAction) -> boolean, number?) -> AutoLootHandle,
            blockItem: (names: string | { string }) -> AutoLootHandle,
            blockAction: (types: string | { string }) -> AutoLootHandle,
            forceItem: (name: string, durationSec: number?) -> AutoLootHandle,
            onAction: ApiSignal<AutoLootAction>,
        }?,
        -- Every game.
        musichud: {
            isEnabled: () -> boolean,
            isPaused: () -> boolean,
            getTrack: () -> MusicTrack?,
            getPlayback: () -> MusicPlayback?,
            getLyrics: () -> { MusicLyric }?,
            getLyric: () -> string?,
            setSource: (spec: MusicSourceSpec?) -> (),
            setLyrics: (fn: ((MusicTrack) -> { MusicLyric }?)?) -> (),
            onTrackChanged: ApiSignal<MusicTrack?>,
            onPauseChanged: ApiSignal<boolean>,
        },
        -- Bloxstrike, Rivals, Overkill, Murderers vs Sheriffs Duels.
        autopeek: {
            save: () -> boolean,
            retreat: () -> (),
            clear: () -> (),
            isPeeking: () -> boolean,
            isRetreating: () -> boolean,
        }?,
        -- Bloxstrike.
        antiaim: {
            setYaw: (yaw: number?) -> (),
            setPitch: (pitch: number?) -> (),
            getYaw: () -> number?,
            getPitch: () -> number?,
            getAngles: () -> { yaw: number, pitch: number }?,
            clear: () -> (),
            isEnabled: () -> boolean,
            isActive: () -> boolean,
        }?,
    },
    -- Universal mode only.
    universal: {
        setCharacterResolver: (fn: (Player) -> Model?) -> UniversalHandle,
        setPartsResolver: (fn: (Model, Player) -> { [string]: Instance }?) -> UniversalHandle,
        setTeamResolver: (fn: (Player) -> string?) -> UniversalHandle,
        setHealthResolver: (fn: (Player) -> (number?, number?)) -> UniversalHandle,
        setAliveResolver: (fn: (Player) -> boolean?) -> UniversalHandle,
        setLocalTeamResolver: (fn: () -> string?) -> UniversalHandle,
        setLocalAliveResolver: (fn: () -> boolean?) -> UniversalHandle,
        setEspFilter: (fn: (Player) -> boolean?) -> UniversalHandle,
        setHitboxParts: (map: { [string]: { string } }) -> UniversalHandle,
        refresh: (player: Player?) -> (),
        setWeapon: (weapon: UniversalWeapon?) -> UniversalHandle,
        clearWeapon: () -> (),
        setWeaponResolver: (fn: () -> UniversalWeapon?) -> UniversalHandle,
        setCanShoot: (fn: (UniversalWeapon?) -> boolean?) -> UniversalHandle,
        setCanFire: (fn: (UniversalWeapon?) -> boolean?) -> UniversalHandle,
        setFire: (fn: (UniversalWeapon?) -> ()) -> UniversalHandle,
        setStopFire: (fn: () -> ()) -> UniversalHandle,
        setWeaponList: (list: { string | { name: string, group: string? } }) -> UniversalHandle,
        reportHit: (info: UniversalHitReport) -> (),
        reportKill: (info: UniversalKillReport) -> (),
        reportShot: (origin: Vector3, target: Vector3, player: Player?) -> (),
        bots: {
            add: (model: Model, opts: { name: string?, team: string?, health: number?, maxHealth: number? }?) -> UniversalBotHandle,
            remove: (model: Model) -> (),
            getAll: () -> { Model },
        },
    }?,
}
```