import { Control } from 'react-hook-form';
import { CSSProperties } from 'react';
import { default as default_2 } from 'react';
import { FC } from 'react';
import { FieldPath } from 'react-hook-form';
import { FieldValues } from 'react-hook-form';
import { JSX as JSX_2 } from 'react/jsx-runtime';
import { NamedExoticComponent } from 'react';
import { ReactNode } from 'react';
import { UseFormReturn } from 'react-hook-form';

export declare const Accordion: default_2.FC<AccordionProps>;

declare interface AccordionBaseProps {
    className?: string;
    children?: default_2.ReactNode;
    /**
     * Visual style. `default` is the flat list row (arrow leading, row dividers,
     * hover background). `sunken` draws the section as a sunken card (dimmed
     * rounded container, arrow pinned right, no dividers/hover) — used for stacked
     * detail sections in side panels and detail pages (see `CollapsibleSection`).
     */
    variant?: 'default' | 'sunken';
    /**
     * Content pinned to the right of the header, OUTSIDE the toggle button — so it may
     * be interactive (e.g. a Checkbox) without nesting a button inside a button.
     */
    trailing?: default_2.ReactNode;
    defaultExpanded?: boolean;
    isExpanded?: boolean;
    onToggle?: (expanded: boolean) => void;
    /** Disables the toggle (and its hover). Trailing controls manage their own state. */
    disabled?: boolean;
    /**
     * Pin the header row to the top of the nearest scroll container so it stays
     * reachable while the body scrolls. Needs a scroll ancestor that clips without
     * trapping sticky — e.g. a `<Surface overflow="clip">` (`overflow: hidden` traps it).
     */
    stickyHeader?: boolean;
    /** Offset (px) from the top of the scroll container when `stickyHeader` is set. */
    stickyTopOffset?: number;
    /**
     * Animate the expand/collapse height (default `true`). Set `false` for an instant
     * open — the body isn't clipped, so a `position: sticky` child pins immediately with
     * no post-animation settle.
     */
    animate?: boolean;
}

/**
 * Requires at least one of `title` (simple text header) or `header` (rich ReactNode
 * content for the toggle area, e.g. avatar + badges) so the toggle is never empty.
 */
export declare type AccordionProps = AccordionBaseProps & ({
    title: string;
    header?: default_2.ReactNode;
} | {
    title?: string;
    header: default_2.ReactNode;
});

export declare const AccountIcon: React.FC<IconProps>;

export declare const AccountsIcon: React.FC<IconProps_2>;

export declare const ActionBar: default_2.FC<ActionBarProps>;

export declare interface ActionBarItem {
    label: string;
    onClick?: () => void;
    disabled?: boolean;
    icon?: default_2.ReactNode;
    tooltip?: string;
    variant?: BaseButtonProps['variant'];
    size?: BaseButtonProps['size'];
    radius?: BaseButtonProps['radius'];
    /** Renders a vertical rule before this button (and a menu divider when collapsed). */
    dividerBefore?: boolean;
}

export declare interface ActionBarProps {
    buttons: ActionBarItem[];
    /** Container width, in px, below which the row collapses into a single menu. */
    collapseBelow?: number;
    /** Accessible name for the collapsed menu trigger. */
    menuLabel?: string;
    className?: string;
}

/**
 * ActionMenu is a kebab-style overflow action menu. The trigger is a square
 * icon-only outline Button (three-dot icon by default); on click, a popover
 * appears with the given items. The popover is rendered to document.body via
 * createPortal so it escapes any Shadow DOM or overflow:hidden ancestors —
 * which is also why the popover is styled inline rather than with Tailwind:
 * the scoped stylesheet does not reach document.body.
 */
export declare const ActionMenu: default_2.FC<ActionMenuProps>;

export declare type ActionMenuItem = {
    type?: 'item';
    key: string;
    label: default_2.ReactNode;
    onClick?: () => void;
    disabled?: boolean;
    danger?: boolean;
    tooltip?: string;
    icon?: default_2.ReactNode;
} | {
    type: 'divider';
    key: string;
};

export declare interface ActionMenuProps {
    items: ActionMenuItem[];
    label?: string;
    triggerIcon?: default_2.ReactNode;
    minWidth?: number;
    size?: 'small' | 'xsmall';
    /**
     * Shows `label` beside the icon instead of leaving it to the accessible name. For a menu
     * that is the point of its corner rather than an overflow for a row that already reads —
     * a kebab nobody can name is only safe when the row it belongs to says what it acts on.
     */
    showLabel?: boolean;
    /** Trigger's Button variant. Defaults to `outline`, the overflow-kebab look. */
    variant?: ButtonVariant;
}

export declare const AddIcon: React.FC<IconProps_3>;

export declare const AdvancedLogsIcon: React.FC<IconProps_4>;

export declare const Alert: default_2.FC<AlertProps>;

declare interface AlertProps {
    type?: AlertType;
    message: string;
    hasMargin?: boolean;
    className?: string;
    children?: default_2.ReactNode;
    isExpanded?: boolean;
    onToggle?: (expanded: boolean) => void;
}

export declare type AlertType = 'info' | 'success' | 'error' | 'warning' | 'assistant';

export declare const ApiKeysIcon: React.FC<IconProps_5>;

export declare const AppLogo: default_2.FC<AppLogoProps>;

export declare interface AppLogoProps {
    /** Connector logo URL. Falls back to a coloured initial tile when missing or broken. */
    src?: string;
    /** Connector name — the accessible label, the fallback initial, and the visible text. */
    name: string;
    /** Renders the name beside the mark. Omit for a bare logo (e.g. inside a dense row). */
    showName?: boolean;
    /** Pixel size of the square mark. */
    size?: number;
    nameSize?: FontSize;
    /** Defaults to `normal`. Raise it when the logo doubles as a page title. */
    nameWeight?: FontWeight;
    /** Rendered as a tag after the name, e.g. `v1.2.0` or `Legacy`. */
    version?: string;
    /** Truncates a long name with an ellipsis and reveals the full value on hover. */
    truncate?: boolean;
    className?: string;
}

/**
 * Apply a custom theme while preserving the current theme mode (light/dark)
 */
export declare function applyCustomTheme(customTheme: PartialMalachiteTheme): void;

/**
 * Apply the dark theme
 */
export declare function applyDarkTheme(): void;

/**
 * Apply the default (light) theme
 */
export declare function applyLightTheme(): void;

/**
 * Apply a custom theme to Malachite components
 * This function sets CSS custom properties that will be used by all Malachite components
 * Works with Shadow DOM isolation by applying to all registered shadow roots
 */
export declare function applyTheme(theme: PartialMalachiteTheme): void;

/** Scope the active theme (base mode + any persisted custom overrides) to one element/root, without changing global mode. Used by <ThemeScope>. */
export declare function applyThemeVars(target: HTMLElement | ShadowRoot, mode: ThemeMode): void;

export declare const ArchiveIcon: React.FC<IconProps_6>;

export declare const ArrowLeftIcon: React.FC<IconProps_7>;

export declare const ArrowUpIcon: React.FC<IconProps_8>;

export declare const ArrowUpRightIcon: React.FC<IconProps_9>;

export declare const AuthenticationIcon: React.FC<IconProps_10>;

/**
 * A logo/initial avatar. Renders `src` when available, otherwise a coloured tile
 * with the first letter of `name`. Encapsulates the fallback colour so consumers
 * never hand-roll it.
 */
export declare const Avatar: default_2.FC<AvatarProps>;

export declare interface AvatarProps {
    /** Image URL (logo/photo). Falls back to the initial of `name` when missing or it fails to load. */
    src?: string;
    /** Used for the initial fallback and as the image alt / accessible label. */
    name?: string;
    /** Pixel size of the (square) avatar. */
    size?: number;
    shape?: AvatarShape;
    className?: string;
}

export declare type AvatarShape = 'square' | 'circle';

declare type BaseButtonProps = default_2.ComponentProps<typeof Button>;

export declare const BaseFormComponent: default_2.FC<BaseFormComponentProps>;

declare interface BaseFormComponentProps {
    label?: string;
    description?: string;
    hint?: string;
    rightSideContent?: RightSideContent;
    tooltip?: string;
    required?: boolean;
    requiredIndicator?: RequiredIndicator;
    name: FieldPath<FieldValues>;
    defaultValue?: string;
    loading?: boolean;
    formControl?: Control<FieldValues, unknown>;
    loadingComponent: default_2.ReactNode;
    children?: FormItemChildren;
    /** Accessibility wiring, from `useFormFieldIds` — see `FormFieldIds`. */
    controlId?: string;
    labelId?: string;
    descriptionId?: string;
    hintId?: string;
    fullWidth?: boolean;
}

declare interface BaseSkeletonProps {
    active?: boolean;
    className?: string;
}

export declare const BellIcon: React.FC<IconProps_11>;

export declare const BellSlashIcon: React.FC<IconProps_12>;

export declare const BiDirectionalArrowsIcon: React.FC<IconProps_13>;

export declare interface BreadcrumbLink {
    name: default_2.ReactNode;
    url?: string;
    isRoot?: boolean;
}

export declare const Breadcrumbs: default_2.FC<BreadcrumbsProps>;

