( actions: Actions, actionResponse: ActionResponse, position: Vector, type: FoldType, state: State,

( game: ClientGame | null, setGame: (game: ClientGame) => void, onGameAction?: | (( gameStat

( selector = ':scope > :first-child > div', )

( states: ReadonlyArray<T> | undefined, currentState: number, setPanel: (panel: T) => void, )

({ active, // Do not pass `active` to the link element. alignCenter, className: initialClassName, disa

(performance: PlayerPerformance | null)

(dep?: unknown)

({ animationConfig, onComplete, scheduleTimer, }: { animationConfig: AnimationConfig; onComplete: ()

(amount: number)

(label: PlayerIDSet)

(map: MapData, vectors: Set<Vector>)

()

(crystal: Crystal)

( map: MapData, unitA: Unit, unitB: Unit, weapon: Weapon, vectorA: Vector, vectorB: Vector, modi

( map: MapData, unitA: Unit, unitB: Unit, vA: Vector, vB: Vector, previousHealth = unitB.health, )

( spriteVariants: ReadonlyMap<SpriteVariant, SpriteVariantConfiguration>, canvasToURL: CanvasToURLFn, is

()

( actions: Actions, actionResponse: ActivateCrystalActionResponse, )

( actions: Actions, state: State, actionResponse: ActivatePowerActionResponse, )

( newMap: MapData, from: Vector | undefined | null, position: Vector, state: State, onComplete: Stat

( newMap: MapData, position: Vector, state: State, onComplete: StateToStateLike = (state) => state, )

(additionalUnitInfos: ReadonlyArray<UnitInfo>)

(additionalUnitInfos: ReadonlyArray<UnitInfo>)

( state: State, unitsToHeal: Iterable<[Vector, HealEntry]>, onComplete: StateToStateLike = (state) => st

( currentMap: MapData, effects: Effects, lastActionResponse: ActionResponse, )

( map: MapData, actionResponse: ActivateCrystalActionResponse, )

(index: number)

(map: MapData)

( vector: Vector, state: State, actions: Actions, shouldConfirm?: boolean, )

(bot: Bot)

(map: MapData)

(map: MapData, unit: UnitInfo, to: Vector, tile: TileInfo)

(entity: Entity)

( map: MapData, origin: Vector, candidate: Vector | null | undefined, field: RadiusItem | undefined,

(player: Player)

(tile?: TileInfo | null)

(map: MapData, position: Vector, type: 'fold' | 'unfold')

(unitInfo: UnitInfo)

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

(map: MapData, vector: Vector, modifier: Modifier)

(map: MapData, vector: Vector)

(info: UnitInfo)

(info: UnitInfo)

( actions: Actions, remoteAction: Promise<GameActionResponse>, newMap: MapData, actionResponse: Action

(map: MapData, player: PlayerID)

(value: number)

( actions: Actions, state: State, actionResponse: ActivatePowerActionResponse, )

( actions: Actions, remoteAction: Promise<GameActionResponse>, newMap: MapData, actionResponse: Action

(context: CanvasRenderingContext2D, size: number, map: MapData)

()

({ optimisticAction, update }: Actions, state: State)

( actionResponse: EndTurnActionResponse, map: MapData, activeMap: MapData, vision: VisionT, )

(biome: Biome, player: PlayerID)

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

({ active, buildings, config, currentPlayer, decorators, map, modifiers, round

({ activeSkills, ai, charge, crystal, funds, id, misses, seen, skills,

( { update }: Actions, actionResponse: CreateTracksActionResponse, )

( actions: Actions, remoteAction: Promise<GameActionResponse>, newMap: MapData, actionResponse: Action

( list: PlainEntitiesList<S>, entityCreator: (entity: S) => T, )

(objective: PlainObjective)

(objectives: PlainObjectives)

(stats: PlainPlayerStatistics | null)

(teams: ReadonlyArray<PlainTeam>)

(array: ReadonlyArray<number>)

(map: MapData, fromPlayer: Player)

(map: MapData, player: PlayerID)

(n = 1)

( canvas: HTMLCanvasElement, map: MapData, offset: number, size: number, vision: VisionT, scale: n

(canvas: HTMLCanvasElement, cache: MistCache | null, size: number, phase = 0)

(unit: TransportedUnit)

(path: Array<Vector>)

( actionResponse: ActionResponse, labels: PlayerIDSet | null, )

(id: DynamicPlayerID)

(entities: ImmutableMap<Vector, Entity>)

( actionResponse: ActionResponse, vision: VisionT, previousMap: MapData | undefined, currentMap: MapDa

(objectives: Objectives)

( stats: PlayerStatistics | null, )

(vectors: ReadonlyArray<Vector>)

(map: MapData)

()

(a: Entity | undefined, b: Entity)

( map: MapData, player: PlayerID, vectors: ReadonlySet<Vector>, label: PlayerIDSet | undefined, )

( map: MapData, playerId: PlayerID, achievedBonusObjective = achievedOneBonusObjective(map, playerId), )

( activeMap: MapData | null, AIRegistry: AIRegistryT, effects: Effects, gameState: GameState = [], )

( map: MapData, vision: VisionT, action: Action, mutateAction: MutateActionResponseFn | undefined, i

(files: Array<string>)

( map: MapData, hasContentRestrictions: boolean, skills: ReadonlySet<Skill> | undefined, )

( initialMap: ReadonlyMap<K, V>, fn: (item: V, key: K) => T | null, )

( initialMap: ReadonlyMap<K, V>, fn: (item: V, key: K) => T | null, )

( initialMap: ReadonlyMap<K, V>, fn: (item: V, key: K) => T | null, )

( initialMap: ReadonlyMap<K, V>, fn: (item: V, key: K) => T | null, )

( activeMap: MapData, vision: VisionT, actionResponse: SpawnActionResponse | ActivatePowerActionResponse

(fn: (tile: TileInfo) => unknown)

(type: 'unfold' | 'fold', unitState: UnitState, unfoldSprite: UnitAnimationSprite)

(fn: (decorator: DecoratorInfo, vector: Vector) => void)

({ name: actionName, props }: ExtractedType)

(value: string, name: string)

( text: string, unit: UnitInfo, name: 'name' | 'characterName', map: MapData, player: PlayerID, pl

( shortActionName: string, { name, optional, value }: Prop, prefix?: string, )

( text: string, unit: UnitInfo, name: 'name' | 'characterName', extra?: ReadonlyArray<readonly [string