(value: unknown)

(biome: Biome)

(fn: (unitInfo: UnitInfo, index: number) => T)

( types: ActiveUnitTypes | undefined, unit: Unit, vector: Vector | null, )

(t: TileInfo)

(t: TileInfo)

(unit: Unit)

( objective: Objective, )

(button?: ButtonResult)

( fn: (value: T, decorator: DecoratorInfo, vector: Vector) => T, value: T, )

()

(unit: Unit)

( scheduleTimer: TimerFunction, { AnimationDuration, Instant }: AnimationConfig, duration: 'short' | 'lo

( actions: Actions, state: State, unitsToSpawn: ReadonlyArray<readonly [Vector, Unit]>, teams: Teams |

( undoContext: RefObject<EditorHistory>, entry: UndoEntry, )

(query: string)

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

(type: 'portraits' | 'all')

(map: MapData, players: PlayerIDs)

(from: Vector, skill: Skill)

(map: MapData)

( actions: Actions, actionResponse: EndTurnActionResponse, state: State, maybeExtraPositions: Promise<

(name: T)

( map: MapData, vision: VisionT, actionResponse: HiddenActionResponse, )

({ update }: Actions, { attackable, selectedPosition }: State)

( state: Pick<State, 'currentViewer' | 'map'>, item: PlayerEffectItem, target: Vector | null, { allowM

(map: MapData, maybeTransporter: Unit, unitA: Unit, vector: Vector)

(error: unknown)

( map: MapData, id: PlayerID, )

(clearTimer: ClearTimerFunction)

(value: AttributeRange)

(map: MapData, biome: Biome)

( response: EncodedGameActionResponseWithError, detail?: unknown, )

( clientMap: MapData, initialMap: MapData, vision: VisionT, gameState: GameState | null, timeout: Da

( object: T, )

()

( size: SizeVector, fill?: ReadonlyArray<TileInfo> | null, )

(map: MapData, playerID: PlayerID)

()

(building: BuildingInfo)

(keyframes: string)

(id: number)

( player: Player, animationSpeed: AnimationSpeed | undefined, )

(vector: Vector, size: SizeVector)

(isAdmin?: boolean)

(health: number)

(name: SongName | SoundName)

( map: MapData, unit: Unit, origin: Vector, target: RadiusItem | undefined, fields: ReadonlyMap<Vect

( map: MapData, unit: Unit, start: Vector, path: ReadonlyArray<Vector>, radius: number = unit.info.g

(id: string)

(unitInfos: ReadonlyArray<UnitInfo>)

(biome: Biome)

(value: number, boundary: number)

(map: MapData, player: PlayerID)

(map: MapData, player: PlayerID | Player)

( info: UnitInfo, weaponId: number, currentSupply: number, )

(animations: Animations)

(biome: Biome, displayOnly = false)

()

(id: number | string)

(fn: (vector: Vector, index: number) => T)

(hide?: boolean)

( vector: Vector, { height, width }: SizeVector, mirrorType: Extract<DrawingMode, 'horizontal' | 'vertic

( objective: Objective, )

(target: EventTarget | null)

(temporary?: boolean)

(song: SongName)

()

( context: CanvasRenderingContext2D, tileset: TileSet, map: MapData, vision: VisionT, frame: number,

(rescuing: PlayerID)

( effects: Effects, previousSize: SizeVector, size: SizeVector, origin: Set<ResizeOrigin>, )

( map: MapData, size: SizeVector, origin: Set<ResizeOrigin>, fill?: number, )

( vector: Vector, state: State, actions: Actions, editor?: unknown, subVector?: unknown,

(unit: Unit)

(unit: Unit)

(unit: Unit)

(value: AttributeRangeWithZero)

(isActive: boolean | undefined, click?: () => void, to?: Route)

( initialCount: number, layer: InputLayer = 'menu', nowrap = false, initial = -1, )

( options: Omit<LongPressOptions, 'onCancel' | 'onStart' | 'threshold'> & { onLongPress: NonNullable<Par

( map: MapData, teams: TeamsList, )

(name: string)

(from: Vector)

( actions: Actions, state: State, item: PlayerEffectItem, target: Vector | null, )

()

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

( previousMap: MapData, activeMap: MapData, effects: Effects, actionResponse: ActionResponse, )

( map: MapData, actionResponse: ObjectiveActionResponse, )

(spawnAction: SpawnActionResponse)

( map: MapData, units: ImmutableMap<Vector, Unit>, )

( { update }: Actions, state: State, { attackStance, damage, directions: [direction, opposit

( map: MapData, vector: Vector, decorator: number, _getDecoratorLimit = getDecoratorLimit, )

( previousMap: MapData, map: MapData, actionResponse: ActionResponse, )

()

(state: State)

(mapData: MapData, map: TileMap)

(player: Player)

(actions: Actions | null)

(units: PlainEntitiesList<PlainUnit>)

(n = 1)