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 shared 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) -> (),
}

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

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,        -- "Head" | "Torso" | "Arms" | "Legs" | "Feet"
    distance: number,
    pixelDist: number,
    alignment: number,     -- 0..1 (1 = center, 0 = FOV edge)
}

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: any?,
    Stickers: any?,
    NameTag: string?,
    Charm: any?,
    Properties: any?,
}

ArmorState

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

export type ArmorState = {
    kevlar: boolean,
    helmet: boolean,
    health: number,    -- 0 to 100
}

AmmoState

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

export type AmmoState = {
    rounds: number,     -- rounds left in the magazine
    reserve: number,    -- rounds left in reserve
}

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
}

Players types

PlayerHandle

export type PlayerHandle = {
    -- Universal
    getPlayer: (self: PlayerHandle) -> Player,
    getCharacter: (self: PlayerHandle) -> Model?,
    getHumanoid: (self: PlayerHandle) -> Humanoid?,
    getRootPart: (self: PlayerHandle) -> BasePart?,
    getParts: (self: PlayerHandle) -> { [string]: Instance },
    isAlive: (self: PlayerHandle) -> boolean,
    getTeam: (self: PlayerHandle) -> string?,
    getHealth: (self: PlayerHandle) -> number,
    getMaxHealth: (self: PlayerHandle) -> number,
    getHealthFraction: (self: PlayerHandle) -> number,
    getPosition: (self: PlayerHandle) -> Vector3?,
    getCFrame: (self: PlayerHandle) -> CFrame?,
    getWeapon: (self: PlayerHandle) -> any?,
    getWeaponName: (self: PlayerHandle) -> string?,
    isReloading: (self: PlayerHandle) -> boolean,
    isBlind: (self: PlayerHandle) -> boolean,
    isScoped: (self: PlayerHandle) -> boolean,
    getState: (self: PlayerHandle) -> string?,
    -- Bloxstrike
    isPlanting: (self: PlayerHandle) -> boolean,
    isDefusing: (self: PlayerHandle) -> boolean,
    hasC4: (self: PlayerHandle) -> boolean,
    getArmor: (self: PlayerHandle) -> ArmorState,
    hasArmor: (self: PlayerHandle) -> boolean,
    hasHelmet: (self: PlayerHandle) -> boolean,
    isRescuingHostage: (self: PlayerHandle) -> boolean,
    isCarryingHostage: (self: PlayerHandle) -> boolean,
    getMoney: (self: PlayerHandle) -> number,
    hasDefuseKit: (self: PlayerHandle) -> boolean,
    getBacktrackPosition: (self: PlayerHandle, partName: string) -> Vector3?,
    -- Rivals
    getEnvironmentId: (self: PlayerHandle) -> string,
    getItems: (self: PlayerHandle) -> { string },
    getVelocity: (self: PlayerHandle) -> Vector3,
    getLevel: (self: PlayerHandle) -> number,
    getWinStreak: (self: PlayerHandle) -> number,
    getDisplayElo: (self: PlayerHandle) -> number,
    isInDuel: (self: PlayerHandle) -> boolean,
    isSpectating: (self: PlayerHandle) -> boolean,
    isCrouching: (self: PlayerHandle) -> boolean,
    isSliding: (self: PlayerHandle) -> boolean,
    isFirstPerson: (self: PlayerHandle) -> boolean,
    isFrozen: (self: PlayerHandle) -> boolean,
    isInvincible: (self: PlayerHandle) -> boolean,
    isHidden: (self: PlayerHandle) -> boolean,
    isBlocking: (self: PlayerHandle) -> boolean,
    isDeflecting: (self: PlayerHandle) -> boolean,
    isHealing: (self: PlayerHandle) -> boolean,
    -- Bloxstrike and Apocalypse Rising 2
    getAmmo: (self: PlayerHandle) -> number?,
    getMaxAmmo: (self: PlayerHandle) -> 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,                      -- the Roblox Model on the ground
    kind: "weapon" | "bomb" | "item",  -- "item" covers grenades etc.
    label: string,                     -- short display label
    weaponName: string,                -- the weapon's name
    rounds: number,                    -- rounds left in its magazine (0 if not tracked)
    maxRounds: number,                 -- magazine size (0 if not tracked)
    position: Vector3,                 -- where it is in the world
}

PlaceableEntry

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

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

Autoloot types

Apocalypse Rising 2. Used by api.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,
}

Api

