(name: number | null)

(from: Vector)

( map: MapData, unit: Unit, start: Vector, optimize: 'cost' | 'cover', radius?: number, )

( map: MapData, gameActionResponse: EncodedGameActionResponse, viewers: string, )

( gameState: GameState, viewers: string | ReadonlyArray<string>, )

( map: MapData, initialActive?: ReadonlyArray<PlayerID>, )

(info: UnitInfo)

( list: ReadonlyArray<T>, extract: (entry: T) => number, min: number = 0, length: number = 5, )

(info: BuildingInfo)

({ movementType }: { movementType: MovementType })

( color: BaseColor | ReadonlyArray<BaseColor> | undefined, alpha = 0.9, direction = 'to bottom right', )

()

( shouldRecover: boolean, player: Player, unit: Unit | undefined, )

()

( direction: Direction, columns: number, index: number | null, list: ReadonlyArray<unknown>, [select

( type: T, fn: (event: CustomEvent<Events[T]>) => void, layer: InputLayer = 'base', )

(code: string)

(sprite: SpriteVariant, variant?: number, biome?: Biome)

( map: MapData, AIRegistry: { has: (ai: number) => boolean }, newTeams?: TeamsList, hasContentRestrict

(from: Vector, to: Vector)

(player: Player, skill: Skill)

(map: MapData, vector: Vector)

(unitInfo: UnitInfo, tile: TileInfo)

({ activeSkills, ai, charge, funds, id, misses, name, seen, skills, st

({ behaviors, completed, health, id, label, player, skills, }: { behaviors?:

( map: MapData, vector: Vector, radius: number, )

( map: MapData, vision: VisionT, units: ReadonlyArray<[Vector, Unit]>, labelsToPrioritize?: Set<Player

(type: AudioVolumeType)

( { processGameActionResponse, update }: Actions, remoteAction: Promise<GameActionResponse>, )

()

( map: MapData, player: Player, type: 'any' | 'with-attack', )

(index: number, width: number)

(inset: number | string)

(players: PlayerIDs | undefined, player: PlayerID)

()

(number: number)

(value: number)

(tile: MaybeTileID, modifier: number | null)

(name: SoundName | SongName, duration = 250)

(fn: T, interval: number)

(teams: Teams)

(game: ClientGame, type: UndoType)

()

( currentMap: MapData, vision: VisionT, { buildings, units, }: { buildings?: ImmutableMap<

(from: Vector)

(map: MapData, fromPlayer: Player, toPlayer: Player)

(event: CustomEvent)

()

()

( from: Vector, to: Vector, )

(entity: Readonly<{ type: EntityType }>)

( info: { animation?: TileAnimation | null }, modifier: number | null, tick: number, )

(unit: Unit, player: Player)

(map: MapData, position: Vector)

(skill: Skill)

(skill: Skill)

(crystal: Crystal)

( performanceType: PerformanceStyleType, )

(ability: Behavior)

(map: MapData, player: Player)

(unitInfo: UnitInfo)

()

(event: MouseEvent)

(ammo: Ammo | null)

(list: Iterable<[Vector, T]>)

(map: MapData)

()

(players: ReadonlyArray<PlainPlayer>)

(object: AnyEntity)

(block: InputLayer, condition: boolean | undefined = true)

( element: RefObject<HTMLElement | null>, scrollIntoView: boolean | undefined, )

(sound: SoundName)

(from: Vector)

(indices: Iterable<number>)

( animations: Animations, { endSound, from, onComplete, partial = false, path, pat

(state: State)

( unitA: Unit, entityB: Entity, map: MapData, from: Vector, to: Vector, attackStatusEffect: number

( previousMap: MapData, vision: VisionT, gameState: GameState, )

({ animation, biomeStyle, group, id, name, placeOn, position, }: { animation

(encodedEffects: EncodedEffects)

(effects: Effects)

(map: MapData, action: Action)

( actions: Actions, state: State, newMap: MapData, entity: Entity, position: Vector, direction: At

(map: MapData, player: PlayerID)

(number: number)

(effect: number)

()

(biome: Biome)

(biome: Biome)

( entity: Entity, player: Player, newEntity: Entity, modifier: number, )

( map: MapData, from: Vector, unit: Unit, )

( map: MapData, vector: Vector, info: TileInfo, layer: TileLayer, )

()

(index: number)

(firstPlayer: PlayerID, unit: Unit)

(gender: Gender, name: number)

( map: MapData, vector: Vector, info: TileInfo, layer: TileLayer, )

()

()

( map: MapData, currentViewer: Player | PlayerID | null, object?: AnyEntity, )