Types - Limerence

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), 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

export type KeyMode = "onPress" | "onRelease" | "onHold" | "toggle"

GradientAnimation

export type GradientAnimation = "none" | "shimmer" | "rainbow" | "blink"

CurvePoint

export type CurvePoint = { x: number, y: number }

ListItem

export type ListItem = { id: string, name: string?, icon: string? }

ColorSnapshot

export type ColorSnapshot = {
    color: Color3,
    gradient: ColorSequence,
    transparency: number,
    rotation: number,
}

OverrideHandle

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.

ElementHandle

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

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

export type Section = { [string]: any }

Tab

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

NotifySpec

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

NotifyHandle

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.

export type ToastSpec = {
    text: string,
    accent: Color3?,
    duration: number?,
}

ToastHandle

Returned by api.ui.toast.

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

Utility types

ApiSignal

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

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

FileArchive

Returned by api.utility.loadArchive.

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

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

BindSignal

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

Legitbot types

TargetSnapshot

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

ShotEvent

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

TargetEvent

export type TargetEvent = { player: Player, part: BasePart?, hitbox: string? }

TriggerEvent

export type TriggerEvent = { player: Player, part: BasePart?, hitbox: string? }

MagnetEvent

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

TargetFilterInfo

export type TargetFilterInfo = { player: Player, weapon: any?, scope: string }

ShotGateInfo

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

AimTransformInfo

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

RegistrationHandle

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

ForceTargetHandle

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

Ragebot types

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

RagebotShotEvent

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

RagebotTargetEvent

export type RagebotTargetEvent = {
    player: Player,
    part: BasePart,
}

RagebotTargetFilterInfo

export type RagebotTargetFilterInfo = {
    player: Player,
    character: Model?,
    weapon: any?,
}

RagebotShotGateInfo

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

RagebotStrafeInfo

Rivals. Passed to api.ragebot.setStrafeOverride.

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.

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().

export type ArmorState = { kevlar: boolean, helmet: boolean, health: number }

AmmoState

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

export type AmmoState = { rounds: number, reserve: number }

EquippedItem

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

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.

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).

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).

export type KillEvent = {
    player: Player,
    position: Vector3?,
    headshot: boolean?,
}

Players types

PlayerHandle

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.

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.

export type PlantingState = {
    site: string?,
    startedAt: number,
    duration: number,
}

HostageState

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

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.

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.

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).

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().

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

PfDroppedWeapon

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

export type PfDroppedWeapon = {
    name: string,
    position: Vector3?,
    model: Instance,
}

PfGrenade

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

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.

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

Autoloot types

Apocalypse Rising 2. Used by api.feature.autoloot.

AutoLootItem

Passed to addItemFilter.

export type AutoLootItem = {
    name: string?,
    rawName: string?,
    type: string?,
    caliber: any?,
    slot: string?,
}

AutoLootAction

Passed to addActionFilter and onAction.

export type AutoLootAction = {
    type: string,
    kind: string?,
    name: string?,
    caliber: any?,
    slot: string?,
}

AutoLootHandle

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

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
}

Music HUD types

Every game. Used by api.feature.musichud.

MusicTrack

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

MusicPlayback

export type MusicPlayback = {
    elapsed: number,
    duration: number,
    paused: boolean,
}

MusicLyric

export type MusicLyric = {
    time: number,
    text: string,
}

MusicSourceSpec

Passed to api.feature.musichud.setSource.

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

MusicSourceTrack

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

MusicSourcePlayback

export type MusicSourcePlayback = {
    elapsed: number,
    paused: boolean?,
}

Universal mode types

Universal mode only. Used by api.universal.

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.

export type UniversalHandle = { Release: (self: UniversalHandle) -> () }

UniversalHitReport

Passed to api.universal.reportHit.

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

UniversalKillReport

Passed to api.universal.reportKill.

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.

export type UniversalWeapon = { Name: string?, [string]: any }

UniversalBotHandle

Returned by api.universal.bots.add.

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

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 },
        },
    }?,
}

​UI types

​KeyMode

​GradientAnimation

​CurvePoint

​ListItem

​ColorSnapshot

​OverrideHandle

​ElementHandle

​ColorpickerHandle

​Section

​Tab

​NotifySpec

​NotifyHandle

​ToastSpec

​ToastHandle

​Utility types

​ApiSignal

​FileArchive

​Bind types

​BindInfo

​BindSignal

​Legitbot types

​TargetSnapshot

​ShotEvent

​TargetEvent

​TriggerEvent

​MagnetEvent

​TargetFilterInfo

​ShotGateInfo

​AimTransformInfo

​RegistrationHandle

​ForceTargetHandle

​Ragebot types

​RagebotShotEvent

​RagebotTargetEvent

​RagebotTargetFilterInfo

​RagebotShotGateInfo

​RagebotStrafeInfo

​Client types

​LoadoutEntry

​ArmorState

​AmmoState

​EquippedItem

​Item

​HitEvent

​KillEvent

​Players types

​PlayerHandle

​Game types

​BombState

​PlantingState

​HostageState

​DroppedItem

​Purchase

​PlaceableEntry

​Grenade

​PfDroppedWeapon

​PfGrenade

​OverkillProjectile

​Autoloot types

​AutoLootItem

​AutoLootAction

​AutoLootHandle

​Music HUD types

​MusicTrack

​MusicPlayback

​MusicLyric

​MusicSourceSpec

​MusicSourceTrack

​MusicSourcePlayback

​Universal mode types

​UniversalHandle

​UniversalHitReport

​UniversalKillReport

​UniversalWeapon

​UniversalBotHandle

​Api