export type Api = {
    name: string,
    onUnload: (callback: () -> ()) -> (),
    ui: {
        tab: (title: string, icon: string?) -> Tab,
        find: (id: string) -> ElementHandle?,
        notify: (spec: NotifySpec) -> NotifyHandle,
        isOpen: () -> boolean,
        onToggle: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
    },
    utility: {
        connect: (RBXScriptSignal, (...any) -> ()) -> (),
        getAsset: (string, string) -> any,
        getAssets: (string?) -> { [string]: any },
    },
    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: { Connect: (self: any, cb: (ShotEvent) -> ()) -> RBXScriptConnection },
        onTargetAcquired: { Connect: (self: any, cb: (TargetEvent) -> ()) -> RBXScriptConnection },
        onTargetLost: { Connect: (self: any, cb: (TargetEvent) -> ()) -> RBXScriptConnection },
        onTriggerArmed: { Connect: (self: any, cb: (TriggerEvent) -> ()) -> RBXScriptConnection },
        onTriggerDisarmed: { Connect: (self: any, cb: () -> ()) -> RBXScriptConnection },
        onScopeChanged: { Connect: (self: any, cb: (string) -> ()) -> RBXScriptConnection },
        onMagnetPull: { Connect: (self: any, cb: (MagnetEvent) -> ()) -> RBXScriptConnection },
    },
    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: { Connect: (self: any, cb: (RagebotShotEvent) -> ()) -> RBXScriptConnection },
        onTargetChanged: { Connect: (self: any, cb: (RagebotTargetEvent) -> ()) -> RBXScriptConnection },
    },
    client: {
        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?,
        getWeapon: () -> LoadoutEntry?,
        getWeaponName: () -> string?,
        getWeaponProperties: () -> any?,
        getInventory: () -> { LoadoutEntry },
        isBlind: () -> boolean,
        isFlashed: () -> boolean,
        getFlashVisibility: () -> number,
        isScoped: () -> boolean,
        isDefusing: () -> boolean,
        isClimbing: () -> boolean,
        hasC4: () -> boolean,
        getArmor: () -> ArmorState,
        hasArmor: () -> boolean,
        hasHelmet: () -> boolean,
        onCharacterAdded: { Connect: (self: any, cb: (Model) -> ()) -> RBXScriptConnection },
        onCharacterRemoving: { Connect: (self: any, cb: (Model) -> ()) -> RBXScriptConnection },
        onSpawn: { Connect: (self: any, cb: () -> ()) -> RBXScriptConnection },
        onDeath: { Connect: (self: any, cb: () -> ()) -> RBXScriptConnection },
        onWeaponChanged: { Connect: (self: any, cb: (LoadoutEntry?) -> ()) -> RBXScriptConnection },
        onTeamChanged: { Connect: (self: any, cb: (string?) -> ()) -> RBXScriptConnection },
        onHealthChanged: { Connect: (self: any, cb: (number, number) -> ()) -> RBXScriptConnection },
        onSpectatingChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onBlindChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onFlashVisibilityChanged: { Connect: (self: any, cb: (number) -> ()) -> RBXScriptConnection },
        onScopedChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onDefusingChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onC4Changed: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onArmorChanged: { Connect: (self: any, cb: (ArmorState) -> ()) -> RBXScriptConnection },
        isRescuingHostage: () -> boolean,
        isCarryingHostage: () -> boolean,
        getSpectatorCount: () -> number,
        isBeingSpectated: () -> boolean,
        getMoney: () -> number,
        getAmmo: () -> AmmoState?,
        onRescuingChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onCarryingChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onSpectatorCountChanged: { Connect: (self: any, cb: (number) -> ()) -> RBXScriptConnection },
        onMoneyChanged: { Connect: (self: any, cb: (number) -> ()) -> RBXScriptConnection },
        -- Rivals
        getEquipped: () -> EquippedItem?,
        getEnvironmentId: () -> string,
        isInDuel: () -> boolean,
        isCrouching: () -> boolean,
        isSliding: () -> boolean,
        isFirstPerson: () -> boolean,
        isFrozen: () -> boolean,
        isInvincible: () -> boolean,
        isHidden: () -> boolean,
        getVelocity: () -> Vector3,
        getAimCFrame: () -> CFrame,
        getControls: () -> string,
        getItems: () -> { string },
        getLevel: () -> number,
        getWinStreak: () -> number,
        getDisplayElo: () -> number,
        onEquippedChanged: { Connect: (self: any, cb: (EquippedItem?) -> ()) -> RBXScriptConnection },
        -- Apocalypse Rising 2
        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?,
        getLocalPlayer: () -> Player,
        onPlayerAdded: { Connect: (self: any, cb: (Player) -> ()) -> RBXScriptConnection },
        onPlayerRemoving: { Connect: (self: any, cb: (Player) -> ()) -> RBXScriptConnection },
        onCharacterAdded: { Connect: (self: any, cb: (Player, Model) -> ()) -> RBXScriptConnection },
        onCharacterRemoving: { Connect: (self: any, cb: (Player, Model) -> ()) -> RBXScriptConnection },
        onSpawn: { Connect: (self: any, cb: (Player) -> ()) -> RBXScriptConnection },
        onDeath: { Connect: (self: any, cb: (Player) -> ()) -> RBXScriptConnection },
        onTeamChanged: { Connect: (self: any, cb: (Player, string?) -> ()) -> RBXScriptConnection },
        onHealthChanged: { Connect: (self: any, cb: (Player, number, number) -> ()) -> RBXScriptConnection },
        onWeaponChanged: { Connect: (self: any, cb: (Player, any?) -> ()) -> RBXScriptConnection },
        onPlantingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onDefusingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onC4Changed: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onArmorChanged: { Connect: (self: any, cb: (Player, ArmorState) -> ()) -> RBXScriptConnection },
        onReloadingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onBlindChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onScopedChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onRescuingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onCarryingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onMoneyChanged: { Connect: (self: any, cb: (Player, number) -> ()) -> RBXScriptConnection },
        -- Rivals
        onEnvironmentChanged: { Connect: (self: any, cb: (Player, string) -> ()) -> RBXScriptConnection },
        onFrozenChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onInvincibleChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onDuelChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onBlockingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onDeflectingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        onHealingChanged: { Connect: (self: any, cb: (Player, boolean) -> ()) -> RBXScriptConnection },
        -- Apocalypse Rising 2
        onAmmoChanged: { Connect: (self: any, cb: (Player, number?, number?) -> ()) -> RBXScriptConnection },
    },
    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: { Connect: (self: any, cb: (BombState) -> ()) -> RBXScriptConnection },
        onBombDefused: { Connect: (self: any, cb: (BombState) -> ()) -> RBXScriptConnection },
        onBombExploded: { Connect: (self: any, cb: (BombState) -> ()) -> RBXScriptConnection },
        onBombCleared: { Connect: (self: any, cb: () -> ()) -> RBXScriptConnection },
        onPlantingStarted: { Connect: (self: any, cb: (PlantingState) -> ()) -> RBXScriptConnection },
        onPlantingEnded: { Connect: (self: any, cb: (PlantingState) -> ()) -> RBXScriptConnection },
        onHostageAdded: { Connect: (self: any, cb: (string, HostageState) -> ()) -> RBXScriptConnection },
        onHostageRemoved: { Connect: (self: any, cb: (string, HostageState) -> ()) -> RBXScriptConnection },
        onHostageChanged: { Connect: (self: any, cb: (string, HostageState) -> ()) -> RBXScriptConnection },
        getGamemode: () -> string?,
        getServerGamemode: () -> string?,
        isBombDefusal: () -> boolean,
        isHostageRescue: () -> boolean,
        isDeathmatch: () -> boolean,
        isCompetitive: () -> boolean,
        onGamemodeChanged: { Connect: (self: any, cb: (string?) -> ()) -> RBXScriptConnection },
        onServerGamemodeChanged: { Connect: (self: any, cb: (string?) -> ()) -> RBXScriptConnection },
        getDroppedItems: () -> { DroppedItem },
        getDroppedItem: (model: Model) -> DroppedItem?,
        onDroppedItemAdded: { Connect: (self: any, cb: (DroppedItem) -> ()) -> RBXScriptConnection },
        onDroppedItemRemoved: { Connect: (self: any, cb: (DroppedItem) -> ()) -> RBXScriptConnection },
        -- Rivals
        isInGame: () -> boolean,
        getTeamId: () -> string,
        getEnvironmentId: () -> string,
        getPlaceables: () -> { PlaceableEntry },
        getPlaceable: (id: string) -> PlaceableEntry?,
        onInGameChanged: { Connect: (self: any, cb: (boolean) -> ()) -> RBXScriptConnection },
        onTeamChanged: { Connect: (self: any, cb: (string) -> ()) -> RBXScriptConnection },
        onEnvironmentChanged: { Connect: (self: any, cb: (string) -> ()) -> RBXScriptConnection },
        onPlaceableAdded: { Connect: (self: any, cb: (string, PlaceableEntry) -> ()) -> RBXScriptConnection },
        onPlaceableRemoved: { Connect: (self: any, cb: (string, PlaceableEntry) -> ()) -> RBXScriptConnection },
        -- Apocalypse Rising 2
        ping: (position: Vector3) -> (),
        pingPlayer: (player: Player) -> (),
        clearPing: () -> (),
    },
    -- 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: { Connect: (self: any, cb: (AutoLootAction) -> ()) -> RBXScriptConnection },
    },
}

​UI types

​KeyMode

​GradientAnimation

​CurvePoint

​ListItem

​ColorSnapshot

​OverrideHandle

​ElementHandle

​ColorpickerHandle

​NotifySpec

​NotifyHandle

​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

​Players types

​PlayerHandle

​Game types

​BombState

​PlantingState

​HostageState

​DroppedItem

​PlaceableEntry

​Autoloot types

​AutoLootItem

​AutoLootAction

​AutoLootHandle

​Api