export declare interface BreadcrumbsProps {
    links: BreadcrumbLink[];
    actions?: PageAction[];
    renderLink?: RenderBreadcrumbLink;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const buildActionBarMenuItems: (buttons: ActionBarItem[]) => ActionMenuItem[];

export declare const Button: default_2.ForwardRefExoticComponent<ButtonProps & default_2.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;

declare interface ButtonDefinition {
    label: string;
    onClick?: (e?: default_2.MouseEvent<HTMLElement, MouseEvent>) => Promise<void> | void;
    disabled?: boolean;
    danger?: boolean;
    icon?: default_2.ReactNode;
    tooltip?: string;
    variant?: ButtonVariant;
    size?: ButtonSize;
}

declare interface ButtonDefinition_2 {
    label: string;
    onClick?: (e?: default_2.MouseEvent<HTMLElement, MouseEvent>) => Promise<void> | void;
    disabled?: boolean;
    danger?: boolean;
    icon?: default_2.ReactNode;
    tooltip?: string;
}

export declare const ButtonList: default_2.FC<ButtonListProps>;

declare interface ButtonListProps {
    buttons: Array<{
        key: string;
        children: ReactNode;
        onClick?: (event: default_2.MouseEvent) => void;
        /** When set, the item renders as an anchor so it can be opened in a new tab. */
        href?: string;
    }>;
    className?: string;
    /** Renders shorter, denser rows. */
    compact?: boolean;
}

declare interface ButtonProps extends default_2.ButtonHTMLAttributes<HTMLButtonElement> {
    variant: ButtonVariant;
    size?: ButtonSize;
    radius?: ButtonRadius;
    loading?: boolean;
    disabled?: boolean;
    icon?: default_2.ReactNode;
    iconPosition?: 'start' | 'end';
    flexGrow?: boolean;
    fill?: boolean;
    tooltip?: string;
    tooltipPlacement?: 'top' | 'bottom' | 'left' | 'right';
    iconOnly?: boolean;
    children?: default_2.ReactNode;
    onClick?: default_2.MouseEventHandler<HTMLButtonElement & HTMLAnchorElement>;
    /** Renders the button as a real anchor, so a link action is never an <a> nested in a <button>. */
    href?: string;
    target?: default_2.HTMLAttributeAnchorTarget;
    rel?: string;
}

export declare type ButtonRadius = 'md' | 'lg' | 'xl';

export declare type ButtonSize = 'xsmall' | 'small' | 'medium' | 'large';

export declare type ButtonVariant = 'filled' | 'outline'
/**
* `outline`'s geometry on a ground of its own. For a button sitting on a tinted or
* patterned surface, where `outline`'s transparent background lets that surface through
* and the control stops reading as a button.
*/
| 'surface'
/**
* The violet the assistant is named in elsewhere — for a control that hands work to it, or
* acts on what it produced. Provenance, not a severity: it says who is being asked, not
* that anything is wrong.
*/
| 'assistant' | 'destructive' | 'success' | 'warning' | 'error' | 'ghost' | 'no-style';

export declare const Card: default_2.FC<CardProps>;

export declare const CardIcon: React.FC<IconProps_14>;

declare interface CardProps {
    title?: string | default_2.ReactNode;
    padding?: string;
    children?: default_2.ReactNode;
    size?: 'default' | 'small';
    width?: string;
    minWidth?: string;
    direction?: 'row' | 'column';
    align?: 'center';
    dimmed?: boolean;
    fullHeight?: boolean;
    border?: 'base' | 'rounded';
    alignSelf?: 'center';
    height?: string;
    footer?: default_2.ReactNode;
    glassFooter?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
    headerConfig?: {
        padding?: string;
    };
}

/** A horizontally scrolling radiogroup of cards — the "pick one of these" strip. */
export declare const CardStrip: default_2.FC<CardStripProps> & {
    AddTile: default_2.FC<CardStripAddTileProps>;
};

export declare type CardStripAddTileEmphasis = 'primary' | 'secondary';

export declare interface CardStripAddTileProps {
    /** Visible label, e.g. "Add Profile". Also names the button for assistive tech. */
    label: string;
    /** Defaults to a plus. */
    icon?: default_2.ReactNode;
    onClick: () => void;
    disabled?: boolean;
    /** Leave unset: CardStrip picks `primary` while the strip is empty and `secondary` once cards exist. */
    emphasis?: CardStripAddTileEmphasis;
    className?: string;
}

export declare interface CardStripProps {
    /** The selected card's value, matched against each radio child's `data-value`. */
    value: string;
    /** Overrides the palette the strip reads off the selected card. See `CardStripTone`. */
    tone?: CardStripTone;
    onChange: (value: string) => void;
    /** Cards. Any element with `role="radio"` and a `data-value` joins the group; an
     *  add tile must be a direct child or it scrolls with the cards. */
    children: default_2.ReactNode;
    /** Pinned, non-scrolling slot before the cards (the Library card in the profile picker). */
    leading?: default_2.ReactNode;
    /** Circular scroll affordances, shown only on an edge that can actually scroll. */
    arrows?: boolean;
    /** Fade the cards out at any edge they scroll past. */
    fadeEdges?: boolean;
    /** Snap cards to the leading edge as the strip scrolls. */
    snap?: boolean;
    /** Run the bottom rule the full width of the page card while the cards stay on the gutter.
     *  Only has an effect inside a layout that publishes its inset (`PageLayout`). */
    bleed?: boolean;
    /** Whether a selection change scrolls the selected card into view. The strip's opening
     *  selection is placed instantly; later ones slide, unless motion is reduced. Set `false`
     *  when the value comes from a URL, or a deep-linked strip below the fold jumps the page
     *  on load. */
    scrollSelectedIntoView?: boolean;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/** Palette for the strip's rule. Pass the tone of whatever card is selected. */
export declare type CardStripTone = 'profile' | 'library' | 'editing';

export declare const CaretDownIcon: React.FC<IconProps_15>;

export declare const CaretLeftIcon: React.FC<IconProps_16>;

export declare const CaretRightIcon: React.FC<IconProps_17>;

export declare const CaretUpIcon: React.FC<IconProps_18>;

export declare type ChangeKind = 'changed' | 'added' | 'removed';

export declare const ChangePasswordIcon: React.FC<IconProps_19>;

/**
 * Reviewing changes a machine made: one note per changed thing, a card for what it removed
 * outright, a bar counting what is still outstanding, and a chip pointing at any of it from
 * elsewhere on the page.
 */
export declare const ChangeReview: {
    Item: FC<ChangeReviewItemProps>;
    Summary: FC<ChangeReviewSummaryProps>;
    Removed: FC<ChangeReviewRemovedProps>;
    Jump: FC<ChangeReviewJumpProps>;
};

export declare interface ChangeReviewItemProps {
    /**
     * What changed — a field name, or the name of a group of them. Omit it when the field this
     * item annotates already carries its own visible heading elsewhere on the page (so the name
     * doesn't render twice) — pass `fieldName` instead, so the badge and actions still know what
     * they belong to.
     */
    label?: string;
    /**
     * Names the field the badge and actions act on, for assistive tech. Defaults to `label`, so
     * passing only `label` keeps working as before. Set it explicitly when `label` is omitted —
     * otherwise "Accept"/"Revert" would have nothing telling a screen reader which field they act
     * on.
     */
    fieldName?: string;
    /** How it read before. A node, so a caller can show chips or code rather than a string. */
    before?: default_2.ReactNode;
    /** How it reads now. Usually omitted: the field itself is showing it. */
    after?: default_2.ReactNode;
    kind?: ChangeKind;
    /** What made the change. Names the assistant by default. */
    origin?: string;
    /**
     * The field the change is annotating. When given, the tag/label/actions form a header band
     * above it and the before/after line moves below it, so "Was …" reads next to the value it
     * describes instead of stacked with the header. Omit it for the standalone card.
     */
    children?: default_2.ReactNode;
    onApprove: () => void;
    onDeny: () => void;
    /**
     * Fires while the revert control is hovered or focused, and again when it stops being
     * either. A callback rather than internal state because the thing being previewed — the
     * field this change came from — lives elsewhere on the page, outside what `Item` renders;
     * only the caller can swap what that field shows.
     */
    onPreviewRevert?: (previewing: boolean) => void;
    disabled?: boolean;
    className?: string;
}

export declare interface ChangeReviewJumpProps {
    /** What the chip points at, e.g. a field or capability name. */
    label: string;
    /** Jumps the page to what changed. Without it the chip only names the change. */
    onClick?: () => void;
    disabled?: boolean;
    className?: string;
}

export declare interface ChangeReviewRemovedDetail {
    label: string;
    /** A node, so a caller can show a chip or code rather than a string. */
    value: default_2.ReactNode;
}

export declare interface ChangeReviewRemovedProps {
    /** The noun for what was removed. Defaults to a capability, but the component isn't
     *  policy-specific — a caller reviewing something else names it. */
    title?: string;
    /** Field/value pairs describing the removed thing, so the admin can see what they would
     *  lose before deciding. */
    details: ChangeReviewRemovedDetail[];
    onRestore: () => void;
    onDiscard: () => void;
    /** What made the removal. Names the assistant by default. */
    origin?: string;
    disabled?: boolean;
    className?: string;
}

export declare interface ChangeReviewSummaryProps {
    /** How many changes are still undecided. */
    count: number;
    /** What made them. Names the assistant by default. */
    origin?: string;
    onApproveAll: () => void;
    onDenyAll: () => void;
    disabled?: boolean;
    /**
     * What to say once nothing is outstanding. Omit and the bar renders nothing, which is what
     * a caller wants when the space should collapse rather than reassure.
     */
    settledMessage?: string;
    className?: string;
}

export declare const Chat: ChatComponent;

declare interface ChatComponent extends default_2.FC<ChatProps> {
    Header: default_2.FC<ChatHeaderProps>;
    Thread: default_2.FC<ChatThreadProps>;
    Message: default_2.FC<ChatMessageProps>;
    ToolCall: default_2.FC<ChatToolCallProps>;
    Thinking: default_2.FC<ChatThinkingProps>;
    Composer: default_2.FC<ChatComposerProps>;
    ComposerChip: default_2.FC<ChatComposerChipProps>;
    Context: default_2.FC<ChatContextProps>;
    ContextMeter: default_2.FC<ChatContextMeterProps>;
    ModelPicker: default_2.FC<ChatModelPickerProps>;
    Suggestion: default_2.FC<ChatSuggestionProps>;
}

export declare interface ChatComposerChipProps {
    label: string;
    icon?: default_2.ReactNode;
    /** Sits after the label — a caret on a chip that opens a menu. */
    trailingIcon?: default_2.ReactNode;
    /** Makes the chip a control. Without it, the chip reports rather than acts. */
    onClick?: () => void;
    disabled?: boolean;
    className?: string;
}

export declare interface ChatComposerProps {
    value: string;
    onChange: (value: string) => void;
    onSend: () => void;
    /** Offered in place of send while `busy`. Without it, send is simply disabled. */
    onStop?: () => void;
    /** A reply is streaming. */
    busy?: boolean;
    disabled?: boolean;
    placeholder?: string;
    maxLength?: number;
    rows?: number;
    /**
     * How many lines the field grows to before it scrolls internally instead of growing
     * further. Defaults well above `rows` so the field grows by default rather than staying
     * fixed at its starting height — a consumer that genuinely wants a static box passes
     * `maxRows` equal to `rows`.
     */
    maxRows?: number;
    /**
     * `'in-field'` (the default, so no existing consumer moves) nests a round send button
     * inside the field, trailing the text. `'beside'` matches the policy design instead: a
     * plain field with a labelled `Send` button to its right. Either way the field stays a
     * `TextArea` — the mock draws a single-line input, but a composer that cannot take a
     * second line is a downgrade, and `TextArea` already owns the Enter-to-send convention.
     */
    sendPlacement?: 'in-field' | 'beside';
    /**
     * `'assistant'` marks the field itself as AI-owned chrome: its focus border recolours to
     * the assistant violet instead of the default accent. Defaults to `'default'` — an AI
     * surface (e.g. the playground) opts in deliberately rather than inheriting it silently.
     */
    tone?: 'default' | 'assistant';
    /** Controls belonging with the composer — a model picker, a token meter. */
    children?: default_2.ReactNode;
    'aria-label'?: string;
    className?: string;
}

export declare interface ChatContextItem {
    id: string;
    label: string;
    /** Shows a remove control on the item. Without it, the item reports rather than can be dropped. */
    onRemove?: () => void;
    /**
     * Opens what the item names, in a new tab. A reader deciding whether context is the right
     * context has to be able to look at it, and following the link in place would cost them the
     * conversation it belongs to.
     */
    href?: string;
}

export declare interface ChatContextMeterProps {
    /** Tokens spent. Absent reads as a dash: nothing has been measured yet. */
    used?: number | null;
    /** The model's context window. */
    limit: number;
    /** Tokens served from cache, when the provider reports them. */
    cached?: number | null;
    label?: string;
    className?: string;
}

export declare interface ChatContextProps {
    label?: string;
    items: ChatContextItem[];
    /** Renders the "Add context" control. Without it, the row only lists what is already in scope. */
    onAdd?: () => void;
    className?: string;
}

export declare type ChatFeedback = 'up' | 'down';

export declare interface ChatHeaderProps {
    /** Names the surface, e.g. "Policy chat". */
    title: string;
    /**
     * Marks the surface as AI-owned: the title takes the assistant violet and a sparkle
     * leads it. Defaults to `'default'`, so a chat that is not assistant-authored does not
     * inherit the treatment.
     */
    tone?: 'default' | 'assistant';
    /** Sits opposite the title — a model name, a token count. */
    trailing?: default_2.ReactNode;
    /** Rows travelling with the header, e.g. `Chat.Context`. Pinned along with it. */
    children?: default_2.ReactNode;
    className?: string;
}

export declare interface ChatMessageProps {
    role: ChatRole;
    /**
     * `card` frames the turn with a header and a footer — for a surface where a reply carries
     * its own status and cost. `plain` is the bare turn. `bubble` wraps the turn in a coloured,
     * asymmetrically-rounded bubble instead — no header, no footer, just the shape.
     */
    variant?: ChatMessageVariant;
    /** Markdown. Rendered through `Typography.MarkdownBlock`, so a reply may carry formatting. */
    content?: string;
    /** Anything belonging with the message — tool calls, reasoning, a busy indicator. */
    children?: default_2.ReactNode;
    /** Names a user turn and its avatar; labels an assistant turn's header. */
    name?: string;
    avatarSrc?: string;
    /** Shown in a `card` header. Omitted means the turn reports no state. */
    status?: ChatMessageStatus;
    /**
     * The reply has been asked for but nothing has arrived. Renders the same placeholder
     * `Chat.Thinking` does, in the body's place, so the turn does not jump when text lands.
     */
    loading?: boolean;
    /**
     * Offers a copy control. The handler decides what to copy: a turn may hold tool calls and
     * reasoning this component never sees, so it cannot honestly claim to know the text.
     */
    onCopy?: () => void;
    /** Offers thumbs up and down. */
    onFeedback?: (feedback: ChatFeedback) => void;
    usage?: ChatMessageUsage;
    className?: string;
}

export declare type ChatMessageStatus = 'streaming' | 'completed' | 'error';

export declare interface ChatMessageUsage {
    /** The model as a reader would name it, e.g. "Claude Haiku 4.5". */
    model: string;
    inputTokens?: number;
    outputTokens?: number;
    totalTokens?: number;
}

/**
 * Three distinct treatments, not two plus a repaint of one: `plain` is the bare turn, `card`
 * frames a reply with its own status, copy/rating actions and a token line, and `bubble` is a
 * message-app chat style with no chrome beyond the bubble itself. All three appear in the
 * design-sync previews — keep them that way rather than folding `bubble` back into `card`.
 */
export declare type ChatMessageVariant = 'plain' | 'card' | 'bubble';

export declare interface ChatModelOption {
    value: string;
    label: string;
    /** The provider's mark. A URL, since providers ship logos rather than icon fonts. */
    iconSrc?: string;
    /** A second choice the model offers, e.g. how long it may think. */
    options?: ChatModelSubOption[];
}

export declare interface ChatModelPickerProps {
    models: ChatModelOption[];
    value: string;
    /** The chosen sub-option, when the current model offers them. */
    optionValue?: string;
    /** Called with the model, and its sub-option when it has them. */
    onChange: (model: string, option?: string) => void;
    disabled?: boolean;
    /**
     * Opens upward. On by default: this sits under a composer at the bottom of a column, so
     * downward is almost always off-screen.
     */
    openUp?: boolean;
    'aria-label'?: string;
}

export declare interface ChatModelSubOption {
    value: string;
    label: string;
    description?: string;
}

export declare interface ChatProps {
    children?: default_2.ReactNode;
    className?: string;
}

export declare type ChatRole = 'user' | 'assistant';

export declare interface ChatSuggestionProps {
    text: string;
    /** Fills the composer — never sends. A suggestion is a starting point the reader edits,
     *  not a message the component decides to submit on their behalf. */
    onPick: (text: string) => void;
    disabled?: boolean;
    className?: string;
}

export declare interface ChatThinkingProps {
    /** Names what is happening, when that is worth saying. Omitted, the bars speak alone. */
    label?: string;
    className?: string;
}

export declare interface ChatThreadProps {
    children?: default_2.ReactNode;
    /** Names the transcript for assistive tech, e.g. "Policy assistant conversation". */
    'aria-label'?: string;
    /** Shown, centred, while the transcript holds nothing. Ignored when `emptyContent` is
     *  supplied. */
    emptyTitle?: string;
    /** The lines under the title. A node, because guidance is rarely one sentence. Ignored
     *  when `emptyContent` is supplied. */
    emptyDescription?: default_2.ReactNode;
    /** Ignored when `emptyContent` is supplied. */
    emptyIcon?: default_2.ReactNode;
    /**
     * Replaces the `emptyTitle`/`emptyDescription`/`emptyIcon` composition. Renders
     * left-aligned at the bottom of the transcript, directly above the composer — an empty
     * conversation should read as ready to start, not as a decorated void.
     */
    emptyContent?: default_2.ReactNode;
    className?: string;
}

export declare interface ChatToolCallProps {
    /** The tool the assistant called, e.g. `update_policy_draft`. */
    name: string;
    status?: ChatToolCallStatus;
    /**
     * The provider's id for this call. Shown once the card is expanded, not on the collapsed
     * row: it is a long opaque string nobody reads at a glance, and beside the tool name it
     * was taking two lines of the transcript to say nothing a reader wanted.
     */
    callId?: string;
    /** Arguments the assistant sent. */
    input?: object;
    /** What the call returned. Absent while it is still running. */
    output?: object;
    defaultExpanded?: boolean;
    className?: string;
}

export declare type ChatToolCallStatus = 'running' | 'completed' | 'error';

export declare const Checkbox: default_2.FC<CheckboxProps>;

export declare interface CheckboxProps {
    checked: boolean;
    /** Tri-state "partial" look — overrides the checked tick with a square. */
    indeterminate?: boolean;
    /** Optional when `presentational` — a presentational checkbox is a visual indicator only. */
    onChange?: (checked: boolean) => void;
    disabled?: boolean;
    size?: number;
    /**
     * Render a visual-only indicator (a non-interactive, non-focusable `<span>`,
     * `aria-hidden`) instead of an interactive checkbox. Use this inside a clickable
     * row/card whose wrapper is the real control, so there's a single tab stop.
     */
    presentational?: boolean;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    id?: string;
}

export declare const CheckCircleFilled: React.FC<IconProps_20>;

export declare const CheckIcon: React.FC<IconProps_21>;

export declare const CheckmarkIcon: React.FC<IconProps_22>;

/**
 * Text clamped to `lines`, revealing the full text on hover / keyboard focus when
 * `expandOnHover`. Pure CSS. The expanded state caps at 1000px, so this is for short blurbs.
 *
 * `line-height` is `1.5em`, NOT the bare `1.5`, and that unit is what makes the cap exact: a
 * `<number>` inherits as a FACTOR, so each descendant re-resolves it against its own
 * font-size, while `max-height: calc(1.5em * lines)` resolves against THIS element's. With
 * the bare number they disagreed — 14px text in a 13px row gave 21px line boxes against a
 * 19.5px allowance and the last line was sliced. As a `<length>` both share one basis.
 *
 * The cap also bounds block children, which `-webkit-line-clamp` counts as one "line" each —
 * so a MarkdownBlock in `block` variant relies on it. (Prefer `variant="flow"` there.)
 */
export declare const ClampText: default_2.FC<ClampTextProps>;

export declare interface ClampTextProps {
    children: default_2.ReactNode;
    lines?: number;
    expandOnHover?: boolean;
    className?: string;
}

export declare const ClearIcon: React.FC<IconProps_23>;

export declare const CloseIcon: React.FC<IconProps_24>;

export declare const CodeBlock: default_2.FC<CodeBlockProps>;

declare interface CodeBlockProps {
    /** The code content to display */
    code?: string;
    /** JSON object to display as formatted JSON */
    json?: object;
    /** Show line numbers */
    showLineNumbers?: boolean;
    /** Custom class name */
    className?: string;
    /** Custom styles */
    style?: default_2.CSSProperties;
    /** Height of the code block */
    height?: string | number;
    /** Enable copy functionality */
    enableCopy?: boolean;
    /** Wrap long lines instead of scrolling horizontally */
    wrapLines?: boolean;
    /**
     * Highlight the code with this language's grammar. `cedar` is a grammar this library
     * ships itself (`prismCedar.ts`), since Prism and refractor carry none; widen the union
     * as further grammars are registered in CodeBlockHighlighter.
     */
    language?: 'yaml' | 'cedar';
    /** How much of a `json` tree starts collapsed: `true` all of it, a number below that depth. */
    collapsed?: boolean | number;
    /**
     * Renders the change between two texts rather than one text, and takes precedence over
     * `code` and `json`. Only the changed lines are shown, with `context` unchanged ones either
     * side, so a small edit to a long document reads as a few hunks instead of the whole thing.
     */
    diff?: {
        before: string;
        after: string;
        /** Unchanged lines kept either side of each change. Three by convention. */
        context?: number;
        /**
         * Swaps the `+`/`-` gutter and tinted rows for the palette a mock specified for
         * AI-authored changes: star, minus-sign and middle-dot markers, and a struck-through
         * removal. Omit to keep the neutral markers; there is no default consumer for the
         * assistant look yet.
         */
        origin?: 'assistant';
    };
}

export declare const CodeIcon: React.FC<IconProps_25>;

export declare interface CodeTextProps {
    bold?: boolean;
    size?: FontSize;
    hasBorder?: boolean;
    variant?: CodeTextVariant;
    color?: string;
    backgroundColor?: string;
    children: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare type CodeTextVariant = 'block' | 'inline';

export declare const CollapsibleSection: default_2.FC<CollapsibleSectionProps>;

export declare interface CollapsibleSectionProps {
    title: string;
    subtitle?: string;
    defaultExpanded?: boolean;
    isExpanded?: boolean;
    onToggle?: (expanded: boolean) => void;
    className?: string;
    children: default_2.ReactNode;
}

export declare const CommandKeyIcon: React.FC<IconProps_26>;

export declare const Confetti: default_2.FC<ConfettiProps>;

export declare interface ConfettiProps {
    /** Number of confetti pieces. */
    count?: number;
    /** Colors cycled across the pieces. */
    colors?: string[];
    className?: string;
}

export declare const ConfirmationDialog: default_2.FC<ConfirmationDialogProps>;

export declare interface ConfirmationDialogProps {
    open: boolean;
    /** Dismiss handler — cancel, close button, ESC or scrim. `loading` suppresses every
     *  route except ESC, which always reaches this so a keyboard user is never stranded. */
    onClose: () => void;
    /** Runs when the confirm action is taken. Closing is left to the consumer. */
    onConfirm: () => void;
    title: default_2.ReactNode;
    titleAdornment?: default_2.ReactNode;
    badgeIcon?: default_2.ReactNode;
    /** The sentence saying what is about to happen. */
    description?: default_2.ReactNode;
    variant?: ConfirmationDialogVariant;
    /** Coloured callout below the body. Defaults to the variant's own type. */
    callout?: {
        type?: AlertType;
        message: string;
    };
    /**
     * Requires this exact phrase to be typed before the confirm action enables — for a
     * consequence severe enough that a single click should not be able to cause it.
     */
    confirmPhrase?: string;
    /** Label above the type-to-confirm field. `{ prefix, suffix }` makes the phrase copyable. */
    confirmPhraseLabel?: PhraseLabel;
    /** Names the copy control, e.g. `Copy profile name`. Default: `Copy`. */
    confirmPhraseCopyLabel?: string;
    /** Runs after the phrase reaches the clipboard, with what was copied. */
    onPhraseCopied?: (phrase: string) => void;
    confirmPhrasePlaceholder?: string;
    confirmLabel?: string;
    cancelLabel?: string;
    /**
     * Disables the actions, spins the confirm button and suppresses the pointer dismissal
     * routes — but never ESC, which always reaches `onClose`.
     */
    loading?: boolean;
    tip?: {
        label?: string;
        message: string;
    };
    size?: ModalSize;
    /** Accessible dialog name; required when `title` isn't a plain string. */
    'aria-label'?: string;
    /** ID of a visible element naming the dialog (alternative to `aria-label`). */
    'aria-labelledby'?: string;
    /** Extra body content between the description and the callout, e.g. an entity chip. */
    children?: default_2.ReactNode;
}

export declare type ConfirmationDialogVariant = 'default' | 'warning' | 'destructive' | 'success';

export declare interface ConnectionEndpoint {
    /** Icon/glyph shown in the tile (coloured white when a `background` is set). */
    icon: default_2.ReactNode;
    /** Optional name — shown as a caption under the tiles and used as the tile's label. */
    label?: string;
    /** Tile background. When omitted, a neutral surface is used. */
    background?: string;
}

export declare const ConnectionHeader: default_2.FC<ConnectionHeaderProps>;

export declare interface ConnectionHeaderProps {
    from: ConnectionEndpoint;
    to: ConnectionEndpoint;
    className?: string;
}

export declare const CopyIcon: React.FC<IconProps_27>;

export declare const CsvIcon: React.FC<IconProps_28>;

export declare const CustomFieldIcon: React.FC<IconProps_29>;

export declare const CustomIcons: {
    AccountIcon: FC<IconProps>;
    AccountsIcon: FC<IconProps>;
    AddIcon: FC<IconProps>;
    AdvancedLogsIcon: FC<IconProps>;
    ApiKeysIcon: FC<IconProps>;
    ArchiveIcon: FC<IconProps>;
    ArrowLeftIcon: FC<IconProps>;
    ArrowUpIcon: FC<IconProps>;
    ArrowUpRightIcon: FC<IconProps>;
    AuthenticationIcon: FC<IconProps>;
    BellIcon: FC<IconProps>;
    BellSlashIcon: FC<IconProps>;
    BiDirectionalArrowsIcon: FC<IconProps>;
    CardIcon: FC<IconProps>;
    CaretDownIcon: FC<IconProps>;
    CaretLeftIcon: FC<IconProps>;
    CaretRightIcon: FC<IconProps>;
    CaretUpIcon: FC<IconProps>;
    CodeIcon: FC<IconProps>;
    ChangePasswordIcon: FC<IconProps>;
    CheckCircleFilled: FC<IconProps>;
    CheckIcon: FC<IconProps>;
    CheckmarkIcon: FC<IconProps>;
    ClearIcon: FC<IconProps>;
    CloseIcon: FC<IconProps>;
    CommandKeyIcon: FC<IconProps>;
    CopyIcon: FC<IconProps>;
    CsvIcon: FC<IconProps>;
    CustomFieldIcon: FC<IconProps>;
    DashboardIcon: FC<IconProps>;
    DateIcon: FC<IconProps>;
    DisabledIcon: FC<IconProps>;
    DisableIcon: FC<IconProps>;
    DismissIcon: FC<IconProps>;
    DocIcon: FC<IconProps>;
    DoubleCheckIcon: FC<IconProps>;
    DownloadIcon: FC<IconProps>;
    EditIcon: FC<IconProps>;
    EnableIcon: FC<IconProps>;
    EnumIcon: FC<IconProps>;
    ErrorCircleFilled: FC<IconProps>;
    ExpandIcon: FC<IconProps>;
    EyeClosedIcon: FC<IconProps>;
    EyeIcon: FC<IconProps>;
    FieldMappingIcon: FC<IconProps>;
    FilledCaretDownIcon: FC<IconProps>;
    FilledCaretRightIcon: FC<IconProps>;
    FilterIcon: FC<IconProps>;
    ForbiddenIcon: FC<IconProps>;
    GlobeIcon: FC<IconProps>;
    ForwardArrowIcon: FC<IconProps>;
    InboxIcon: FC<IconProps>;
    InfoIcon: FC<IconProps>;
    InfoFilledIcon: FC<IconProps>;
    InfoCircleFilled: FC<IconProps>;
    IntegrationsIcon: FC<IconProps>;
    KeyIcon: FC<IconProps>;
    LibraryIcon: FC<IconProps>;
    LogsIcon: FC<IconProps>;
    MagicWandIcon: FC<IconProps>;
    ManageTeamIcon: FC<IconProps>;
    ManualWebhookIcon: FC<IconProps>;
    MarkReadIcon: FC<IconProps>;
    MarkUnreadIcon: FC<IconProps>;
    MembersIcon: FC<IconProps>;
    ModalIcon: FC<IconProps>;
    MoreHorizontalIcon: FC<IconProps>;
    MoreVerticalIcon: FC<IconProps>;
    NavbarCollapseIcon: FC<IconProps>;
    NavbarExpandIcon: FC<IconProps>;
    NotFoundIcon: FC<IconProps>;
    OrganizationIcon: FC<IconProps>;
    PinIcon: FC<IconProps>;
    PlusIcon: FC<IconProps>;
    PreviewIcon: FC<IconProps>;
    ProgrammaticWebhookIcon: FC<IconProps>;
    PulseIcon: FC<IconProps>;
    RefreshIcon: FC<IconProps>;
    RejectIcon: FC<IconProps>;
    ReloadIcon: FC<IconProps>;
    ReplyIcon: FC<IconProps>;
    RequiredFieldIndicatorIcon: FC<IconProps>;
    SearchIcon: FC<IconProps>;
    SecurityIcon: FC<IconProps>;
    SendIcon: FC<IconProps>;
    SettingsIcon: FC<IconProps>;
    SignOutIcon: FC<IconProps>;
    SliderIcon: FC<IconProps>;
    SortIcon: FC<IconProps>;
    SourceIcon: FC<IconProps>;
    SparkleIcon: FC<IconProps>;
    StarIcon: FC<IconProps>;
    StepCurrentIcon: FC<IconProps>;
    StepUpcomingIcon: FC<IconProps>;
    SyntheticWebhookIcon: FC<IconProps>;
    ThumbsDownIcon: FC<IconProps>;
    ThumbsUpIcon: FC<IconProps>;
    TrashIcon: FC<IconProps>;
    TriangleDownIcon: FC<IconProps>;
    TriangleRightIcon: FC<IconProps>;
    UnarchiveIcon: FC<IconProps>;
    UploadIcon: FC<IconProps>;
    WarningCircleFilled: FC<IconProps>;
    WarningTriangleIcon: FC<IconProps>;
    WebhookEventsIcon: FC<IconProps>;
    WebhookIcon: FC<IconProps>;
    WebhookSigningSecretIcon: FC<IconProps>;
};

export declare const darkTheme: MalachiteTheme;

export declare const DashboardIcon: React.FC<IconProps_30>;

export declare const DateIcon: React.FC<IconProps_31>;

export declare const defaultTheme: MalachiteTheme;

export declare const DefinitionRow: default_2.FC<DefinitionRowProps>;

declare interface DefinitionRowProps {
    icon: default_2.ReactNode;
    label: string;
    tag: string;
    description: string;
}

export declare const DisabledIcon: React.FC<IconProps_33>;

export declare const DisableIcon: React.FC<IconProps_32>;

export declare const DismissIcon: React.FC<IconProps_34>;

export declare const Divider: default_2.FC<DividerProps>;

/** Fixed lengths a rule between inline controls can take. Left unset it spans its container. */
declare type DividerLength = 'small' | 'medium' | 'large';

export declare type DividerLineStyle = 'solid' | 'dashed';

declare type DividerOrientation = 'horizontal' | 'vertical';

declare interface DividerProps {
    /** `vertical` draws a 1px rule between inline controls, e.g. groups in a toolbar. */
    orientation?: DividerOrientation;
    /** Length along the rule's own axis — height when vertical, width when horizontal.
     *  Unset spans the container. */
    length?: DividerLength;
    margin?: SpacingSize;
    padding?: PaddingSize;
    className?: string;
    variant?: DividerVariant;
    lineStyle?: DividerLineStyle;
    grow?: boolean;
}

export declare enum DividerVariant {
    Default = "default",
    Muted = "muted",
    Emphasis = "emphasis"
}

export declare const DocIcon: React.FC<IconProps_35>;

export declare const DoubleCheckIcon: React.FC<IconProps_36>;

export declare const DownloadIcon: React.FC<IconProps_37>;

export declare const Dropdown: ({ items, onItemSelected, defaultValue, value, disabled, error, tone, label, hint, rightSideContent, tooltip, name, required, requiredIndicator, loading, menuLoading, formControl, description, helperText, placeholder, search, showSubtitleInTrigger, subtitleLayout, clearable, size, fullWidth, width, minWidth, id, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, }: DropdownProps) => JSX_2.Element;

declare interface DropdownBaseProps {
    label?: string;
    hint?: string;
    rightSideContent?: RightSideContent;
    tooltip?: string;
    name: FieldPath<FieldValues> | string;
    loading?: boolean;
    menuLoading?: boolean;
    items: DropdownItem[];
    onItemSelected?: (id?: string) => void;
    defaultValue?: string;
    /** Controlled selection. When set, the trigger always reflects this id and the component
     *  keeps no selection state of its own. Pass it with `onItemSelected`. */
    value?: string;
    disabled?: boolean;
    error?: boolean;
    /** `pending` marks a value the user still has to supply. Outranks open and selection. */
    tone?: DropdownTone;
    className?: string;
    formControl?: Control<FieldValues, unknown>;
    description?: string;
    required?: boolean;
    requiredIndicator?: RequiredIndicator;
    helperText?: default_2.ReactNode;
    placeholder?: string;
    subtitleLayout?: SubtitleLayout;
    /** Adds a clear control to the trigger, reported as `onItemSelected(undefined)`. */
    clearable?: boolean;
    /** 'large' (42px) for form inputs; 'medium' (32px) for toolbar chips; 'small' (28px) beside a title. */
    size?: DropdownSize;
    fullWidth?: boolean;
    width?: string | number;
    /**
     * Raises the open menu's floor above the shared 160px one, without widening the trigger.
     * For a control pinned narrow by its column — a role picker in a 160px cell, a member
     * picker in a 200px slot — whose options carry a subtitle the trigger never has to show.
     */
    minWidth?: number;
    /** Names the trigger from the light DOM, where `htmlFor` cannot reach into the shadow root. */
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
}

export declare interface DropdownItem {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    /** Alternate label shown in the closed trigger when selected (falls back to `label`). */
    triggerLabel?: string;
    /** Items sharing a `group` render under a section header, in first-seen order. */
    group?: string;
    subtitle?: string;
    rightSideText?: string;
    rightSideTextVariant?: 'muted' | 'primary';
    rightSideTextAlignment?: 'left' | 'right';
}

export declare type DropdownProps = DropdownBaseProps & DropdownTriggerModeProps;

/**
 * Matches Button and the Figma component library: 28 / 32 / 42px. These names moved up a
 * tier in 0.71 — what was `xsmall`/`small`/`medium` is now `small`/`medium`/`large`.
 */
export declare type DropdownSize = 'small' | 'medium' | 'large';

export declare type DropdownTone = 'default' | 'pending';

/**
 * The search trigger is a single-line text input with nowhere for a second line, so
 * `showSubtitleInTrigger` is rejected alongside `search` rather than silently ignored.
 */
declare type DropdownTriggerModeProps = {
    search?: false;
    /** Promotes the selected item's `subtitle` into the closed trigger, beneath the value. */
    showSubtitleInTrigger?: boolean;
} | {
    search: true;
    showSubtitleInTrigger?: never;
};

export declare const EditIcon: React.FC<IconProps_38>;

declare interface EllipsisTextProps {
    children: default_2.ReactNode;
    tooltip?: default_2.ReactNode | string;
    /**
     * Defaults to filling the container. Pass a fixed width only when the text should
     * truncate before its container runs out of room (e.g. a column with a hard cap).
     */
    maxWidth?: string;
    color?: TextColor;
    size?: FontSize;
    /**
     * Show `tooltip` only when the text is actually cut off. Opt-in, because `tooltip` is any
     * node: a caller repeating the label wants this, and one supplying something the label does
     * not say — a full path, a timestamp — would lose it.
     */
    tooltipWhenTruncated?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare interface EmptyLayoutProps {
    title?: string;
    children: default_2.ReactNode;
    centered?: boolean;
    uniformPadding?: boolean;
    headerActions?: default_2.ReactNode;
    background?: default_2.ReactNode;
    /** Demotes the default `main` landmark — pass e.g. `region` when the app owns its own. */
    role?: default_2.AriaRole;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const EnableIcon: React.FC<IconProps_39>;

export declare const EnumIcon: React.FC<IconProps_40>;

export declare const ErrorCircleFilled: React.FC<IconProps_41>;

export declare const ExpandIcon: React.FC<IconProps_42>;

export declare const EyeClosedIcon: React.FC<IconProps_43>;

export declare const EyeIcon: React.FC<IconProps_44>;

/**
 * Something a form has to show but does not ask for — a computed list, a generated value —
 * wearing a field's anatomy: label, content, helper text, on a field's metrics.
 */
export declare const FieldBlock: default_2.FC<FieldBlockProps>;

export declare interface FieldBlockProps {
    label?: string;
    /** Sits beside the label — a count, a status. */
    badge?: default_2.ReactNode;
    /** Sits at the far end of the label row — a copy button, a link. */
    action?: default_2.ReactNode;
    helperText?: default_2.ReactNode;
    children: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare interface FieldErrorState {
    error: boolean;
    message?: string;
    /**
     * Reports an edit to the resolver only — the control keeps painting whatever value the
     * consumer gives it — so a rejection clears as the field is fixed, not at the next submit.
     */
    onFieldChange?: (value: unknown) => void;
    onFieldBlur?: () => void;
    /** What this form means by "nothing chosen" — see `emptyValueOf`. */
    emptyValue: unknown;
    /** The value the form holds for the field, which is what a bound control must paint. */
    value: unknown;
}

/**
 * Fields that follow from an answer given above them — the credentials a chosen
 * authentication type asks for, say — drawn as its children: indented, with a rule down the side.
 */
export declare const FieldGroup: default_2.FC<FieldGroupProps>;

export declare type FieldGroupGap = 'small' | 'medium' | 'large';

export declare interface FieldGroupProps {
    children: default_2.ReactNode;
    gap?: FieldGroupGap;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const FieldMappingIcon: React.FC<IconProps_45>;

export declare const FilledCaretDownIcon: React.FC<IconProps_46>;

export declare const FilledCaretRightIcon: React.FC<IconProps_47>;

export declare const FilterIcon: React.FC<IconProps_48>;

export declare const Flex: default_2.FC<FlexProps>;

export declare enum FlexAlign {
    Top = "flex-start",
    Bottom = "flex-end",
    Center = "center",
    Normal = "normal",
    Stretch = "stretch"
}

export declare enum FlexDirection {
    Horizontal = "horizontal",
    Vertical = "vertical"
}

export declare enum FlexGapSize {
    XSmall = "xsmall",
    Small = "small",
    Medium = "medium",
    Large = "large"
}

export declare enum FlexJustify {
    Left = "flex-start",
    Right = "flex-end",
    Center = "center",
    SpaceBetween = "space-between",
    SpaceAround = "space-around",
    SpaceEvenly = "space-evenly"
}

declare interface FlexProps {
    justify?: FlexJustify;
    align?: FlexAlign;
    gapSize?: FlexGapSize;
    direction?: FlexDirection;
    fullHeight?: boolean;
    grow?: boolean;
    shrink?: boolean;
    wrap?: boolean;
    width?: string;
    id?: string;
    children?: default_2.ReactNode;
    className?: string;
}

/** Which theme typeface to render in. Defaults to the sans body face. */
declare type FontFamily = 'sans' | 'heading' | 'body' | 'mono';

export declare type FontSize = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';

export declare type FontWeight = 'normal' | 'semi-bold' | 'bold';

export declare const FooterLinks: default_2.FC<FooterLinksProps>;

declare interface FooterLinksProps {
    fullWidth?: boolean;
    showDocsSupport?: boolean;
}

export declare const FooterNav: default_2.FC<FooterNavProps>;

export declare interface FooterNavLink {
    label: string;
    href?: string;
    onClick?: () => void;
}

export declare interface FooterNavProps {
    links: FooterNavLink[];
    className?: string;
}

export declare const ForbiddenIcon: React.FC<IconProps_49>;

export declare const Form: default_2.FC<FormProps>;

export declare const FormItem: default_2.FC<FormItemProps>;

export declare type FormItemChildren = default_2.ReactNode | ((state: FieldErrorState) => default_2.ReactNode);

declare interface FormItemProps {
    control: Control<FieldValues, unknown>;
    name: FieldPath<FieldValues>;
    children: FormItemChildren;
}

declare interface FormProps {
    children: default_2.ReactNode;
    onFinish?: (data: FieldValues) => void;
    formInstance?: UseFormReturn<FieldValues>;
    defaultValues?: FieldValues;
    className?: string;
}

/**
 * Names a group of fields in a form and rules off the space beside it. Quieter than
 * `Typography.FormSectionTitle`, which titles a form rather than dividing one.
 */
export declare const FormSectionHeading: default_2.FC<FormSectionHeadingProps>;

export declare type FormSectionHeadingLevel = 2 | 3 | 4 | 5 | 6;

export declare interface FormSectionHeadingProps {
    children: default_2.ReactNode;
    /** The rule that runs from the label to the edge of the section. */
    rule?: boolean;
    /** Where the section sits in the page's heading hierarchy. */
    level?: FormSectionHeadingLevel;
    className?: string;
    style?: default_2.CSSProperties;
}

declare interface FormSectionTitleProps {
    children: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const ForwardArrowIcon: React.FC<IconProps_50>;

/**
 * Get current theme values from CSS custom properties
 */
export declare function getCurrentTheme(): MalachiteTheme;

/**
 * Get current theme mode from localStorage
 */
export declare function getCurrentThemeMode(): 'light' | 'dark';

export declare const GlobeIcon: React.FC<IconProps_51>;

declare interface IconProps {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_10 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_100 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_101 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_102 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_103 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_104 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_105 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_106 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_107 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_11 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_12 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_13 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_14 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_15 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_16 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_17 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_18 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_19 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_2 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_20 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_21 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_22 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_23 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_24 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_25 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_26 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_27 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_28 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_29 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_3 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_30 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_31 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_32 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_33 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_34 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_35 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_36 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_37 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_38 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_39 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_4 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_40 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_41 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_42 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_43 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_44 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_45 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_46 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_47 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_48 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_49 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_5 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_50 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_51 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_52 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_53 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_54 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_55 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_56 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_57 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_58 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_59 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_6 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_60 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_61 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_62 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_63 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_64 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_65 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_66 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_67 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_68 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_69 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_7 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_70 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_71 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_72 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_73 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_74 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_75 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_76 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_77 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_78 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_79 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_8 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_80 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_81 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_82 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_83 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_84 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_85 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_86 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_87 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_88 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_89 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_9 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_90 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_91 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_92 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_93 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_94 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_95 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_96 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_97 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_98 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

declare interface IconProps_99 {
    size?: number | string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
}

export declare const InboxIcon: React.FC<IconProps_52>;

export declare const InfoCircleFilled: React.FC<IconProps_53>;

export declare const InfoFilledIcon: React.FC<IconProps_54>;

export declare const InfoIcon: React.FC<IconProps_55>;

/**
 * Initialize the theme system - should be called on app startup
 */
export declare function initializeTheme(): void;

/**
 * A confirmation asked on the control that triggered it, rather than in a modal.
 *
 * With `anchorTo` the chip places and tracks itself. Without it the chip renders in flow, and
 * must not sit in a container that clips its overflow — `Table`'s header cells among them.
 */
export declare const InlineConfirm: default_2.FC<InlineConfirmProps>;

export declare interface InlineConfirmProps {
    /** Mounts the chip and moves focus into it. Nothing renders while false. */
    open: boolean;
    /** What is being confirmed, e.g. "Confirm Remove All". Becomes the chip's name. */
    message: string;
    /** Defaults to "Yes". */
    confirmLabel?: string;
    onConfirm: () => void;
    /** Called on Escape, on a click outside, and when the anchor scrolls out of view. */
    onDismiss: () => void;
    /** The control being answered for. The chip pins to its left and follows it. */
    anchorTo?: default_2.RefObject<HTMLElement | null>;
    /** Replaces the leading spinner. `null` drops it. */
    icon?: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const Input: default_2.FC<InputProps>;

declare interface InputProps {
    label?: string;
    hint?: string;
    tooltip?: string;
    placeholder?: string;
    icon?: default_2.ReactNode;
    readOnly?: boolean;
    name: FieldPath<FieldValues> | string;
    type?: InputType;
    description?: string;
    size?: InputSize;
    variant?: InputVariant;
    required?: boolean;
    requiredIndicator?: RequiredIndicator;
    error?: boolean;
    loading?: boolean;
    defaultValue?: string;
    disabled?: boolean;
    prefixValue?: string;
    prefixSecondaryValue?: string;
    ellipsis?: boolean;
    formControl?: Control<FieldValues, unknown>;
    buttons?: ButtonDefinition[];
    onCopyClick?: () => void;
    showCopyButton?: boolean;
    onChange?: (value: string) => void;
    /** Controlled value, for a source of truth outside the form (URL, app state). */
    value?: string;
    onBlur?: () => void;
    helperText?: string;
    showPasswordToggle?: boolean;
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
}

declare type InputSize = 'small' | 'medium' | 'large';

declare type InputType = 'text' | 'password' | 'number' | 'email' | 'tel' | 'url';

declare type InputVariant = 'default' | 'ghost';

export declare const IntegrationsIcon: React.FC<IconProps_56>;

export declare const KeyIcon: React.FC<IconProps_57>;

export declare const KeyValueList: default_2.FC<KeyValueListProps> & {
    Row: typeof Row;
};

export declare interface KeyValueListProps {
    className?: string;
    children: default_2.ReactNode;
}

export declare interface KeyValueListRowProps {
    label: default_2.ReactNode;
    className?: string;
    children: default_2.ReactNode;
}

export declare const LibraryIcon: React.FC<IconProps_58>;

export declare const Link: default_2.FC<LinkProps>;

export declare interface LinkProps {
    href: string;
    target?: '_blank' | '_self' | '_parent' | '_top';
    rel?: string;
    children: default_2.ReactNode;
    className?: string;
    color?: 'default' | 'dimmed';
    size?: FontSize;
    underline?: boolean;
}

declare interface LinkProps_2 {
    href: string;
    target?: '_blank' | '_self' | '_parent' | '_top';
    rel?: string;
    children: default_2.ReactNode;
    className?: string;
    showRightBorder?: boolean;
    showLeftBorder?: boolean;
    padding?: boolean;
    color?: 'default' | 'dimmed';
    fontSize?: 'sm' | 'base';
}

export declare const LoadingBar: default_2.FC<LoadingBarProps>;

export declare interface LoadingBarProps {
    /**
     * Whether the bar is animating. When false the line is hidden but its height
     * is preserved, so toggling it doesn't shift the layout underneath.
     */
    active?: boolean;
    /**
     * Semantic colour role. Colours come from theme tokens by design — there is no
     * free-form colour prop, so a consumer can't paint the bar off-palette. To
     * restyle a variant, override its tokens via `applyTheme` / `applyCustomTheme`.
     */
    variant?: LoadingBarVariant;
    /** Line thickness. Fixed steps rather than a free px value, to keep bars consistent. */
    size?: LoadingBarSize;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare type LoadingBarSize = 'small' | 'medium' | 'large';

export declare type LoadingBarVariant = 'default' | 'warning' | 'error';

export declare const LogsIcon: React.FC<IconProps_59>;

export declare const MagicWandIcon: React.FC<IconProps_60>;

/**
 * MalachiteContext provides a Shadow DOM context with theme setup for Malachite components.
 * Use this to wrap groups of Malachite components instead of each component managing its own Shadow DOM.
 *
 * @example
 * <MalachiteContext>
 *   <Button variant="filled">Click me</Button>
 *   <Card>
 *     <CardContent>Hello world</CardContent>
 *   </Card>
 * </MalachiteContext>
 */
export declare const MalachiteContext: default_2.FC<MalachiteContextProps>;

declare interface MalachiteContextProps {
    children: default_2.ReactNode;
    className?: string;
    /**
     * Stretches the shadow host, and every plain div between it and `children`, to 100% of
     * the height available from this component's own parent. Without it, the host sizes to
     * its content: a percentage height set further down (inside `children`) has nothing
     * non-`auto` to resolve against, and a chain of plain `<div>`s does not propagate a
     * parent's height to its children on its own. Off by default: every existing consumer
     * relies on the host hugging its content, and turning this on for all of them would
     * change how much space they take up.
     */
    fillHeight?: boolean;
}

export declare interface MalachiteTheme {
    fontSizes: {
        xsmall: string;
        small: string;
        medium: string;
        /** Off-ladder: the control ladder's large tier is 15px, between `medium` and `large`. */
        '15'?: string;
        large: string;
        xlarge: string;
        xxlarge: string;
    };
    /**
     * Heights of the shared control ladder. Optional so adding the family never breaks a
     * consumer building a full theme literal — same reason `radius.xs` is optional.
     */
    controlHeights?: {
        small: string;
        medium: string;
        large: string;
    };
    iconSizes: {
        xsmall: string;
        small: string;
        medium: string;
        large: string;
    };
    radius: {
        /** Optional so adding a rung never breaks a consumer building a full theme literal. */
        xs?: string;
        sm: string;
        md: string;
        lg: string;
        /** Off-ladder: no rung exists between `lg` (8px) and `xl` (12px). */
        '10'?: string;
        xl: string;
        xxl: string;
        xxxl: string;
    };
    shadows: {
        sm: string;
        md: string;
        lg: string;
        xl: string;
        default: string;
        glow?: string;
        glowLg?: string;
        /** Optional so adding a shadow never breaks a consumer building a full theme literal. */
        accent?: string;
        success: string;
        warning: string;
        error: string;
    };
    colors: {
        shadowColor: string;
        shadowOpacity: number;
        card: {
            background: string;
            foreground: string;
            border: string;
            shadow: string;
            dimmedBackground: string;
            sunkenBackground: string;
            warmBackground: string;
            headerBackground: string;
            footerBackground: string;
            /** @deprecated No longer read by any component — glass surfaces derive from `sunkenBackground` (see `glassSurface.ts`). */
            footerGlassBackground: string;
            trayNeutral?: string;
            trayWarning?: string;
            trayError?: string;
            traySuccess?: string;
            subtleDivider?: string;
        };
        overlay: {
            /** Dimming layer drawn behind modal overlays (e.g. SidePanel). */
            scrim: string;
        };
        alert: {
            info: {
                background: string;
                foreground: string;
            };
            success: {
                background: string;
                foreground: string;
            };
            error: {
                background: string;
                foreground: string;
            };
            warning: {
                background: string;
                foreground: string;
            };
            /** Says a machine wrote this, not that anything is wrong — the violet the
             *  assistant is named in elsewhere, not a fifth severity. */
            assistant: {
                background: string;
                foreground: string;
            };
        };
        tooltip: {
            background: string;
            foreground: string;
            border: string;
            shadow: string;
        };
        primary: {
            background: string;
            foreground: string;
            border: string;
            borderHover: string;
        };
        /** Brand accent for interaction states — checked, selected, active. Green today,
         *  but a rebrand repaints it; `success.*` stays status-only and does not follow.
         *  Optional so adding a group never breaks a consumer building a full theme literal. */
        accent?: {
            background: string;
            foreground: string;
            border: string;
            backgroundGlass: string;
        };
        control: {
            borderHover: string;
        };
        outline: {
            foreground: string;
        };
        secondary: {
            background: string;
            foreground: string;
            border: string;
            borderHover: string;
        };
        destructive: {
            background: string;
            foreground: string;
            border: string;
            borderHover: string;
            shadow: string;
            shadowLight: string;
            shadowMedium: string;
        };
        success: {
            background: string;
            foreground: string;
            border: string;
            borderHover: string;
            backgroundGlass: string;
            shadowLight: string;
            shadowMedium: string;
        };
        warning: {
            background: string;
            foreground: string;
            border: string;
            borderHover: string;
            backgroundGlass: string;
            shadowLight: string;
            shadowMedium: string;
        };
        error: {
            background: string;
            foreground: string;
            border: string;
            borderHover: string;
            backgroundGlass: string;
            shadowLight: string;
            shadowMedium: string;
        };
        buttonList: {
            background: string;
            foreground: string;
            hoverBackground: string;
            hoverForeground: string;
        };
        pillButton: {
            background: string;
            foreground: string;
            hoverBackground: string;
            hoverForeground: string;
            pressedBackground: string;
            pressedForeground: string;
            pressedOpacity: string;
            activeBackground: string;
            activeForeground: string;
            staticBackground: string;
            staticForeground: string;
            invertedBackground: string;
            invertedForeground: string;
            invertedHoverBackground: string;
            invertedHoverForeground: string;
            invertedPressedBackground: string;
            invertedPressedForeground: string;
        };
        toggle: {
            track: string;
            trackChecked: string;
            /** The checked track while the change it represents has not been saved yet. */
            trackCheckedPending: string;
            knob: string;
        };
        segmentedControl: {
            trackBackground: string;
            itemForeground: string;
            itemHoverForeground: string;
            selectedBackground: string;
            selectedForeground: string;
            selectedShadow: string;
        };
        selectableCard: {
            background: string;
            border: string;
            selectedTint: string;
            selectedSurfaceEnd: string;
            selectedBorder: string;
            librarySelectedTint: string;
            librarySelectedBorder: string;
            editingTint: string;
            accent: string;
            mutedForeground: string;
            hoverBackground: string;
            hoverRule: string;
            pendingForeground: string;
        };
        cardStrip: {
            background: string;
            divider: string;
            fade: string;
            arrowBackground: string;
            arrowBorder: string;
            addPrimaryBackground: string;
            addPrimaryForeground: string;
        };
        selectionBar: {
            background: string;
            foreground: string;
            mutedForeground: string;
            divider: string;
            border: string;
            primaryBorder: string;
            shadow: string;
            noticeBackground: string;
            noticeForeground: string;
            noticeShadow: string;
        };
        inlineConfirm: {
            background: string;
            foreground: string;
            divider: string;
            shadow: string;
        };
        dropdown: {
            border: string;
            borderActive: string;
            borderFilter: string;
            borderError: string;
            borderPending: string;
            shadow: string;
            shadowHover: string;
            shadowActive: string;
            shadowFilter: string;
            shadowError: string;
            shadowPending: string;
            disabledBackground: string;
        };
        tag: {
            primary: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            secondary: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            default: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            error: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            warning: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            success: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            emphasis: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            info: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
            assistant: {
                background: string;
                foreground: string;
                border: string;
                shadow: string;
            };
        };
        numberTag: {
            background: string;
            foreground: string;
            emphasisBackground: string;
            emphasisForeground: string;
        };
        table: {
            background: string;
            boxShadow: string;
            header: {
                background: string;
                foreground: string;
                border: string;
            };
            row: {
                background: string;
                foreground: string;
                hoverBackground: string;
                border: string;
                /** `Table`'s `selectedRowKey` tint. Must stay distinguishable from
                 *  `hoverBackground`: a selected row keeps this tint under the cursor. */
                selectedBackground: string;
                /** Leading accent bar on that same row. */
                selectedAccent: string;
                /** Cascades, so cells setting their own colour are deliberately unaffected. */
                selectedForeground: string;
            };
            border: string;
            borderedRow: {
                background: string;
                outline: string;
            };
            rowVariant: {
                success: {
                    background: string;
                };
                warning: {
                    background: string;
                };
                error: {
                    background: string;
                };
                info: {
                    background: string;
                };
            };
            error: {
                iconBackground: string;
                iconForeground: string;
                titleForeground: string;
                subtitleForeground: string;
            };
        };
        text: {
            primary: string;
            secondary: string;
            dimmed: string;
            emphasis: string;
            muted: string;
            placeholder: string;
            destructive: string;
            success: string;
            highlight: string;
            warning: string;
            warningMuted: string;
            error: string;
            info: string;
            linkForeground: string;
            linkForegroundHover: string;
            rightSideText: {
                muted: string;
                primary: string;
                alignment: 'left' | 'right';
                fontSize: string;
                minWidth: string;
            };
        };
        codeBlock: {
            background: string;
            foreground: string;
            border: string;
            lineNumber: string;
            keyword: string;
            comment: string;
            string: string;
            number: string;
            type: string;
            diffAddedBackground: string;
            diffRemovedBackground: string;
            diffAssistantBackground: string;
            diffAssistantForeground: string;
            diffAssistantRemovedBackground: string;
            diffRemovedForeground: string;
            diffContextForeground: string;
            diffContextText: string;
        };
        /** The conversation's own surfaces — message bubbles, not chrome around them. */
        chat: {
            userBubbleBackground: string;
            userBubbleBorder: string;
            assistantBubbleBackground: string;
            assistantBubbleBorder: string;
            assistantBubbleForeground: string;
        };
        /** Chrome marking machine-authored content outside the conversation itself
         *  (badges, diff callouts) — distinct from `chat`, which is the conversation's
         *  own bubbles. */
        assistant: {
            foreground: string;
            surfaceBackground: string;
            surfaceBorder: string;
            /** Body text sitting on `surfaceBackground` — darker/muted so a run of it reads,
             *  unlike `foreground`, which is the vivid accent. */
            surfaceForeground: string;
        };
    };
}

export declare const ManageTeamIcon: React.FC<IconProps_61>;

export declare const ManualWebhookIcon: React.FC<IconProps_62>;

export declare interface MarkdownProps {
    text: string;
    color?: TextColor;
    size?: FontSize;
    omitMargin?: boolean;
    variant?: MarkdownVariant;
    normalizeSource?: boolean;
}

export declare type MarkdownVariant = 'block' | 'flow';

export declare const MarkReadIcon: React.FC<IconProps_63>;

export declare const MarkUnreadIcon: React.FC<IconProps_64>;

export declare const MembersIcon: React.FC<IconProps_65>;

export declare const Modal: default_2.FC<ModalProps>;

export declare const ModalIcon: React.FC<IconProps_66>;

export declare interface ModalProps {
    open: boolean;
    /** Dismiss handler — close button, ESC, or overlay click. */
    onClose: () => void;
    title: default_2.ReactNode;
    /** Secondary line beneath the title. */
    subtitle?: default_2.ReactNode;
    /** Leading header slot, typically an icon or logo. */
    icon?: default_2.ReactNode;
    /** Content pinned right in the header, before the close button. */
    headerExtra?: default_2.ReactNode;
    titleAdornment?: default_2.ReactNode;
    tray?: {
        tone?: ModalTrayTone;
        caption?: {
            label?: string;
            message: string;
        };
    };
    /** Divider under the header. Default: false. */
    headerDivider?: boolean;
    /** Pinned action row below the scrolling body. */
    footer?: default_2.ReactNode;
    size?: ModalSize;
    /** Default: true. */
    showCloseButton?: boolean;
    /** Default: true. Turn off for a dialog whose choice must be made deliberately. */
    closeOnOverlayClick?: boolean;
    /** Whether the body gets default padding. Default: true. */
    bodyPadding?: boolean;
    /**
     * `alertdialog` for a dialog interrupting the user over a consequential choice — it
     * tells assistive tech to announce the body, not just the name.
     */
    role?: 'dialog' | 'alertdialog';
    /** Accessible dialog name; required when `title` isn't a plain string. */
    'aria-label'?: string;
    /** ID of a visible element naming the dialog (alternative to `aria-label`). */
    'aria-labelledby'?: string;
    /** ID of the element describing what the dialog is asking. */
    'aria-describedby'?: string;
    /**
     * Work is in flight: suppresses the pointer dismissal routes and announces the busy
     * state. Never ESC — that is the only guaranteed keyboard exit from a focus trap, so it
     * always reaches `onClose` and whether to abort is left to the caller.
     */
    busy?: boolean;
    children: default_2.ReactNode;
}

export declare type ModalSize = 'small' | 'medium' | 'large';

export declare type ModalTrayTone = 'neutral' | 'warning' | 'error' | 'success';

export declare const MoreHorizontalIcon: React.FC<IconProps_67>;

export declare const MoreVerticalIcon: React.FC<IconProps_68>;

export declare const MultiSelect: default_2.FC<MultiSelectProps>;

declare interface MultiSelectBaseProps {
    options: MultiSelectOption[];
    /** Controlled value. When provided, component is fully controlled. */
    value?: string[];
    /** Initial value for uncontrolled usage (like Dropdown's defaultValue). */
    defaultValue?: string[];
    onChange?: (next: string[]) => void;
    placeholder?: string;
    renderTrigger?: (selected: MultiSelectOption[]) => default_2.ReactNode;
    searchable?: boolean;
    /** 'large' (42px) for form inputs; 'medium' (32px) for toolbar chips; 'small' (28px) beside a title. */
    size?: MultiSelectSize;
    width?: string | number;
    minWidth?: number;
    disabled?: boolean;
    error?: boolean;
    loading?: boolean;
    label?: string;
    description?: string;
    tooltip?: string;
    hint?: string;
    rightSideContent?: RightSideContent;
    required?: boolean;
    requiredIndicator?: RequiredIndicator;
    /** Show selected values as chips instead of "N selected" text */
    chips?: boolean;
    /** Show × button on each chip to remove it (only when chips=true) */
    chipsRemovable?: boolean;
    /** Max visible chips. 'auto' = show all chips. Number = hard limit with "+N" badge */
    chipsMax?: number | 'auto';
    /** Search input inside the trigger field instead of external search bar */
    inlineSearch?: boolean;
    /**
     * Called with the query as typed, and with `''` whenever the component clears it — on
     * select, and on close — so a consumer's request stays in step with what is on screen.
     *
     * For a list too large to load in full: fire the request here and pass the results back
     * as `options`. Pair it with `localFilter={false}`, or the component filters the answer
     * the server already filtered. Debouncing is left to the caller, who is the only one who
     * knows what a request costs.
     */
    onSearchChange?: (query: string) => void;
    /**
     * Whether this component filters `options` itself. Default true.
     *
     * Set false when the options already reflect the query. A server commonly matches on
     * fields the label does not contain — an account found by its owner's email, say — and
     * filtering again here would hide precisely those matches.
     */
    localFilter?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
    /** Names the trigger from the light DOM, where `htmlFor` cannot reach into the shadow root. */
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
}

export declare interface MultiSelectOption {
    value: string;
    label: default_2.ReactNode;
    searchText?: string;
    /** Prevent toggling or removing this option — used for mandatory/locked selections */
    disabled?: boolean;
    /** Right-aligned badge shown in the dropdown only (not in chips) */
    badge?: default_2.ReactNode;
    /** Description text for this option */
    description?: string;
    /** How description renders — 'icon': info icon with tooltip, 'subtitle': text below label, 'hover': tooltip on label. Default: 'icon' */
    descriptionMode?: 'icon' | 'subtitle' | 'hover';
    /** Custom icon for 'icon' mode. Default: built-in ⓘ */
    descriptionIcon?: default_2.ReactNode;
    /** Truncate subtitle after N lines. Only applies to 'subtitle' mode */
    descriptionMaxLines?: number;
}

export declare type MultiSelectProps = (MultiSelectBaseProps & {
    formControl: Control<FieldValues, unknown>;
    name: string;
}) | (MultiSelectBaseProps & {
    formControl?: undefined;
    name?: string;
});

export declare type MultiSelectSize = 'small' | 'medium' | 'large';

export declare const NavbarCollapseIcon: React.FC<IconProps_69>;

export declare const NavbarExpandIcon: React.FC<IconProps_70>;

export declare const NotFoundIcon: React.FC<IconProps_71>;

export declare const NumberTag: default_2.FC<NumberTagProps>;

export declare interface NumberTagProps {
    value: number | string;
    emphasis?: boolean;
    /**
     * Names the bare number for assistive tech — "3 schemas" rather than "3". Rendered as
     * visually-hidden text, because `aria-label` on a plain span is not honoured.
     */
    'aria-label'?: string;
    className?: string;
}

export declare const OrganizationIcon: React.FC<IconProps_72>;

export declare const OverflowRow: default_2.FC<OverflowRowProps>;

declare interface OverflowRowProps {
    children?: default_2.ReactNode;
    gap?: number | string;
    align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
    justify?: 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly';
    className?: string;
    renderOverflow?: (hiddenCount: number) => default_2.ReactNode;
}

export declare const Padded: default_2.FC<PaddedProps>;

declare interface PaddedProps {
    vertical: PaddingSize_2;
    horizontal: PaddingSize_2;
    children: default_2.ReactNode;
    fullHeight?: boolean;
    className?: string;
    overflow?: 'hidden' | 'visible' | 'scroll' | 'auto';
}

export declare enum PaddingSize {
    XSmall = "xsmall",
    Small = "small",
    Medium = "medium",
    Large = "large"
}

declare type PaddingSize_2 = 'xsmall' | 'small' | 'medium' | 'large' | 'none';

declare type PaddingSize_3 = 'default' | 'compact';

export declare interface PageAction {
    label: string;
    /** Ignored when `href` is set. */
    onClick?: () => void;
    disabled?: boolean;
    variant?: ButtonVariant;
    icon?: default_2.ReactNode;
    href?: string;
    /** Defaults to `_blank`. */
    target?: '_self' | '_blank';
    tooltip?: string;
    tooltipPlacement?: 'top' | 'bottom' | 'left' | 'right';
    dividerBefore?: boolean;
}

/**
 * The page's action buttons, collapsing into an overflow menu as the row narrows. Exported so
 * a page that renders its own header block — e.g. one that scrolls the title away — keeps the
 * same behaviour instead of hand-rolling `buttons.map(...)` and losing the collapse, the
 * dividers and the href handling.
 */
export declare const PageActions: default_2.FC<{
    buttons: PageAction[];
}>;

declare type PageContentGap = 'small' | 'medium' | 'large' | 'xlarge';

export declare const PageLayout: {
    Regular: FC<RegularLayoutProps>;
    Empty: FC<EmptyLayoutProps>;
};

declare interface PageTitleProps {
    children: default_2.ReactNode;
    margin?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare interface PartialMalachiteTheme {
    fontSizes?: Partial<MalachiteTheme['fontSizes']>;
    iconSizes?: Partial<MalachiteTheme['iconSizes']>;
    radius?: Partial<MalachiteTheme['radius']>;
    controlHeights?: Partial<MalachiteTheme['controlHeights']>;
    shadows?: Partial<MalachiteTheme['shadows']>;
    colors?: {
        shadowColor?: string;
        shadowOpacity?: number;
        card?: Partial<MalachiteTheme['colors']['card']>;
        overlay?: Partial<MalachiteTheme['colors']['overlay']>;
        /** Nested-partial: a sub-object may be overridden leaf by leaf. A flat
         *  `Partial<…>` would demand every leaf of any group you touch. */
        alert?: {
            [K in keyof MalachiteTheme['colors']['alert']]?: Partial<MalachiteTheme['colors']['alert'][K]>;
        };
        tooltip?: Partial<MalachiteTheme['colors']['tooltip']>;
        primary?: Partial<MalachiteTheme['colors']['primary']>;
        accent?: Partial<NonNullable<MalachiteTheme['colors']['accent']>>;
        control?: Partial<MalachiteTheme['colors']['control']>;
        outline?: Partial<MalachiteTheme['colors']['outline']>;
        secondary?: Partial<MalachiteTheme['colors']['secondary']>;
        destructive?: Partial<MalachiteTheme['colors']['destructive']>;
        success?: Partial<MalachiteTheme['colors']['success']>;
        warning?: Partial<MalachiteTheme['colors']['warning']>;
        error?: Partial<MalachiteTheme['colors']['error']>;
        buttonList?: Partial<MalachiteTheme['colors']['buttonList']>;
        pillButton?: Partial<MalachiteTheme['colors']['pillButton']>;
        toggle?: Partial<MalachiteTheme['colors']['toggle']>;
        segmentedControl?: Partial<MalachiteTheme['colors']['segmentedControl']>;
        selectableCard?: Partial<MalachiteTheme['colors']['selectableCard']>;
        cardStrip?: Partial<MalachiteTheme['colors']['cardStrip']>;
        selectionBar?: Partial<MalachiteTheme['colors']['selectionBar']>;
        inlineConfirm?: Partial<MalachiteTheme['colors']['inlineConfirm']>;
        dropdown?: Partial<MalachiteTheme['colors']['dropdown']>;
        tag?: {
            [K in keyof MalachiteTheme['colors']['tag']]?: Partial<MalachiteTheme['colors']['tag'][K]>;
        };
        numberTag?: Partial<MalachiteTheme['colors']['numberTag']>;
        table?: Partial<Omit<MalachiteTheme['colors']['table'], 'header' | 'row' | 'borderedRow' | 'rowVariant' | 'error'>> & {
            header?: Partial<MalachiteTheme['colors']['table']['header']>;
            row?: Partial<MalachiteTheme['colors']['table']['row']>;
            borderedRow?: Partial<MalachiteTheme['colors']['table']['borderedRow']>;
            rowVariant?: {
                [K in keyof MalachiteTheme['colors']['table']['rowVariant']]?: Partial<MalachiteTheme['colors']['table']['rowVariant'][K]>;
            };
            error?: Partial<MalachiteTheme['colors']['table']['error']>;
        };
        text?: Partial<Omit<MalachiteTheme['colors']['text'], 'rightSideText'>> & {
            rightSideText?: Partial<MalachiteTheme['colors']['text']['rightSideText']>;
        };
        codeBlock?: Partial<MalachiteTheme['colors']['codeBlock']>;
        chat?: Partial<MalachiteTheme['colors']['chat']>;
        assistant?: Partial<MalachiteTheme['colors']['assistant']>;
    };
}

declare type PhraseLabel = string | {
    prefix: string;
    suffix?: string;
};

export declare const PillButton: default_2.FC<PillButtonProps>;

declare interface PillButtonProps {
    label: string;
    icon?: default_2.ReactNode;
    className?: string;
    selected?: boolean;
    disabled?: boolean;
    interactive?: boolean;
    size?: PillButtonSize;
    variant?: PillButtonVariant;
    shape?: PillButtonShape;
    tone?: PillButtonTone;
    /** Sits after the label — a caret on a pill that opens a menu. */
    trailingIcon?: default_2.ReactNode;
    onClick?: () => void;
}

/**
 * `tab` squares the top corners so the pill reads as attached to whatever sits above it —
 * a row of controls hanging under an input, rather than free-floating pills.
 */
declare type PillButtonShape = 'pill' | 'tab';

declare type PillButtonSize = 'xsmall' | 'small' | 'medium';

/**
 * `assistant` is the chrome for AI-authored chips (e.g. `ChangeReview.Jump`): a fixed
 * violet-on-white look with its own border, independent of `variant`/`selected`.
 */
declare type PillButtonTone = 'default' | 'assistant';

declare type PillButtonVariant = 'default' | 'inverted';

export declare const PinIcon: React.FC<IconProps_73>;

export declare const PlusIcon: React.FC<IconProps_74>;

export declare const PreviewIcon: React.FC<IconProps_75>;

/** A translucent rounded card that groups {@link PreviewTreeRow}s into a tree preview. */
export declare const PreviewTree: default_2.FC<PreviewTreeProps>;

declare interface PreviewTreeProps {
    children: default_2.ReactNode;
}

export declare const PreviewTreeRow: default_2.FC<PreviewTreeRowProps>;

declare interface PreviewTreeRowProps {
    icon: default_2.ReactNode;
    label: string;
    tag: string;
    highlighted?: boolean;
    indented?: boolean;
    onToggle?: () => void;
    expanded?: boolean;
}

export declare const ProgrammaticWebhookIcon: React.FC<IconProps_76>;

export declare const Progress: default_2.FC<ProgressProps>;

declare interface ProgressCommonProps {
    height?: number;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    /** Spoken instead of the range, which reads as 100% once segments fill the track. */
    'aria-valuetext'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/** One fill or a list of segments, never both — `color`/`trackColor` mean nothing to segments. */
export declare type ProgressProps = ProgressValueProps | ProgressSegmentsProps;

export declare interface ProgressSegment {
    /** Portion of `max` this segment covers, in the same units. */
    value: number;
    variant?: ProgressSegmentVariant;
    fill?: ProgressSegmentFill;
}

/** `hatched` reads as claimed-but-unpaid-for — usage past an allowance, not more of it. */
export declare type ProgressSegmentFill = 'solid' | 'hatched';

declare interface ProgressSegmentsProps extends ProgressCommonProps {
    segments: ProgressSegment[];
    /** Scale the segments measure against. Defaults to their sum, and a larger sum wins. */
    max?: number;
    value?: never;
    color?: never;
    trackColor?: never;
}

/**
 * Semantic colour role for a segment. Colours come from theme tokens by design — unlike
 * `color`/`trackColor`, which predate that rule, there is no free-form colour here. To
 * restyle a role, override its token via `applyTheme` / `applyCustomTheme`.
 */
export declare type ProgressSegmentVariant = 'default' | 'success' | 'warning' | 'error' | 'info';

declare interface ProgressValueProps extends ProgressCommonProps {
    value: number;
    color?: string;
    trackColor?: string;
    segments?: never;
    max?: never;
}

export declare const PulseIcon: React.FC<IconProps_77>;

export declare const QueryInput: default_2.FC<QueryInputProps>;

export declare interface QueryInputProps {
    value: string;
    onChange: (value: string) => void;
    /** Ranges to colour. Tokens that are out of range, reversed or overlapping are ignored. */
    tokens?: QueryToken[];
    /** Rows for the caret menu. Empty or undefined means the menu stays closed. */
    suggestions?: QuerySuggestion[];
    /** The span an accepted suggestion replaces. Defaults to a zero-width span at the caret. */
    activeRange?: {
        start: number;
        end: number;
    };
    onAccept?: (suggestion: QuerySuggestion) => void;
    /** Every value change AND every caret move, so the consumer can recompute tokens/suggestions. */
    onQueryContextChange?: (context: {
        value: string;
        caret: number;
    }) => void;
    /** Enter with nothing highlighted in the menu. */
    onSubmit?: (value: string) => void;
    placeholder?: string;
    size?: QueryInputSize;
    disabled?: boolean;
    /** Suggestions are being fetched: the menu shows a loading row instead of the empty message. */
    loading?: boolean;
    emptyMessage?: string;
    className?: string;
    style?: default_2.CSSProperties;
    'aria-label'?: string;
    'aria-labelledby'?: string;
}

export declare type QueryInputSize = 'small' | 'medium' | 'large';

export declare interface QuerySuggestion {
    id: string;
    label: string;
    /** Secondary text, right-aligned in the row. */
    detail?: string;
    /** What replaces `activeRange` when accepted. Defaults to `label`. */
    insertText?: string;
}

export declare interface QueryToken {
    /** Index into `value`. */
    start: number;
    /** Exclusive. */
    end: number;
    kind: QueryTokenKind;
}

export declare type QueryTokenKind = 'key' | 'value' | 'operator' | 'negation' | 'punctuation' | 'error' | 'plain';

export declare const Radio: default_2.FC<RadioProps>;

export declare interface RadioProps {
    checked: boolean;
    /** Optional when `presentational` — a presentational radio is a visual indicator only. */
    onChange?: (checked: boolean) => void;
    disabled?: boolean;
    size?: number;
    /**
     * Render a visual-only indicator (a non-interactive, non-focusable `<span>`,
     * `aria-hidden`) instead of an interactive radio. Use this inside a clickable
     * row/card whose wrapper is the real control, so there's a single tab stop.
     */
    presentational?: boolean;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    id?: string;
}

export declare const RefreshIcon: React.FC<IconProps_78>;

export declare interface RegularLayoutProps {
    breadcrumbLinks?: BreadcrumbLink[];
    breadcrumbActions?: PageAction[];
    renderLink?: RenderBreadcrumbLink;
    title?: default_2.ReactNode;
    titleSuffix?: default_2.ReactNode;
    subtitle?: string;
    description?: default_2.ReactNode;
    buttons?: PageAction[];
    /**
     * Hides the buttons and skeletons the title. `subtitle` and `description` are only
     * skeletoned when those props are also passed.
     */
    loading?: boolean;
    children: default_2.ReactNode;
    centered?: boolean;
    noPadding?: boolean;
    contentGap?: PageContentGap;
    alert?: {
        message: string;
        type?: AlertType;
    };
    /** Demotes the default `main` landmark — pass e.g. `region` when the app owns its own. */
    role?: default_2.AriaRole;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const RejectIcon: React.FC<IconProps_79>;

export declare const ReloadIcon: React.FC<IconProps_80>;

/**
 * Renders a crumb or the back button through the app's own link component, spreading every
 * field onto it. A client-side-routed consumer MUST pass this, or navigation breaks.
 */
declare type RenderBreadcrumbLink = (props: {
    href: string;
    children: default_2.ReactNode;
    className?: string;
    'aria-current'?: 'page';
    'aria-label'?: string;
}) => default_2.ReactNode;

export declare const ReplyIcon: React.FC<IconProps_81>;

export declare const RequiredFieldIndicatorIcon: React.FC<IconProps_82>;

export declare type RequiredIndicator = 'optional-suffix' | 'asterisk' | 'none';

/**
 * Reset theme to default values
 */
export declare function resetTheme(): void;

/**
 * What sits at the far end of a field's label row. Data rather than a node, so nothing
 * arbitrary reaches the row; discriminated so a further kind is additive. Plain text is
 * already `hint`.
 */
export declare type RightSideContent = {
    type?: 'link';
    text: string;
    href: string;
};

declare const Row: default_2.FC<KeyValueListRowProps>;

export declare type RowVariant = 'success' | 'warning' | 'error' | 'info';

export declare const Search: default_2.FC<SearchProps>;

export declare const SearchIcon: React.FC<IconProps_83>;

export declare interface SearchProps {
    value: string;
    onChange: (value: string) => void;
    placeholder?: string;
    /** 'large' (42px) for form inputs; 'medium' (32px) for toolbars; 'small' (28px) in a table. */
    size?: SearchSize;
    variant?: SearchVariant;
    disabled?: boolean;
    autoFocus?: boolean;
    className?: string;
    width?: string | number;
    style?: default_2.CSSProperties;
}

export declare type SearchSize = 'small' | 'medium' | 'large';

export declare type SearchVariant = 'default' | 'muted';

declare interface SecondaryTextProps {
    children: default_2.ReactNode;
    fontWeight?: FontWeight;
    size?: FontSize;
    textTransform?: 'uppercase' | 'lowercase' | 'capitalize' | 'none';
    className?: string;
    style?: default_2.CSSProperties;
}

declare interface SectionTitleProps {
    children: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const SecurityIcon: React.FC<IconProps_84>;

/**
 * A rounded track of mutually-exclusive options — the segmented "one of these" control.
 *
 * Owns the track background, the selected-thumb chrome and the radiogroup semantics in
 * one place, so consumers never hand-roll a track around `PillButton` (whose `default`
 * variant tokens are tuned for standalone filter pills, not for a sunken track).
 *
 * Selection is conveyed non-visually via `role="radio"` + `aria-checked`, and by a
 * foreground-colour change as well as the thumb, so it does not rest on background
 * colour alone.
 */
export declare const SegmentedControl: <T extends string = string>({ options, value, onChange, size, fullWidth, disabled, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, className, }: SegmentedControlProps<T>) => JSX_2.Element;

export declare interface SegmentedControlOption<T extends string = string> {
    value: T;
    label: string;
    icon?: default_2.ReactNode;
    disabled?: boolean;
}

export declare interface SegmentedControlProps<T extends string = string> {
    options: SegmentedControlOption<T>[];
    /** The selected option's value. A value not present in `options` renders nothing selected. */
    value: T;
    onChange: (value: T) => void;
    size?: SegmentedControlSize;
    /** Stretch the track to its container and split it into equal segments. */
    fullWidth?: boolean;
    /** Disables every segment. Individual segments can also be disabled via `options`. */
    disabled?: boolean;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
}

export declare type SegmentedControlSize = 'small' | 'medium' | 'large';

/** A fixed-size card that behaves as one option in a radio group: a card-shaped `Surface.Row`. */
export declare const SelectableCard: default_2.FC<SelectableCardProps>;

export declare interface SelectableCardProps {
    /** Identifies the card inside its group; handed back to `onSelect`. */
    value: string;
    title: string;
    /** Leading glyph on the title line, e.g. a library/book icon. */
    titleIcon?: default_2.ReactNode;
    /** Pins the card as the account default, marked beside the title. */
    isDefault?: boolean;
    /** Palette only — gradient, borders, indicator and eyebrow; position is settled by the strip. */
    variant?: SelectableCardVariant;
    /** Small label above the title ("Profile", "Explore"). */
    eyebrow?: string;
    /** Status pill rendered next to the eyebrow — or in its place when there is no eyebrow. */
    status?: SelectableCardStatus;
    /** Supporting copy under the title, clamped to two lines. */
    description?: string;
    /** Bottom-left summary ("16 Actions", "10 Selected"). */
    countLabel?: string;
    /** Top-right cluster (markers, an ActionMenu…). The eyebrow row gives way to one
     *  xsmall control; a wider cluster needs a shorter eyebrow and status to clear it. */
    actions?: default_2.ReactNode;
    selected?: boolean;
    /** Replaces the card's content with a centred in-progress message. */
    loading?: boolean;
    loadingLabel?: string;
    loadingHint?: string;
    /** Blocks selection. Draws no dimming of its own — a switched-off profile is signalled by its `status` tag. */
    disabled?: boolean;
    /** Mutes the title without blocking selection. */
    dimmed?: boolean;
    onSelect?: (value: string) => void;
    /** Tab stop for the card. */
    tabIndex?: number;
    /** Replaces the generated accessible name (eyebrow + title + status). */
    'aria-label'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare interface SelectableCardStatus {
    label: string;
    /** Maps to Tag's palette — `default` (grey) for "Disabled", `warning` (amber) for "Draft". */
    type?: TagType;
}

/** The card's palette: `profile` is green, `library` neutral, `editing` amber for a
 *  profile with unsaved changes. */
export declare type SelectableCardVariant = 'profile' | 'library' | 'editing';

/**
 * A bar reporting a pending, not-yet-written selection and the actions that resolve it. Every
 * action destroys the button just pressed, so an `onClick` that ends the pending state must
 * also move focus.
 */
export declare const SelectionBar: default_2.FC<SelectionBarProps>;

export declare interface SelectionBarAction {
    label: string;
    onClick: () => void;
    /** 'primary' commits the pending change; 'secondary' (the default) is a filled chip;
     *  'quiet' is unfilled and takes a wash on hover. */
    emphasis?: SelectionBarEmphasis;
    icon?: default_2.ReactNode;
    iconPosition?: 'start' | 'end';
    disabled?: boolean;
    /** Renders a separator glyph before this action. */
    dividerBefore?: boolean;
}

/** A `value + label` pair, e.g. `{ value: 3, label: 'Added' }`. */
export declare interface SelectionBarCount {
    value: string | number;
    label: string;
}

export declare type SelectionBarEmphasis = 'primary' | 'secondary' | 'quiet';

export declare interface SelectionBarProps {
    /** Drives the mount: the bar animates in on true and animates out on false. */
    open: boolean;
    counts: SelectionBarCount[];
    actions: SelectionBarAction[];
    /** 'sticky' keeps the bar in view while its container scrolls; render it as the last child
     *  of that content, with no `overflow: hidden` on any ancestor. */
    placement?: 'sticky' | 'inline';
    /**
     * Wraps the bar in a warning sleeve carrying this message, for state the bar is
     * reporting rather than an action it offers — e.g. that the selection is unsaved.
     * It leads the announcement. An empty string renders no sleeve.
     */
    notice?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
}

export declare const SendIcon: React.FC<IconProps_85>;

export declare const SettingRow: default_2.FC<SettingRowProps>;

/** The ids a control needs to name and describe itself from the row's own text. */
export declare interface SettingRowControlIds {
    labelId: string;
    descriptionId?: string;
}

export declare interface SettingRowProps {
    label: string;
    /** Small badge after the label, e.g. a `Tag`. */
    badge?: default_2.ReactNode;
    /** Explanation rendered under the row, outside its border. */
    description?: default_2.ReactNode;
    /** The control on the trailing edge. Passed the row's ids: a control `<label htmlFor>`
     *  cannot reach must name itself with `aria-labelledby`. */
    control: default_2.ReactNode | ((ids: SettingRowControlIds) => default_2.ReactNode);
    className?: string;
}

export declare const SettingsIcon: React.FC<IconProps_86>;

/**
 * ShadowEscape renders its children OUTSIDE the Shadow DOM to avoid React hook issues.
 * This is used internally by form components to escape Shadow DOM boundaries.
 *
 * The component finds the nearest non-shadow DOM ancestor and renders there.
 */
export declare const ShadowEscape: default_2.FC<ShadowEscapeProps>;

declare interface ShadowEscapeProps {
    children: default_2.ReactNode;
    className?: string;
}

/**
 * A right-hand slide-in overlay panel (drawer) for inspecting or editing an entity
 * without leaving the page. Portals to `document.body`, locks background scroll and
 * traps keyboard focus while open (restoring both on close), dismisses on ESC
 * (topmost open overlay only), overlay click or the close button, and exposes header
 * (back/icon/title/subtitle/extra), scrollable body and optional footer slots.
 */
export declare const SidePanel: default_2.FC<SidePanelProps>;

export declare const SidePanelNavFooter: default_2.FC<SidePanelNavFooterProps>;

export declare interface SidePanelNavFooterProps {
    onNavigateUp?: () => void;
    onNavigateDown?: () => void;
    canNavigateUp?: boolean;
    canNavigateDown?: boolean;
    actions?: default_2.ReactNode;
    className?: string;
}

export declare interface SidePanelProps {
    open: boolean;
    /** Dismiss handler — close button, ESC, or overlay click. */
    onClose: () => void;
    title: default_2.ReactNode;
    /** Secondary text, inline after the title. */
    subtitle?: default_2.ReactNode;
    /** Content at the end of the title row, after the subtitle (e.g. a status tag). */
    titleExtra?: default_2.ReactNode;
    /** Block paragraph below the title row, spanning the header width. */
    description?: default_2.ReactNode;
    /** Divider under the header. Default: false. */
    headerDivider?: boolean;
    /** Leading header slot, typically a logo or icon. */
    icon?: default_2.ReactNode;
    /** Content pinned right in the header, before the close button. */
    headerExtra?: default_2.ReactNode;
    footer?: default_2.ReactNode;
    /** Renders a back button before the header icon. */
    onBack?: () => void;
    /** Maximum panel width. Default: 1080. */
    maxWidth?: number | string;
    /** Accessible dialog name; required when `title` isn't a plain string. */
    'aria-label'?: string;
    /** ID of a visible element naming the dialog (alternative to `aria-label`). */
    'aria-labelledby'?: string;
    /** Whether the body gets default padding. Default: true. */
    bodyPadding?: boolean;
    /** `above-app-overlays` lifts the overlay stack clear of chrome pinned near max-int. */
    stacking?: 'default' | 'above-app-overlays';
    children: default_2.ReactNode;
}

export declare const SignOutIcon: React.FC<IconProps_87>;

export declare const Skeleton: {
    Button: default_2.FC<SkeletonButtonProps>;
    Input: default_2.FC<SkeletonInputProps>;
    Avatar: default_2.FC<SkeletonAvatarProps>;
};

declare interface SkeletonAvatarProps extends BaseSkeletonProps {
    size?: SkeletonSize | number;
    shape?: 'circle' | 'square';
}

declare interface SkeletonButtonProps extends BaseSkeletonProps {
    size?: SkeletonSize;
    shape?: SkeletonShape;
    block?: boolean;
    width?: number | string;
    height?: number | string;
    minWidth?: number | string;
}

declare interface SkeletonInputProps extends BaseSkeletonProps {
    size?: SkeletonSize;
    block?: boolean;
    width?: number | string;
    height?: number | string;
    minWidth?: number | string;
}

declare type SkeletonShape = 'default' | 'round' | 'circle' | 'square';

declare type SkeletonSize = 'small' | 'default' | 'large';

export declare const SliderIcon: React.FC<IconProps_88>;

export declare const SortIcon: React.FC<IconProps_89>;

export declare const SourceIcon: React.FC<IconProps_90>;

export declare const Spacer: default_2.FC<SpacerProps>;

declare interface SpacerProps {
    direction?: 'horizontal' | 'vertical';
    size?: number;
    align?: 'center' | 'start' | 'end' | 'baseline' | 'stretch';
    justifyContent?: 'space-between' | 'end' | 'center';
    padding?: string;
    children: default_2.ReactNode;
    id?: string;
    fullHeight?: boolean;
    fullWidth?: boolean;
    className?: string;
}

export declare enum SpacingSize {
    XSmall = "xsmall",
    Small = "small",
    Medium = "medium",
    Large = "large"
}

export declare const SparkleIcon: React.FC<IconProps_91>;

export declare const Spinner: default_2.FC<SpinnerProps>;

declare interface SpinnerProps {
    size?: 'xxxsmall' | 'xxsmall' | 'xsmall' | 'small' | 'medium' | 'large';
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const SplitScreenLayout: default_2.FC<SplitScreenLayoutProps>;

declare interface SplitScreenLayoutProps {
    left: default_2.ReactNode;
    right: default_2.ReactNode;
    logo?: default_2.ReactNode;
    onClose?: () => void;
    footer?: default_2.ReactNode;
}

export declare const StarIcon: React.FC<IconProps_92>;

export declare const StatBadge: default_2.FC<StatBadgeProps>;

export declare interface StatBadgeProps {
    /** The numeric value shown in the pill. */
    count: number;
    /** Caption shown next to the pill. */
    label: string;
    className?: string;
}

export declare const Statistic: default_2.FC<StatisticProps>;

declare interface StatisticLabelProps {
    bold?: boolean;
    children: default_2.ReactNode;
    secondary?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare interface StatisticProps {
    label: string | default_2.ReactNode;
    value: string | number | default_2.ReactNode;
    sub?: string | default_2.ReactNode;
    accent?: string;
    valueSize?: StatisticValueSize;
    width?: string | number;
    minWidth?: string | number;
    padding?: string;
    align?: 'left' | 'center' | 'right';
    className?: string;
    style?: default_2.CSSProperties;
}

declare interface StatisticValueProps {
    children: default_2.ReactNode;
    secondary?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare type StatisticValueSize = 'small' | 'medium' | 'large';

export declare const StatusBadge: default_2.FC<StatusBadgeProps>;

/**
 * How much of the badge the glyph fills.
 *
 * `default` is half the diameter, which is the right proportion at the sizes a badge is
 * usually drawn. `bold` is for the small end: at the 14px a table row gives it, half a
 * badge is a mark under 3px tall, and the tone is doing all the work.
 *
 * `bold` takes the glyph's box to the full diameter rather than merely most of it, so the
 * box and the badge share an edge. Anything short of that leaves a fractional margin at odd
 * sizes (13px inside 14px), which the browser rounds onto one side and draws off centre.
 * Nothing collides with the edge: the furthest point of any glyph is the tick's, at 86% of
 * the radius.
 */
export declare type StatusBadgeGlyph = 'default' | 'bold';

export declare interface StatusBadgeProps {
    type?: StatusBadgeType;
    size?: number;
    glyph?: StatusBadgeGlyph;
    className?: string;
    'aria-label'?: string;
}

export declare type StatusBadgeType = 'success' | 'error' | 'warning' | 'info';

export declare const StepCurrentIcon: React.FC<IconProps_93>;

export declare const Stepper: default_2.FC<StepperProps>;

export declare interface StepperProps {
    /** Total number of steps. */
    steps: number;
    /** Active step index (0-based). */
    active: number;
    /** When provided, each step becomes a clickable control. */
    onChange?: (index: number) => void;
    className?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
}

export declare interface StepTabItem {
    key: string;
    label: string;
    /** Position marker shown at the trailing edge. Defaults to `Step ${index + 1}`. */
    hint?: string;
    disabled?: boolean;
}

/**
 * A horizontal step navigator whose steps are destinations, unlike the read-only `Stepper`.
 * Each step is a button with `aria-current="step"`, not a tab.
 */
export declare const StepTabs: default_2.FC<StepTabsProps>;

export declare interface StepTabsProps {
    items: StepTabItem[];
    activeKey: string;
    /** Steps already satisfied. They render a check and stay reachable, so a user can go back. */
    completedKeys?: string[];
    onChange: (key: string) => void;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
}

export declare const StepUpcomingIcon: React.FC<IconProps_94>;

export declare type SubtitleLayout = 'inline' | 'stacked';

export declare const Surface: SurfaceComponent;

declare interface SurfaceComponent extends default_2.FC<SurfaceProps> {
    Row: default_2.FC<SurfaceRowProps>;
}

export declare interface SurfaceProps {
    children?: default_2.ReactNode;
    padding?: boolean;
    /**
     * Content overflow. Defaults to `hidden` so children are clipped to the rounded
     * corners. Use `clip` to keep the rounded clipping WITHOUT creating a scroll
     * container — so a `position: sticky` descendant still pins (unlike `hidden`,
     * which traps it). `visible` disables clipping entirely.
     */
    overflow?: 'hidden' | 'visible' | 'clip';
    role?: default_2.AriaRole;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * A single full-bleed row inside a <Surface>. Owns the row chrome — hover
 * highlight, colour transition and an optional bottom divider — so consumers
 * compose their own content inside without re-implementing design-system styling.
 * Pass `onClick`/`href` to make the entire row clickable (rendered as a real
 * button/anchor, so keyboard navigation works natively).
 */
export declare const SurfaceRow: default_2.FC<SurfaceRowProps>;

export declare interface SurfaceRowProps {
    children?: default_2.ReactNode;
    /** Renders a bottom divider — omit on the last row in a Surface. */
    divider?: boolean;
    /** Removes the hover affordance / disables the control (e.g. while loading/busy). */
    disabled?: boolean;
    /**
     * When provided, the whole row becomes clickable: it renders as a `<button>`
     * (or `<a>` when `href` is set), so the entire row is the click target with
     * native focus + Enter/Space — no manual tabIndex/key handlers. For a
     * selectable row, put a presentational `<Radio>`/`<Checkbox>` inside as the
     * visual indicator; do NOT nest an interactive control (invalid + double tab stop).
     */
    onClick?: (event: default_2.MouseEvent) => void;
    /** Renders the clickable row as an anchor instead of a button. */
    href?: string;
    /** Announces the row as selected — `aria-checked` under a `radio`/`checkbox` role,
     *  `aria-current` otherwise — and paints `Table`'s selected treatment unless `selection`
     *  says not to. */
    selected?: boolean;
    /** How a `selected` row shows it. `highlight` paints the treatment; `announce` leaves the
     *  visual to a control inside the row and only sets the ARIA state. Defaults to `announce`
     *  under `role="checkbox"` and `highlight` otherwise. */
    selection?: 'highlight' | 'announce';
    /** Content pinned right, outside the row button, so it may hold its own control. */
    trailing?: default_2.ReactNode;
    /** `muted` tints a row whose subject is inactive — not disabled: it stays interactive. */
    tone?: 'default' | 'muted';
    /** ARIA role for a clickable row, e.g. `radio`/`checkbox` (wrap the list in a `radiogroup`). */
    role?: default_2.AriaRole;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const Swatch: default_2.FC<SwatchProps>;

export declare interface SwatchProps {
    color?: string;
    size?: number;
    on?: boolean;
    radius?: number;
    children?: default_2.ReactNode;
    onClick?: () => void;
    'aria-label'?: string;
    'aria-pressed'?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const SyntheticWebhookIcon: React.FC<IconProps_95>;

export declare interface TabItem {
    key: string;
    label: default_2.ReactNode;
    disabled?: boolean;
}

export declare const Table: <T = Record<string, unknown>>({ columns, data, loading, error, errorTitle, errorSubTitle, emptyTitle, emptySubTitle, bordered, showHeader, rowKey, scrollHeight, size, rowDensity, layout, headerVariant, rowClassName, rowVariant, onRow, onClickRow, selectedRowKey, scrollSelectedIntoView, rowSelection, pagination, className, style, stickyHeaderTop, scrollX, rowSection, renderSectionDivider, onVisibleOrderChange, virtual, virtualRowHeightEstimate, virtualScrollElement, }: TableProps<T>) => JSX_2.Element;

export declare type TableColumnDefinition<T = Record<string, unknown>> = {
    title: string | default_2.ReactNode;
    /** Explanatory text shown in a tooltip behind an info icon next to the title. */
    info?: string;
    dataIndex: keyof T | (string & {});
    key: string;
    width?: string | number;
    minWidth?: number;
    ellipsis?: boolean;
    render?: (value: unknown, record?: T, index?: number) => default_2.ReactNode;
    sorter?: boolean | ((a: T, b: T) => number);
    sortIcon?: (props: {
        sortOrder: 'desc' | 'asc' | null;
    }) => default_2.ReactNode;
    onHeaderCell?: (data: T, index?: number) => default_2.HTMLAttributes<HTMLTableCellElement> | default_2.TdHTMLAttributes<HTMLTableCellElement>;
    defaultSortOrder?: 'ascend' | 'descend';
    sortDirections?: ('ascend' | 'descend')[];
    fixed?: 'left' | 'right';
    align?: 'left' | 'center' | 'right';
};

export declare type TableColumns<T = Record<string, unknown>> = TableColumnDefinition<T>[];

declare type TableHeaderVariant = 'inline' | 'detached';

export declare type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';

declare type TableProps<T = Record<string, unknown>> = {
    columns: TableColumns<T>;
    data: T[];
    loading?: boolean;
    error?: boolean;
    errorTitle?: string;
    errorSubTitle?: string;
    emptyTitle?: string;
    emptySubTitle?: string;
    bordered?: boolean;
    showHeader?: boolean;
    rowKey?: string | ((record: T) => string);
    scrollHeight?: string | number;
    type?: TableType;
    size?: TableSize;
    /** Vertical density of body rows. 'compact' halves the cell padding so
     *  rows carrying controls (buttons, dropdowns) sit close to text-row
     *  height; headers keep their own padding. */
    rowDensity?: 'default' | 'compact';
    layout?: 'fixed' | 'auto';
    headerVariant?: TableHeaderVariant;
    rowClassName?: (record: T, index: number) => string;
    rowVariant?: (record: T, index: number) => RowVariant | undefined;
    onRow?: (record: T, index: number) => TableRowActions<T>;
    onClickRow?: (record: T, index: number) => void;
    /** Row the master-detail view is showing, resolved against `rowKey`. Controlled, so
     *  selection can change without a row click and the highlight follows. Unlike
     *  `rowSelection` it paints no control — a tint, an accent bar and `aria-current`.
     *  Follows its record through a sort only with a resolvable `rowKey`. */
    selectedRowKey?: default_2.Key;
    /** Whether a selection change scrolls the row into view. Default true.
     *
     *  Set `false` when the initial key comes from a URL: the reveal uses `scrollIntoView`,
     *  which walks every scrollable ancestor, so a deep-linked row below the fold jumps the
     *  page on load. Selection still highlights; only the scroll is suppressed. */
    scrollSelectedIntoView?: boolean;
    rowSelection?: TableRowSelection<T>;
    pagination?: {
        current?: number;
        pageSize?: number;
        total?: number;
        showSizeChanger?: boolean;
        showQuickJumper?: boolean;
        showTotal?: (total: number, range: [number, number]) => default_2.ReactNode;
        pageSizeOptions?: string[];
        position?: TablePaginationPosition[];
        onChange?: (page: number, pageSize: number) => void;
        onShowSizeChange?: (current: number, size: number) => void;
    };
    className?: string;
    style?: default_2.CSSProperties;
    /** When set, makes the detached-variant header sticky at this offset (px) from the
     *  top of the nearest scrolling ancestor. Use this when the table sits inside a
     *  page-level scroll container with other sticky elements (e.g. tabs + toolbar)
     *  stacked above. */
    stickyHeaderTop?: number;
    scrollX?: boolean;
    rowSection?: (record: T) => string;
    renderSectionDivider?: (sectionKey: string, records: T[]) => default_2.ReactNode;
    /** Reports the rows in render order — sorted and section-grouped, so not `data` order,
     *  and always all of `data`. An equal-but-new array does not re-fire, so a host cannot loop.
     *  Needs a `rowKey`, or records that keep their object identity across renders. */
    onVisibleOrderChange?: TableVisibleOrderHandler<T>;
    /** Windowed rendering for large datasets (detached variant only), powered by
     *  TanStack Virtual: only rows near the viewport stay mounted; spacers keep the
     *  scrollbar reflecting the full list. The table body becomes the scroll
     *  container, so give it a bounded height via `scrollHeight`. Row heights are
     *  measured per row (non-uniform rows are fine). */
    virtual?: boolean;
    /** Estimated row height (px) used by `virtual` before rows are measured. */
    virtualRowHeightEstimate?: number;
    /** With `virtual`: virtualize against this ancestor scroll container instead of
     *  the table body (e.g. a page-level scroller so content above the table can
     *  scroll away). Pass the element from state (not a ref) so it arrives after
     *  mount. The table body stops scrolling when this is set. */
    virtualScrollElement?: HTMLElement | null;
};

declare type TableRowActions<T = Record<string, unknown>> = {
    onClick?: (record: T, index: number) => void;
    onDoubleClick?: (record: T, index: number) => void;
    onContextMenu?: (record: T, index: number) => void;
    onMouseEnter?: (record: T, index: number) => void;
    onMouseLeave?: (record: T, index: number) => void;
};

export declare type TableRowSelection<T = Record<string, unknown>> = {
    type?: 'checkbox' | 'radio';
    selectedRowKeys?: default_2.Key[];
    onChange?: (selectedRowKeys: default_2.Key[], selectedRows: T[]) => void;
    onSelect?: (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
    getCheckboxProps?: (record: T) => {
        disabled?: boolean;
        name?: string;
    };
    hideSelectAll?: boolean;
    preserveSelectedRowKeys?: boolean;
    fixed?: boolean;
    columnWidth?: string | number;
    columnTitle?: string | default_2.ReactNode;
    selections?: boolean | default_2.ReactNode[];
};

export declare type TableSize = 'small' | 'medium' | 'large';

export declare type TableType = 'default' | 'compact' | 'bordered';

/** Receives the table's rows in render order — see `Table`'s `onVisibleOrderChange`. */
export declare type TableVisibleOrderHandler<T = Record<string, unknown>> = (records: readonly T[]) => void;

export declare const Tabs: default_2.FC<TabsProps>;

export declare interface TabsProps {
    items: TabItem[];
    activeKey: string;
    onChange: (key: string) => void;
    trailing?: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const Tag: default_2.FC<TagProps>;

declare type TagFontSize = 'xsmall' | 'small' | 'medium';

export declare interface TagProps {
    value: string | number | default_2.ReactNode;
    /** Defaults to 12px. Use `xsmall` for a secondary badge beside a primary one. */
    fontSize?: TagFontSize;
    type?: TagType;
    bordered?: boolean;
    shadow?: boolean;
    textTransform?: 'none' | 'uppercase';
    width?: WidthSize;
    paddingSize?: PaddingSize_3;
    icon?: default_2.ReactNode;
    iconPosition?: 'left' | 'right';
    iconColor?: TextColor;
    pointerType?: 'pointer' | 'default';
    onClick?: () => void;
    onRemove?: (e: default_2.MouseEvent) => void;
    className?: string;
}

export declare type TagType = 'primary' | 'secondary' | 'default' | 'error' | 'warning' | 'success' | 'emphasis' | 'info'
/** Marks content a machine produced rather than a person — provenance, not severity. */
| 'assistant';

declare interface TerminalTextProps {
    bold?: boolean;
    size?: FontSize;
    children: default_2.ReactNode;
    color?: TextColor;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const TextArea: default_2.FC<TextAreaProps>;

declare interface TextAreaProps {
    label?: string;
    hint?: string;
    tooltip?: string;
    placeholder?: string;
    icon?: default_2.ReactNode;
    readOnly?: boolean;
    name: FieldPath<FieldValues> | string;
    description?: string;
    size?: TextAreaSize;
    required?: boolean;
    requiredIndicator?: RequiredIndicator;
    error?: boolean;
    loading?: boolean;
    defaultValue?: string;
    disabled?: boolean;
    prefixValue?: string;
    prefixSecondaryValue?: string;
    ellipsis?: boolean;
    formControl?: Control<FieldValues, unknown>;
    buttons?: ButtonDefinition_2[];
    onCopyClick?: () => void;
    onChange?: (value: string) => void;
    value?: string;
    onBlur?: () => void;
    /** Key handling the control cannot own, e.g. Enter-to-submit in a chat composer. */
    onKeyDown?: (event: default_2.KeyboardEvent<HTMLTextAreaElement>) => void;
    /**
     * A control that belongs inside the field, pinned bottom-right — a chat composer's send.
     * The field reserves room for it, so text cannot run underneath.
     */
    inFieldAction?: default_2.ReactNode;
    /** See `TextAreaTone`. Defaults to `'default'`, so no existing field changes. */
    tone?: TextAreaTone;
    helperText?: string;
    rows?: number;
    /**
     * Grows the field from `rows` up to this many lines as content is typed, then scrolls
     * internally rather than growing further. Omitted keeps the field at a fixed `rows`
     * height, the pre-existing behaviour.
     */
    maxRows?: number;
    maxLength?: number;
    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
    /**
     * When false, lines are not soft-wrapped — long content scrolls horizontally
     * instead of wrapping (native `wrap="off"`). Useful for one-value-per-line
     * content like URLs. Defaults to true.
     */
    wrap?: boolean;
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
}

declare type TextAreaSize = 'small' | 'medium' | 'large';

/**
 * `assistant` is the chrome for a field sitting in an AI context (e.g. `Chat.Composer`'s
 * policy-assistant tone): the field's own focus border recolours to the assistant violet
 * instead of the default accent — same indicator, different colour, not an extra one. Same
 * naming precedent as `PillButton`'s own `tone`.
 */
declare type TextAreaTone = 'default' | 'assistant';

export declare type TextColor = 'primary' | 'secondary' | 'dimmed' | 'placeholder' | 'emphasis' | 'muted' | 'destructive' | 'success' | 'highlight' | 'warning' | 'error' | 'info' | 'link'
/** Machine-authored text — what an assistant wrote, or what it is proposing. */
| 'assistant' | 'inherit';

export declare interface TextProps {
    color?: TextColor;
    size?: FontSize;
    /**
     * Typeface. Defaults to `sans` (Inter), the library's body face. `heading` is Stack Sans
     * Text and `body` is Geist — both are loaded on mount and declared in the theme.
     */
    font?: FontFamily;
    underline?: boolean;
    fontWeight?: FontWeight;
    children: default_2.ReactNode;
    tooltip?: string;
    textAlign?: 'left' | 'center' | 'right' | 'justify';
    className?: string;
    style?: default_2.CSSProperties;
}

export declare type ThemeMode = 'light' | 'dark';

/**
 * Pins a subtree to a fixed Malachite theme via its own shadow root — a themed island (e.g. a dark
 * panel in a light app). The dedicated root is required: theme tokens are scoped per shadow root.
 */
export declare const ThemeScope: default_2.FC<ThemeScopeProps>;

export declare interface ThemeScopeProps {
    mode?: ThemeMode;
    fontFamily?: string;
    className?: string;
    style?: default_2.CSSProperties;
    children?: default_2.ReactNode;
}

export declare const ThumbsDownIcon: React.FC<IconProps_96>;

export declare const ThumbsUpIcon: React.FC<IconProps_97>;

export declare const Toggle: default_2.ForwardRefExoticComponent<ToggleProps & default_2.RefAttributes<HTMLElement>>;

declare interface ToggleProps {
    checked: boolean;
    onChange: (checked: boolean) => void;
    disabled?: boolean;
    size?: ToggleSize;
    tone?: ToggleTone;
    /** Visible text shown before the switch (e.g. a filter label). */
    label?: string;
    /**
     * Chrome for a toolbar filter — pick the family it sits beside. `pill` is the
     * filter-bar look that matches `Search`/`MultiSelect`; `button` renders the whole
     * control as an outline `Button`. Setting this implies `bordered`.
     */
    variant?: ToggleVariant;
    /** Shorthand for `variant="pill"`. */
    bordered?: boolean;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
    className?: string;
    id?: string;
}

export declare type ToggleSize = 'small' | 'medium';

/**
 * Toggle between light and dark themes
 */
export declare function toggleTheme(): 'light' | 'dark';

/** What the checked state means. 'pending' paints the track amber, for a switch whose change
 *  has not been written yet. The unchecked track is unaffected. */
export declare type ToggleTone = 'default' | 'pending';

/**
 * Which family of toolbar controls the chrome should match. `pill` matches the
 * filter-bar inputs (`Search`, `MultiSelect`); `button` matches the buttons.
 */
export declare type ToggleVariant = 'pill' | 'button';

export declare const Toolbar: ToolbarComponent;

export declare const TOOLBAR_FILL_BASIS_PX = 260;

export declare const TOOLBAR_FILL_MIN_WIDTH_PX = 200;

export declare const TOOLBAR_FILTER_MIN_WIDTH_PX = 160;

export declare const TOOLBAR_FILTER_WIDTH_PX = 200;

declare interface ToolbarComponent extends default_2.FC<ToolbarProps> {
    Fill: typeof ToolbarFill;
    Item: typeof ToolbarItem;
}

declare const ToolbarFill: default_2.FC<ToolbarFillProps>;

export declare interface ToolbarFillProps {
    children?: default_2.ReactNode;
    minWidth?: number;
    className?: string;
    style?: default_2.CSSProperties;
}

declare const ToolbarItem: default_2.FC<ToolbarItemProps>;

export declare interface ToolbarItemProps {
    children?: default_2.ReactNode;
    width?: number;
    minWidth?: number;
    grow?: boolean;
    className?: string;
    style?: default_2.CSSProperties;
}

export declare interface ToolbarProps {
    children?: default_2.ReactNode;
    /** Draw a bottom divider — for a bar that sits above scrolling/list content. */
    divider?: boolean;
    /** Padding preset (applies to both axes). `none` for a bar that must sit flush with
     *  the content it pins over — the consumer then owns the gutter. */
    padding?: 'none' | 'compact' | 'default';
    layout?: 'plain' | 'filters';
    className?: string;
    style?: default_2.CSSProperties;
}

export declare const Tooltip: default_2.FC<TooltipProps>;

declare interface TooltipProps {
    text: default_2.ReactNode | string;
    children: default_2.ReactNode;
    delay?: number;
    wrapChildren?: boolean;
    placement?: 'top' | 'bottom' | 'left' | 'right';
    isShrinkable?: boolean;
    fill?: boolean;
    /** Max width of tooltip. Default: 320px */
    maxWidth?: number | string;
    /** Called synchronously when the trigger is hovered/focused; return false to
     *  suppress the tooltip for this interaction. Lets wrappers defer expensive
     *  checks (e.g. truncation measurement) to interaction time instead of mount. */
    shouldShow?: () => boolean;
    triggerAs?: 'div' | 'span';
    /** Whether the tooltip acts as the trigger's accessible description. False where the
     *  trigger already points at the same sentence on screen, so it is not announced twice. */
    describesTrigger?: boolean;
}

export declare const TrashIcon: React.FC<IconProps_98>;

export declare const TriangleDownIcon: React.FC<IconProps_99>;

export declare const TriangleRightIcon: React.FC<IconProps_100>;

/**
 * TruncatedTooltip renders its children in a single-line truncating container
 * (overflow:hidden + text-overflow:ellipsis + white-space:nowrap) and surfaces
 * the malachite Tooltip only when the content is actually being cut off.
 *
 * Truncation is checked at interaction time (Tooltip's `shouldShow`), not at
 * mount: a mount-time measurement forces a synchronous layout per instance,
 * and in large tables those reads interleave with other components' DOM writes
 * — hundreds of full layout passes per mounted batch (the Safari row-mount
 * stalls of ENG-1168). The ellipsis itself is pure CSS and needs no JS.
 */
export declare const TruncatedTooltip: default_2.FC<TruncatedTooltipProps>;

export declare interface TruncatedTooltipProps {
    text: default_2.ReactNode | string;
    children: default_2.ReactNode;
    delay?: number;
    placement?: 'top' | 'bottom' | 'left' | 'right';
    className?: string;
}

export declare const Typography: {
    CodeText: FC<CodeTextProps>;
    EllipsisText: FC<EllipsisTextProps>;
    FormSectionTitle: FC<FormSectionTitleProps>;
    LinkText: FC<LinkProps_2>;
    MarkdownBlock: NamedExoticComponent<MarkdownProps>;
    PageTitle: FC<PageTitleProps>;
    SecondaryText: FC<SecondaryTextProps>;
    SectionTitle: FC<SectionTitleProps>;
    StatisticLabel: FC<StatisticLabelProps>;
    StatisticValue: FC<StatisticValueProps>;
    TerminalText: FC<TerminalTextProps>;
    Text: FC<TextProps>;
};

export declare const UnarchiveIcon: React.FC<IconProps_101>;

export declare const UploadIcon: React.FC<IconProps_102>;

/**
 * Whether a SidePanel or Modal is open anywhere, for host chrome that has to move out of the way.
 * Overlays portal, so the only other signal is this module's markers, which a host cannot read
 * without coupling to an internal. Dropdowns and tooltips do not count: they trap no focus.
 */
export declare const useHasOpenOverlay: () => boolean;

export declare const WarningCircleFilled: React.FC<IconProps_103>;

export declare const WarningTriangleIcon: React.FC<IconProps_104>;

export declare const WebhookEventsIcon: React.FC<IconProps_105>;

export declare const WebhookIcon: React.FC<IconProps_106>;

export declare const WebhookSigningSecretIcon: React.FC<IconProps_107>;

export declare type WidthSize = 'large' | 'medium' | 'small' | 'xsmall';

export declare const WizardLayout: default_2.FC<WizardLayoutProps>;

export declare interface WizardLayoutProps {
    /** Renders the outline back button in the top-left slot. */
    showBack?: boolean;
    onBack?: () => void;
    backDisabled?: boolean;
    /** Top-left slot beside the back button — e.g. a user avatar menu. */
    leading?: default_2.ReactNode;
    /** Right top-bar slot (sits just before `stepper`) — e.g. a theme toggle. */
    stepper?: default_2.ReactNode;
    /** Far-right top-bar slot — e.g. a theme toggle. */
    trailing?: default_2.ReactNode;
    /**
     * Pinned below the top bar and always visible while the content scrolls —
     * e.g. connection logos + a step title. Rendered in the same centred column
     * as the content (`contentWidth`).
     */
    header?: default_2.ReactNode;
    /** Pinned to the bottom of the screen — typically a <FooterNav /> or a primary CTA. */
    footer?: default_2.ReactNode;
    /**
     * Give the pinned footer a frosted-glass treatment (translucent background +
     * backdrop blur) so scrolling content shows through it. The footer already sits
     * above sticky body content, so it reads as glass over the scrolling list.
     */
    footerGlass?: boolean;
    /** Vertically centre the content (used for terminal/success screens). */
    center?: boolean;
    /** Max width of the centered content column. */
    contentWidth?: number;
    /** Minimum width of the whole layout, below which it scrolls horizontally. */
    minWidth?: number;
    children?: default_2.ReactNode;
    className?: string;
}

export { }