({ actions, availableActions, state }: MenuItemProps)

({ actions, availableActions, state }: MenuItemProps)

({ onCreate, position: { x, y }, size, update, ...props }: Omit<AnimationProps, 'sound'> & { onCre

({ building, buildingColor = 1, color, size = 'small', ...props }: { building: BuildingInfo; bui

(node)

(node)

({ addMap, campaign: data, editorComponent: MapEditor, exportMap, initialMapId, isAdmin, isValid

({ allowSuperHard, campaignEditorState, campaignExists, campaignName, description, difficulty, e

({ allowSuperHard, campaignExists, campaignName, description, difficulty, exportMaps, isAdmin,

({ actions, navigationDirection, }: { actions: Actions; navigationDirection: NavigationDirection | nul

({ actions, availableActions, state }: MenuItemProps)

({ actions: { update }, availableActions, state, type = 'capture', }: MenuItemProps & { type: 'capture

({ achieved, description, onComplete, type, }: { achieved: boolean; description?: ReactNode; onC

({ className, player, style, ...props }: HTMLAttributes<HTMLHeadingElement> & { player?: PlayerID })

({ className, player, style, ...props }: HTMLAttributes<HTMLHeadingElement> & { player?: PlayerID })

({ children }: { children: ReactNode })

( unit: UnitInfo | number, message: string, player: DynamicPlayerID, variant?: number, silhouette =

({ module }: { module: keyof typeof modules })

({ children }: { children: ReactElement })

({ type }: { type: PerformanceStyleType })

({ playerDetails, players, }: { playerDetails: PlayerDetails; players: PlayerIDs; })

({ biome, conjunction, id, isNext, next, removeTemplate, setConjunction, setNext, setTemplat

({ actions, icon, onAction, position, showComplete, state, }: StateWithActions & ConfirmProps)

({ effect }: { effect: number })

({ animationConfig, biome, maskRef, onCreate, player, playerDetails, scale, update, user,

({ crystal, onComplete, onConvert, scale, update, }: { crystal: Crystal; onComplete: () => void;

({ active, children, collapse, crystal, pageSize, }: { active?: boolean; children?: ReactNode;

({ activeCrystal, canAction, crystal, crystalMap, onAction, onClose, spectatorLink, }: { activ

({ active, animate, crystal, onClick, }: { active?: boolean; animate: boolean; crystal: Crystal;

({ animation, onDamage, position: { x, y }, size, update, ...props }: Omit<AnimationProps, 'sound'

({ editor, setEditorState, state, }: StateWithActions & { editor: EditorState; setEditorState: (setE

({ effect }: { effect: number })

({ effect }: { effect: number })

({ active, onClick, scale, tall, tileSize, }: { active?: boolean; onClick: () => void; scale:

({ map, player, type: performanceType, }: { map: MapData; player: PlayerID; type: PerformanceType;

({ children, onClose, size = 'medium', transformOrigin, }: { children: ReactNode; onClose: () => v

({ children, horizontalScroll, ...props }: Omit< ComponentProps<typeof ScrollContainerWithNavigation>,

({ children, disabled, end, highlight, isIcon, onClick, }: { children: ReactNode; disabled?: b

({ children }: { children: ReactNode })

({ onClose }: { onClose: () => void })

({ url: initialURL }: { url: string })

({ children, expand, inset = 0, mode, position = 'bottom', ref, sidebar, visible, }: Readonly<

({ actions, availableActions, state }: MenuItemProps)

({ children, className, closeOnSelect, dropdownClassName, flex1, forceOpen, shouldRenderControls

({ actions: { update }, currentPlayer, isAdmin, setEditorState, vertical, }: { actions: Actions;

({ id, objectives, }: { id: DynamicEffectObjectiveID; objectives?: Objectives; })

({ effects, objectives, scenario: { effect: currentEffect, trigger: currentTrigger }, setScenario, }:

({ editor, hasContentRestrictions, isAdmin, map, position, scenario, scrollRef, setEditorState

({ actions, canEndTurn, fade, state, subscribe, }: StateWithActions & { canEndTurn: boolean; fad

()

({ actions, editor, editorHistory, isAdmin, state, }: StateWithActions & Readonly<{ editorHist

({ animationConfig, biome, building, firstPlayerID, onSelectBuilding, onSelectUnit, playerDetail

({ error }: { error: unknown })

({ error }: { error: unknown })

({ editor, state, }: StateWithActions & { editor: EditorState; })

()

({ children, className, gap, isExpanded, style, toggleExpanded, ...props }: ComponentProps<typeo

({ biome, onExplode, position: { x, y }, size, style, update, ...props }: Omit<AnimationProps, '

({ accept = '.json,application/json', label, onDrop, onError, }: { accept?: string; label: ReactNo

({ delay, position: { x, y }, size, ...props }: Omit<AnimationProps, 'sound'> & { delay: number; p

({ align, animationConfig, clearTimer, delay, items, mini, onComplete, position, rate, sch

({ align, items: initialItems, mini, opaque, position, resetPosition, tileSize, width, zInde

({ center, children, color, disabled, highlight, icon, interactive = true, onClick, onPointe

({ children, highlight, icon, ...props }: Omit<FlyoutProps, 'icon' | 'onPointerEnter' | 'onPointerLeav

()

({ actions, availableActions, state }: MenuItemProps)

({ actions: { update }, availableActions, state }: MenuItemProps)

()

({ className, value, }: { className?: string; value: number | string; })

({ actions, canUndoAction = true, children, fade, hide, inset = 0, onDownloadReplay, setZoom,

({ index, state }: { index: number; state: State })

({ gameInfoState: { action, actionName, activeCrystal, canAction, charges, crystalMa

({ position: { x, y }, size, unitDirection, ...props }: Omit<AnimationProps, 'sound'> & { position:

({ actions: { update }, availableActions, state: { navigationDirection }, }: MenuItemProps)

({ color, types }: { color: BaseColor; types: ActiveUnitTypes })

({ hasStatus, hide, unit: { health }, }: { hasStatus: boolean; hide: boolean; unit: Unit; })

({ animationConfig, change, clearTimer, onComplete, position, previousHealth, scheduleTimer, t

()

({ histogram }: { histogram: string })

(props: Props)

(node)

(props: HTMLAttributes<HTMLDivElement> & StackProps)

({ actions: { showGameInfo }, bottom, fade, state: { gameInfoState }, }: StateWithActions & Readonly<{

({ onClick, ref, to, ...initialProps }: Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'onClick'> & Inl

({ biome, building, cycleUnitState, decorator, extraInfos, hasSprites, hideCursor, index, la

({ biome, buildings, children, cycleUnitState, decorators, extraInfos, gap = true, lazyDecorat

({ biome, isHighlighted, isSelected, tile, unit, ...props }: { biome: Biome; isHighlighted: bo

({ biome, customSprite, isHighlighted, isSelected, offset, tile, unit, }: { biome: Biome; is

(path: NodePath<JSXIdentifier>)

({ button, shortcut }: { button?: true; shortcut: string })

({ entity, hide }: { entity: Entity; hide: boolean })

({ active, isAdmin, onChange, }: { active?: PlayerID | null; isAdmin?: boolean; onChange: (label:

({ detail, disabled, entityCount, icon, label, navigationDirection, onClick, onLongPress: init

({ gender }: { gender: Gender })

({ onComplete }: { onComplete: () => void })

({ className, ...props }: Omit<ComponentProps<typeof MenuButton>, 'children'>)

({ active, children, isAdmin, onChange, }: { active?: PlayerIDSet; children?: ReactNode; isAdmin

({ actions: { clearTimer, requestFrame, scheduleTimer, scrollIntoView, update }, animation, animationCom

({ actions, animationComplete, getLayer, scale, skipBanners, state: { animationConfig, animations,

({ map }: { map: MapData })