({ animationConfig, animations, attackable, behavior, className, extraUnits, fogStyle, getLaye

({ buttons, creator, gap = 16, hasSkills, isCampaign, isRanked, map, rating, showCampaign,

({ animationSpeed, autoPanning, campaignLock, children, confirmActionStyle, createMap, effects:

({ actions, campaignLock, drawerPosition, editor, editorHistory, estimateMapPerformance, expand,

()

({ drawingMode, mapSize, origin: orign, ...props }: { drawingMode: DrawingMode | undefined; mapSiz

({ actions, canEditPerformance, estimateMapPerformance, isAdmin, mapName, mapObject, resize, s

({ animationConfig, biome, currentUser, deleteMessage, maskRef, message, playerDetails, scale,

({ animationConfig, button, children, isValuable, maskRef, player, playerDetails, scale, scr

({ hasNext, isNext, message, punctuation, replacement, }: { hasNext: boolean; isNext?: boolean;

({ currentViewer, map, playerAchievement, }: { currentViewer: PlayerID | null; map: MapData; playe

({ legendaryAchievement, map, mapName, player, playerAchievement, scrollIntoView, }: { legendary

({ children }: { children: React.ReactNode })

({ player, zoom = 2 }: { player: PlayerID; zoom?: number })

({ children, controls, hide, }: { children?: ((close: () => void) => ReactNode) | null; controls?: (

({ children }: { children: ReactNode })

({ currentUser, currentViewer, hasUndo, highlight, onClick, playerDetails, }: { currentUser: Use

({ animationConfig, map, onComplete, player, playerDetails, position, silhouette, text, unit

({ biome, isFirst, onRemove, player, playerDetails, tag, value, }: { biome: Biome; isFirst:

({ isNext, setTemplate, }: { isNext?: boolean; setTemplate: (template: number) => void; })

({ hasNext = false, id, isNext = false, message, replacement, setTemplate, }: { hasNext?: boolea

({ gap, id }: { gap?: true; id: PlayerID })

({ animate, human, paused, player, portraitClip, user, }: { animate?: boolean; human?: true;

()

({ biome, cost, size, tiles, unitGroups, units, }: { biome: Biome; cost: number; size?: 'tal

({ movementType, size = 'small', ...props }: { movementType: MovementType; } & InlineTagProps)

({ movementTypes, size = 'small', ...props }: { movementTypes: ReadonlyArray<MovementType>; } & Inline

({ movement }: { movement: ReadonlyMap<MovementType, number> })

({ effects, type, }: { effects: ReadonlyMap<MovementType, number>; type: 'attack' | 'defense'; })

({ children }: { children: ReactNode })

({ animationConfig, currentViewer, map, playerDetails, tileSize, unit, vector, zIndex, }: {

({ hasNewAppVersion, hasNewVersion, reload, }: { hasNewAppVersion: boolean; hasNewVersion: boolean;

({ actions, fade, playerCanEndTurn, state, }: StateWithActions & { fade?: boolean; playerCanEndTurn: b

( props: Omit<NoticeAnimation, 'animationConfig' | 'onComplete' | 'type'> & BaseAnimationProps, )

({ center, children, delay = 0, inline, inset = 0, offset = 0, position = 'bottom', size, }: {

( props: Omit<InputHTMLAttributes<HTMLInputElement>, 'inputMode' | 'pattern' | 'type'> & { invalid?: boo

({ campaigns, canDelete, canEditPerformance, hasContentRestrictions, id, isAdmin, map, objecti

({ objective, playerDetails, round, }: { objective: Objective; playerDetails: PlayerDetails; round

({ actions, campaignEdges, canEditPerformance, editor, hasContentRestrictions, isAdmin, mapId,

({ objective, playerDetails, }: { objective: Objective; playerDetails: PlayerDetails; })

({ id, objective, short, }: { id?: ObjectiveID; objective: Objective; short?: true; })

({ achievement: { legendary, result, stars }, }: { achievement: PlayerAchievementT; })

({ id, map, objective, player, }: { id: number; map: MapData; objective: Objective; player: Pl

({ button, className, cursorStyle, id, inline, onClick, scale = 1, selected, }: { button?: t

({ container, id, navigate: [left, right], onDrag, onDrop, onEnter, onLeave, selected, }: {

({ aiRegistry, allowDefaultAI, availableSkills, blocklistedSkills, favoriteSkills, hasSkills, is

({ conjunction = 'or', playerDetails, players, }: { conjunction?: 'and' | 'or'; playerDetails: Playe

({ color, confirm, hasPlayer, }: { color: Color; confirm?: boolean; hasPlayer?: boolean; })

({ activePlayer, aiRegistry, allowDefaultAI, availableSkills, children, favoriteSkills, hasSkill

({ availableSkills, blocklistedSkills, disabledSkillSlots, favorites, focusedSlot, isFocused, on

()

({ map, metadata, }: { map: MapData; metadata?: MapMetadata; })

({ children, container = defaultContainer, }: { children: ReactNode; container?: HTMLElement; })

({ color, onSelect, selected, unit, variant, }: { color: PlayerID; onSelect: (character: Charact

()

({ animationConfig, map, tileSize, vector, zIndex, }: { animationConfig: AnimationConfig; map: M

({ className, inset, size, wideOnNarrowScreen, ...props }: ComponentProps<typeof ExpandableMenuButto

({ reload = _reload }: { reload?: () => void })

({ actions, currentPlayer, currentViewer, inlineUI, replayState, timeout, timer, }: { actions:

({ fade, onClick }: { fade?: boolean; onClick: () => void })

({ animationSpeed: initialAnimationSpeed, autoPanning, confirmActionStyle: initialConfirmActionStyle,

({ currentIndex, gameState, hasState, max, playState, setCurrentIndex, setPlayState, }: { curr

({ onRescue, position: { x, y }, size, unitDirection, update, ...props }: Omit<AnimationProps, 'so

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

({ isVisible, onResize, size, zIndex, }: { isVisible: boolean; onResize: (size: SizeVector, origin

({ actions: { update }, editor, hasContentRestrictions, setEditorState, state, user, }: StateWithA

({ player, reward }: { player: PlayerID; reward: Reward })

({ results }: { results: ReadonlyArray<Result> })

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

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

({ children, className, ref, }: { children: ReactNode; className?: string; ref?: RefCallback<HTMLE

({ children, className, navigate, scrollContainerClassName, scrollDownClassName, }: { children: Re

({ animation, animationComplete, position, positions, scrollIntoView, }: { animation: Animation;

({ children }: { children: ReactNode })

({ children, dropdownClassName, forceOpen, outline, selectedItem, size = 'medium', }: { children

({ actions, onSelectBuilding, onSelectUnit, state, }: { actions: Actions; onSelectBuilding: (posit

({ active, color, onClick, }: { active: boolean; color: PlayerID; onClick: () => void; })

({ isAdmin, setMap, state, }: { isAdmin: boolean | undefined; setMap: SetMapFunction; state: State

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

({ className, hide, unit: { shield }, }: { className: string; hide: boolean; unit: Unit; })

({ editor, expand, mapObject, position, previousState, resetMap, restorePreviousState, setEdit

({ actionName, allowTouch, availableSkills: initialAvailableSkills, blocklistedAreDisabled, blocklis

({ actionName, allowTouch, availableSkills, blocklistedAreDisabled, blocklistedSkills, canAction,

({ active, canActivate, dialogSize, disabled, favorites, hideDialog, showName, skill, toggle

({ active, background, borderStyle, button, canActivate, color, disabled, icon, isFocused,

({ allowTouch, blocklistedSkills, currentSkill, isFavorite, onSelect, selected, showCost, skil

({ availableSkills, blocklistedAreDisabled: blocklistedAreUnavailable, blocklistedSkills, currentSkill

({ color, skill }: { color: BaseColor; skill: Skill })

()

({ onSpawn, position: { x, y }, size, type, unitDirection, update, ...props }: Omit<AnimationPro

({ component: Component = Stack, }: { component?: typeof Stack | typeof Box; })

({ className, size, starClassName, type, }: { className?: string; size?: 'small' | 'medium' | 'lar

({ hide, unit: { statusEffect } }: { hide: boolean; unit: Unit })

({ instant, legendaryAchievement, onComplete, result, }: { instant: boolean; legendaryAchievement?

({ actions, availableActions, state }: MenuItemProps)

(path: NodePath<TSTypeAliasDeclaration>)

({ active, capitalize, className, color, isMessage, onClick, onRemove, selected, size = 'med

({ dataSource, emptySuggestions, freeform, setTags, stringify = String, tags, toValue = stringif

({ className, stringify = String, ...props }: Omit<TagListProps<T>, 'stringify'> & { stringify?: (tag: T

({ className, editable, setTags, stringify, tags, }: TagListProps<T>)