(map: MapData)

(map: MapData)

()

(entities: ImmutableMap<Vector, T>)

(route: string)

( actions: Actions, state: State, unitsToExplode: ReadonlyArray<Vector>, onComplete: StateToStateLike,

( map: MapData, unit: Unit, to: RadiusItem, moveableRadius: ReadonlyMap<Vector, RadiusItem>, radiusT

( fn: (vector: Vector, tile: TileInfo, layer: TileLayer, modifier: number, index: number) => void, )

(filePath: string, sourceText: string)

(filePath: string, sourceText: string)

()

()

( map: MapData, from: Vector, entityB: Entity | undefined, )

(id: number)

(vector: Vector, state: State)

( map: MapData, position: Vector, vision: VisionT, )

(attributes: string, name: string)

(campaign: Campaign<T>)

(player: Player)

( map: MapData, currentPlayer: Player, dirtyUnits: ReadonlySet<Vector>, )

(effects: Effects)

()

(skill: Skill)

(map: MapData, unit: Unit)

(objectives: Objectives)

( map: MapData, currentPlayer: Player, label: PlayerID | null, { canCreateBuildUnits, canCreateCapture

(mapName: string)

( user: UserLikeWithID, player: PlayerID | null, playerDetails: PlayerDetails, )

(modifier: ModifierField, layer: TileLayer)

( map: MapData, vision: VisionT, unit: Unit, vector: Vector, )

(objectives: Objectives, player: PlayerID)

( buildings: ReadonlyArray<Building>, currentPlayer: Player, )

( targets: ReadonlyArray<Vector>, radius: ReadonlyMap<Vector, RadiusItem>, adjacent = true, )

(props: ReadonlyArray<Prop>)

(keyframes: string)

(size: SizeVector)

(tag: string, colorCount = PlayerIDs.length - 1)

(unitInfosWithWeight: ReadonlyArray<UnitInfo>)

(skills: ReadonlySet<Skill>)

(map: MapData, player: PlayerID, info: UnitInfo)

( map: MapData, currentPlayer: Player, attackOption: PossibleAttack, )

(tile: MaybeTileID)

(vector: Vector, size: SizeVector)

({ current, next }: EndTurnActionResponse)

(vector: Vector)

(map: MapData, playerID: PlayerID)

()

()

(tile: TileInfo)

(vector: Vector)

(count: number, value: number)

(count: number, value: number)

(vector: Vector)

(maybePlayer: PlayerOrPlayerID)

(player: PlayerID | null | undefined, state: 'complete' | 'recover')

(min: number, max: number, value: number)

(timestamp: number)

(value: number)

(objectives: Objectives)

(map: MapData, player: PlayerID | Player)

(sound: SoundName, rate = 1)

(vector: Vector, offsetX: number, offsetY: number)

(n = 1)

(type: Rumble, duration?: number)

(behaviorClass: MapBehaviorConstructor)

(statusEffect: UnitStatusEffect | null)

(map: MapData, skill: Skill)

()

( map: MapData, opponentUnits: ReadonlyArray<[Vector, Unit]>, unitInfos: ReadonlyArray<UnitInfo>, curr

(vectors: Array<Vector>)

(sprite: SpriteVariant, variant: number)

(weapon: Weapon, amount = 1)

(x: number, y: number)

()

(text: string)

(bitSet: BitSet)

(campaign: Campaign<T>)

(n = 1)

( inputType: 'navigate' | 'navigateSecondary', callback: (direction: Direction) => void, )

(map: MapData, effects: Effects)

(action: Action, map: MapData)

()

(fn: () => Promise<T>)

(state: State)

( actions: Actions, state: State, remoteAction: Promise<GameActionResponse>, newMap: MapData, action

(entries: ReadonlyArray<TypeaheadDataSourceEntry<T>>)

( state: State, entity: Entity, position: Vector, direction: AttackDirection | undefined, onComplete

(player: PlayerID, unit: UnitInfo)

( state: State, poisonedUnits: UnitsWithPosition | Iterable<[Vector, Unit]>, onComplete: StateToStateLik

( map: MapData, actionResponses: ActionResponses, )

(map: MapData, player: PlayerOrPlayerID)

(state: State, stateLike: StateLike | null | undefined)

(unitState: UnitState, unit: Unit)

( { scheduleTimer, update }: Actions, state: State, options: Options, )

( { requestFrame, update }: Actions, actionResponse: BuySkillActionResponse | SkillRewardActionResponse, )

(path: string)

( unitA: Unit, entityB: Entity, weapon: Weapon, coverA: number, coverB: number, attackStatusEffect

( map: MapData, unit: Unit, start: Vector, radius: number, { getCost, getResourceValue,

(next: Level<string>)

(vector: Vector)