@vireocodedev/ui

export declare const BOOLEAN_ARRAY: [
    true,
    false
];

Country and territory identifiers with 3:2 flag assets shipped by country-flag-icons.

/** Country and territory identifiers with 3:2 flag assets shipped by country-flag-icons. */
export declare const COUNTRY_CODES: readonly [
    "AC",
    "AD",
    "AE",
    "AF",
    "AG",
    "AI",
    "AL",
    "AM",
    "AO",
    "AQ",
    "AR",
    "AS",
    "AT",
    "AU",
    "AW",
    "AX",
    "AZ",
    "BA",
    "BB",
    "BD",
    "BE",
    "BF",
    "BG",
    "BH",
    "BI",
    "BJ",
    "BL",
    "BM",
    "BN",
    "BO",
    "BQ-BO",
    "BQ-SA",
    "BQ-SE",
    "BQ",
    "BR",
    "BS",
    "BT",
    "BV",
    "BW",
    "BY",
    "BZ",
    "CA",
    "CC",
    "CD",
    "CF",
    "CG",
    "CH",
    "CI",
    "CK",
    "CL",
    "CM",
    "CN",
    "CO",
    "CR",
    "CU",
    "CV",
    "CW",
    "CX",
    "CY",
    "CZ",
    "DE",
    "DJ",
    "DK",
    "DM",
    "DO",
    "DZ",
    "EC",
    "EE",
    "EG",
    "EH",
    "ER",
    "ES-CT",
    "ES",
    "ET",
    "EU",
    "FI",
    "FJ",
    "FK",
    "FM",
    "FO",
    "FR",
    "GA",
    "GB-ENG",
    "GB-NIR",
    "GB-SCT",
    "GB-WLS",
    "GB",
    "GD",
    "GE",
    "GF",
    "GG",
    "GH",
    "GI",
    "GL",
    "GM",
    "GN",
    "GP",
    "GQ",
    "GR",
    "GS",
    "GT",
    "GU",
    "GW",
    "GY",
    "HK",
    "HM",
    "HN",
    "HR",
    "HT",
    "HU",
    "IC",
    "ID",
    "IE",
    "IL",
    "IM",
    "IN",
    "IO",
    "IQ",
    "IR",
    "IS",
    "IT",
    "JE",
    "JM",
    "JO",
    "JP",
    "KE",
    "KG",
    "KH",
    "KI",
    "KM",
    "KN",
    "KP",
    "KR",
    "KW",
    "KY",
    "KZ",
    "LA",
    "LB",
    "LC",
    "LI",
    "LK",
    "LR",
    "LS",
    "LT",
    "LU",
    "LV",
    "LY",
    "MA",
    "MC",
    "MD",
    "ME",
    "MF",
    "MG",
    "MH",
    "MK",
    "ML",
    "MM",
    "MN",
    "MO",
    "MP",
    "MQ",
    "MR",
    "MS",
    "MT",
    "MU",
    "MV",
    "MW",
    "MX",
    "MY",
    "MZ",
    "NA",
    "NC",
    "NE",
    "NF",
    "NG",
    "NI",
    "NL",
    "NO",
    "NP",
    "NR",
    "NU",
    "NZ",
    "OM",
    "PA",
    "PE",
    "PF",
    "PG",
    "PH",
    "PK",
    "PL",
    "PM",
    "PN",
    "PR",
    "PS",
    "PT",
    "PW",
    "PY",
    "QA",
    "RE",
    "RO",
    "RS",
    "RU",
    "RW",
    "SA",
    "SB",
    "SC",
    "SD",
    "SE",
    "SG",
    "SH",
    "SI",
    "SJ",
    "SK",
    "SL",
    "SM",
    "SN",
    "SO",
    "SR",
    "SS",
    "ST",
    "SV",
    "SX",
    "SY",
    "SZ",
    "TA",
    "TC",
    "TD",
    "TF",
    "TG",
    "TH",
    "TJ",
    "TK",
    "TL",
    "TM",
    "TN",
    "TO",
    "TR",
    "TT",
    "TV",
    "TW",
    "TZ",
    "UA",
    "UG",
    "UM",
    "US",
    "UY",
    "UZ",
    "VA",
    "VC",
    "VE",
    "VG",
    "VI",
    "VN",
    "VU",
    "WF",
    "WS",
    "XA",
    "XC",
    "XK",
    "XO",
    "YE",
    "YT",
    "ZA",
    "ZM",
    "ZW"
];

Identifier backed by a 3:2 flag asset in country-flag-icons.

/** Identifier backed by a 3:2 flag asset in country-flag-icons. */
export type CountryCode = z.infer<typeof CountryCodeSchema>;

Runtime schema for identifiers backed by country-flag-icons.

/** Runtime schema for identifiers backed by country-flag-icons. */
export declare const CountryCodeSchema: z.ZodEnum<{
    AC: "AC";
    AD: "AD";
    AE: "AE";
    AF: "AF";
    AG: "AG";
    AI: "AI";
    AL: "AL";
    AM: "AM";
    AO: "AO";
    AQ: "AQ";
    AR: "AR";
    AS: "AS";
    AT: "AT";
    AU: "AU";
    AW: "AW";
    AX: "AX";
    AZ: "AZ";
    BA: "BA";
    BB: "BB";
    BD: "BD";
    BE: "BE";
    BF: "BF";
    BG: "BG";
    BH: "BH";
    BI: "BI";
    BJ: "BJ";
    BL: "BL";
    BM: "BM";
    BN: "BN";
    BO: "BO";
    BQ: "BQ";
    "BQ-BO": "BQ-BO";
    "BQ-SA": "BQ-SA";
    "BQ-SE": "BQ-SE";
    BR: "BR";
    BS: "BS";
    BT: "BT";
    BV: "BV";
    BW: "BW";
    BY: "BY";
    BZ: "BZ";
    CA: "CA";
    CC: "CC";
    CD: "CD";
    CF: "CF";
    CG: "CG";
    CH: "CH";
    CI: "CI";
    CK: "CK";
    CL: "CL";
    CM: "CM";
    CN: "CN";
    CO: "CO";
    CR: "CR";
    CU: "CU";
    CV: "CV";
    CW: "CW";
    CX: "CX";
    CY: "CY";
    CZ: "CZ";
    DE: "DE";
    DJ: "DJ";
    DK: "DK";
    DM: "DM";
    DO: "DO";
    DZ: "DZ";
    EC: "EC";
    EE: "EE";
    EG: "EG";
    EH: "EH";
    ER: "ER";
    ES: "ES";
    "ES-CT": "ES-CT";
    ET: "ET";
    EU: "EU";
    FI: "FI";
    FJ: "FJ";
    FK: "FK";
    FM: "FM";
    FO: "FO";
    FR: "FR";
    GA: "GA";
    GB: "GB";
    "GB-ENG": "GB-ENG";
    "GB-NIR": "GB-NIR";
    "GB-SCT": "GB-SCT";
    "GB-WLS": "GB-WLS";
    GD: "GD";
    GE: "GE";
    GF: "GF";
    GG: "GG";
    GH: "GH";
    GI: "GI";
    GL: "GL";
    GM: "GM";
    GN: "GN";
    GP: "GP";
    GQ: "GQ";
    GR: "GR";
    GS: "GS";
    GT: "GT";
    GU: "GU";
    GW: "GW";
    GY: "GY";
    HK: "HK";
    HM: "HM";
    HN: "HN";
    HR: "HR";
    HT: "HT";
    HU: "HU";
    IC: "IC";
    ID: "ID";
    IE: "IE";
    IL: "IL";
    IM: "IM";
    IN: "IN";
    IO: "IO";
    IQ: "IQ";
    IR: "IR";
    IS: "IS";
    IT: "IT";
    JE: "JE";
    JM: "JM";
    JO: "JO";
    JP: "JP";
    KE: "KE";
    KG: "KG";
    KH: "KH";
    KI: "KI";
    KM: "KM";
    KN: "KN";
    KP: "KP";
    KR: "KR";
    KW: "KW";
    KY: "KY";
    KZ: "KZ";
    LA: "LA";
    LB: "LB";
    LC: "LC";
    LI: "LI";
    LK: "LK";
    LR: "LR";
    LS: "LS";
    LT: "LT";
    LU: "LU";
    LV: "LV";
    LY: "LY";
    MA: "MA";
    MC: "MC";
    MD: "MD";
    ME: "ME";
    MF: "MF";
    MG: "MG";
    MH: "MH";
    MK: "MK";
    ML: "ML";
    MM: "MM";
    MN: "MN";
    MO: "MO";
    MP: "MP";
    MQ: "MQ";
    MR: "MR";
    MS: "MS";
    MT: "MT";
    MU: "MU";
    MV: "MV";
    MW: "MW";
    MX: "MX";
    MY: "MY";
    MZ: "MZ";
    NA: "NA";
    NC: "NC";
    NE: "NE";
    NF: "NF";
    NG: "NG";
    NI: "NI";
    NL: "NL";
    NO: "NO";
    NP: "NP";
    NR: "NR";
    NU: "NU";
    NZ: "NZ";
    OM: "OM";
    PA: "PA";
    PE: "PE";
    PF: "PF";
    PG: "PG";
    PH: "PH";
    PK: "PK";
    PL: "PL";
    PM: "PM";
    PN: "PN";
    PR: "PR";
    PS: "PS";
    PT: "PT";
    PW: "PW";
    PY: "PY";
    QA: "QA";
    RE: "RE";
    RO: "RO";
    RS: "RS";
    RU: "RU";
    RW: "RW";
    SA: "SA";
    SB: "SB";
    SC: "SC";
    SD: "SD";
    SE: "SE";
    SG: "SG";
    SH: "SH";
    SI: "SI";
    SJ: "SJ";
    SK: "SK";
    SL: "SL";
    SM: "SM";
    SN: "SN";
    SO: "SO";
    SR: "SR";
    SS: "SS";
    ST: "ST";
    SV: "SV";
    SX: "SX";
    SY: "SY";
    SZ: "SZ";
    TA: "TA";
    TC: "TC";
    TD: "TD";
    TF: "TF";
    TG: "TG";
    TH: "TH";
    TJ: "TJ";
    TK: "TK";
    TL: "TL";
    TM: "TM";
    TN: "TN";
    TO: "TO";
    TR: "TR";
    TT: "TT";
    TV: "TV";
    TW: "TW";
    TZ: "TZ";
    UA: "UA";
    UG: "UG";
    UM: "UM";
    US: "US";
    UY: "UY";
    UZ: "UZ";
    VA: "VA";
    VC: "VC";
    VE: "VE";
    VG: "VG";
    VI: "VI";
    VN: "VN";
    VU: "VU";
    WF: "WF";
    WS: "WS";
    XA: "XA";
    XC: "XC";
    XK: "XK";
    XO: "XO";
    YE: "YE";
    YT: "YT";
    ZA: "ZA";
    ZM: "ZM";
    ZW: "ZW";
}>;

Options for resolving a localized country or territory display name.

/** Options for resolving a localized country or territory display name. */
export type CountryNameOptions = {
    /** Already-localized names that take precedence over Vireo and platform data. */
    overrides?: Partial<Record<CountryCode, string>>;
};

export declare const DEFAULT_DESKTOP_SIDE_PANEL_MIN_CONTENT_WIDTH = 420;

export declare const DEFAULT_DESKTOP_SIDE_PANEL_MIN_WIDTH = 360;

export declare const DEFAULT_DESKTOP_SIDE_PANEL_VIEWPORT_INSET = 48;

export declare const DESKTOP_SIDE_PANEL_WIDTH_BY_MAX_WIDTH: Record<Exclude<DialogProps["maxWidth"], undefined | false>, number>;

export declare const DOCKED_SIDE_PANEL_TRANSITION_EVENT = "responsive-overlay:docked-side-panel-transition";

export declare const DOCKED_SIDE_PANEL_TRANSITION_MS: 180;

export declare const DateFormat: {
    readonly API_DATE_TIME: "YYYY-MM-DDTHH:mm";
    readonly API_DATE: "YYYY-MM-DD";
    readonly API_TIME: "HH:mm";
    readonly CLIENT_DATE_TIME: "DD.MM.YYYY HH:mm";
    readonly CLIENT_DATE: "DD.MM.YYYY";
    readonly CLIENT_TIME: "HH:mm";
};
export type DateFormat = (typeof DateFormat)[keyof typeof DateFormat];

export type DateFormatConfig = Partial<{
    format: DateFormat;
    unit: "seconds" | "milliseconds";
}>;

export type DelayedOverlayRenderProps = {
    open: boolean;
    onClose: () => void;
    onExited: () => void;
};

export type DockedSidePanelTransitionEventDetail = {
    animating: boolean;
};

export declare const EMPTY_ARRAY: [
];

export type GuardedOverlayModeSwitch<TPayloadByMode extends Record<string, unknown>> = <TMode extends keyof TPayloadByMode>(mode: TMode, payload: TPayloadByMode[TMode], beforeOpen?: () => void) => void;

export type OverlayPayloadMap = Record<string, unknown>;

export type OverlayRendererProps = DelayedOverlayRenderProps & {
    onExited: () => void;
};

export type OverlayRenderers<TMap extends OverlayPayloadMap> = {
    [K in keyof TMap]: (props: OverlayRendererProps, payload: TMap[K]) => React.ReactElement | null;
};

export type OverlayState<TMap extends OverlayPayloadMap> = {
    mode: "none";
} | {
    [K in keyof TMap]: {
        mode: K;
        payload: TMap[K];
    };
}[keyof TMap];

Registers a single overlay with the controller and portals its content into the shared outlet. Pass a falsy {@link render} while the overlay is unmounted.

/**
 * Registers a single overlay with the controller and portals its content into
 * the shared outlet. Pass a falsy {@link render} while the overlay is unmounted.
 */
export declare function PageOverlay({ overlayKey, open, onRequestClose, render }: PageOverlayProps): React.ReactPortal | null;

export declare const PageOverlayControllerContext: React.Context<PageOverlayControllerValue | null>;

App-level controller for page overlays. Overlays register here and portal their content into a single shared outlet, so the create/update form and the history overlay render from the same place. Opening any overlay closes the others (mutual exclusion), while each overlay keeps its own mount lifecycle so open/close transitions animate normally.

/**
 * App-level controller for page overlays. Overlays register here and portal
 * their content into a single shared outlet, so the create/update form and the
 * history overlay render from the same place. Opening any overlay closes the
 * others (mutual exclusion), while each overlay keeps its own mount lifecycle so
 * open/close transitions animate normally.
 */
export declare function PageOverlayControllerProvider({ children }: {
    children: React.ReactNode;
}): React.JSX.Element;

export type PageOverlayControllerValue = {
    hostElement: HTMLElement | null;
    setHostElement: (element: HTMLElement | null) => void;
    register: (key: string, requestClose: () => void) => void;
    unregister: (key: string) => void;
    requestExclusive: (key: string) => void;
};

export declare function PageOverlayOutlet(): React.JSX.Element;

export type PageOverlayProps = {
    overlayKey?: string;
    open: boolean;
    onRequestClose: () => void;
    render: React.ReactNode | (() => React.ReactNode);
};

A React state setter accepted by controlled application contracts.

/** A React state setter accepted by controlled application contracts. */
export type ReactStateSetter<T> = Dispatch<SetStateAction<T>>;

export type ResponsiveOverlayFrameDesktopSidePanelWidth = number | string | Partial<Record<Breakpoint, number | string>>;

export type ResponsiveOverlayFrameDesktopSurface = "dialog" | "overlaySidePanel" | "dockedSidePanel";

export declare const SIDE_PANEL_RESIZE_ACTIVE_OPACITY = 0.7;

export declare const SIDE_PANEL_RESIZE_HANDLE_WIDTH = 6;

export declare const SIDE_PANEL_RESIZE_HITBOX_WIDTH = 24;

export declare const SIDE_PANEL_RESIZE_HOVER_OPACITY = 0.35;

export declare const SIDE_PANEL_RESIZE_KEYBOARD_STEP = 16;

export declare const SIDE_PANEL_WIDTH_CSS_VAR = "--responsive-overlay-side-panel-width";

Portable component type for exported MUI styled slots.

/** Portable component type for exported MUI styled slots. */
export type StyledSlotComponent<TProps extends object, TOwnerState extends object> = ComponentType<TProps & StyledSlotProps<TOwnerState> & {
    as?: ElementType;
}>;

Internal props shared by MUI styled slots that react to component owner state.

/** Internal props shared by MUI styled slots that react to component owner state. */
export type StyledSlotProps<TOwnerState extends object> = {
    ownerState: TOwnerState;
};

export declare const UnsavedChangesContext: React.Context<UnsavedChangesContextValue>;

export type UnsavedChangesContextValue = {
    removeRegistration: (id: string) => void;
    requestDiscard: (request: UnsavedChangesDiscardRequest) => void;
    runWithoutNavigationBlock: <T>(action: () => T) => T;
    upsertRegistration: (registration: UnsavedChangesRegistration) => void;
};

export type UnsavedChangesDiscardRequest = {
    onDiscard: () => void | Promise<void>;
    scopeId?: string | null;
};

export type UnsavedChangesRegistration = {
    busy: boolean;
    dirty: boolean;
    id: string;
    scopeId?: string;
};

export type UnsavedChangesRegistry = {
    getSnapshot: () => ReadonlyMap<string, UnsavedChangesRegistration>;
    getStatus: (scopeId?: UnsavedChangesScopeId) => UnsavedChangesStatus;
    isNavigationBlockBypassed: () => boolean;
    removeRegistration: (id: string) => void;
    runWithoutNavigationBlock: <T>(action: () => T) => T;
    subscribe: (listener: () => void) => () => void;
    upsertRegistration: (registration: UnsavedChangesRegistration) => void;
};

export declare function UnsavedChangesScope({ children, id }: UnsavedChangesScopeProps): React.JSX.Element;

export declare const UnsavedChangesScopeContext: React.Context<string | undefined>;

export type UnsavedChangesScopeId = string | null | undefined;

export type UnsavedChangesScopeProps = {
    children: React.ReactNode;
    id?: string;
};

export type UnsavedChangesStatus = {
    busy: boolean;
    dirty: boolean;
};

export type UseDelayedOverlayMountReturn = {
    mounted: boolean;
    open: boolean;
    openOverlay: () => void;
    closeOverlay: () => void;
    onExited: () => void;
    render: (children: (props: DelayedOverlayRenderProps) => React.ReactNode) => React.ReactNode;
};

export type UseMeasuredVireoPageLayoutOptions = {
    /** Controls the layout mode without measuring a container. */
    mode?: VireoPageLayoutMode;
    /** Resolves compact mode without measuring a container. @default false */
    forceCompact?: boolean;
    /** Measures the referenced element's parent instead of the element itself. @default false */
    measureParent?: boolean;
    /** Suspends measurement while preserving the last resolved mode. @default false */
    paused?: boolean;
    /** Inline space to subtract from the measured container width. @default 0 */
    reservedInlineSize?: number;
};

export type UsePageOverlayModesReturn<TMap extends OverlayPayloadMap> = {
    overlay: {
        open: boolean;
        render: () => React.ReactNode;
    };
    state: OverlayState<TMap>;
    open: <K extends keyof TMap>(mode: K, payload: TMap[K]) => void;
    close: () => void;
    onExited: () => void;
};

export type UseUnsavedChangesRegistrationProps = {
    busy?: boolean;
    dirty: boolean;
    enabled?: boolean;
    scopeId?: string;
};

export type UseUnsavedChangesRequestDiscardOptions = {
    disabled?: boolean;
    scopeId?: UnsavedChangesScopeId;
};

export type UseVireoDebouncedCallbackOptions = {
    /** Delay after the latest invocation before the callback runs. */
    delayMs: number;
};

export type UseVireoTransitionPresenceOptions = {
    /** Runs after an exit cycle completes and the retained value has been cleared. */
    onExited?: () => void;
};

Complete render-time utility-class mapping for a component's public slots.

/** Complete render-time utility-class mapping for a component's public slots. */
export type UtilityClassSlotMap<TSlotName extends string, TClassKey extends string> = Record<TSlotName, readonly (TClassKey | false | null | undefined)[]>;

export declare const VIREO_APPLICATION_NAVIGATION_DEFAULT_COLLAPSE_THRESHOLD = 220;

export declare const VIREO_APPLICATION_NAVIGATION_DEFAULT_COMPACT_WIDTH = 80;

export declare const VIREO_APPLICATION_NAVIGATION_DEFAULT_EXPANDED_WIDTH = 264;

export declare const VIREO_APPLICATION_NAVIGATION_MAX_EXPANDED_WIDTH = 480;

export declare const VIREO_APPLICATION_NAVIGATION_MIN_EXPANDED_WIDTH = 220;

export declare const VIREO_APPLICATION_NAVIGATION_WIDTH_CSS_VAR = "--vireo-application-navigation-width";

Shared semantic timing values for asynchronous loading presentation. Boundaries own reveal timing and content transitions. Skeleton leaves consume only the visual animation duration.

/**
 * Shared semantic timing values for asynchronous loading presentation.
 *
 * Boundaries own reveal timing and content transitions. Skeleton leaves consume
 * only the visual animation duration.
 */
export declare const VIREO_LOADING_TOKENS: {
    readonly revealDelay: 150;
    readonly contentTransitionDuration: 120;
    readonly skeletonAnimationDuration: 1400;
};

Shared semantic motion values for Vireo components and consuming applications. Direct manipulation should remain immediate. Use the longer values only when motion communicates a surface or navigation relationship.

/**
 * Shared semantic motion values for Vireo components and consuming applications.
 *
 * Direct manipulation should remain immediate. Use the longer values only when
 * motion communicates a surface or navigation relationship.
 */
export declare const VIREO_MOTION_TOKENS: {
    readonly duration: {
        readonly instant: 0;
        readonly micro: 110;
        readonly standard: 180;
        readonly enter: 210;
        readonly exit: 150;
        readonly emphasized: 270;
    };
    readonly easing: {
        readonly standard: "cubic-bezier(0.2, 0, 0, 1)";
        readonly enter: "cubic-bezier(0, 0, 0, 1)";
        readonly exit: "cubic-bezier(0.3, 0, 1, 1)";
    };
    readonly distance: {
        readonly micro: 4;
        readonly component: 8;
        readonly surface: 16;
    };
    readonly scale: {
        readonly pressed: 0.98;
    };
};

export declare const VIREO_PAGE_LAYOUT_COMPACT_ENTER_WIDTH = 580;

export declare const VIREO_PAGE_LAYOUT_COMPACT_EXIT_WIDTH = 620;

Minimum content width the application shell preserves beside resizable navigation.

/** Minimum content width the application shell preserves beside resizable navigation. */
export declare const VIREO_PAGE_LAYOUT_MIN_WIDTH = 420;

export declare const VIREO_PAGE_LAYOUT_WIDE_ENTER_WIDTH = 1120;

export declare const VIREO_PAGE_LAYOUT_WIDE_EXIT_WIDTH = 1080;

Shared authored-CSS branch matching the canonical theme's system reduced-motion policy.

/** Shared authored-CSS branch matching the canonical theme's system reduced-motion policy. */
export declare const VIREO_REDUCED_MOTION_MEDIA_QUERY: "@media (prefers-reduced-motion: reduce)";

Renders an action together with a concise preview of the consequence it will commit.

/** Renders an action together with a concise preview of the consequence it will commit. */
export declare const VireoActionPreviewButton: React.ForwardRefExoticComponent<Omit<VireoActionPreviewButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

export type VireoActionPreviewButtonAlignment = "center" | "start";

Valid keys for VireoActionPreviewButton utility classes and theme style overrides.

/** Valid keys for VireoActionPreviewButton utility classes and theme style overrides. */
export type VireoActionPreviewButtonClassKey = keyof VireoActionPreviewButtonClasses;

Utility classes available to VireoActionPreviewButton.

/** Utility classes available to VireoActionPreviewButton. */
export type VireoActionPreviewButtonClasses = Record<VireoActionPreviewButtonSlotName, string>;

export interface VireoActionPreviewButtonContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoActionPreviewButton inherits from its default root after excluding component-owned props.

/** Props VireoActionPreviewButton inherits from its default root after excluding component-owned props. */
export type VireoActionPreviewButtonInheritedProps = Omit<ButtonProps, "children" | "component">;

export interface VireoActionPreviewButtonLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoActionPreviewButton }.

/** Props owned by {@link VireoActionPreviewButton}. */
export type VireoActionPreviewButtonOwnProps = VireoActionPreviewButtonSlotsAndSlotProps & {
    /** Horizontal alignment for the action label and its consequence preview. @default 'start' */
    align?: VireoActionPreviewButtonAlignment;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoActionPreviewButtonClasses>;
    /** Primary action label. */
    label: React.ReactNode;
    /** Short statement describing the result or scope of the action before it is committed. */
    preview: React.ReactNode;
};

export type VireoActionPreviewButtonOwnerState = {
    align: VireoActionPreviewButtonAlignment;
    disabled: boolean;
};

export interface VireoActionPreviewButtonPreviewSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props accepted by {@link VireoActionPreviewButton }.

/** Props accepted by {@link VireoActionPreviewButton}. */
export type VireoActionPreviewButtonProps = VireoActionPreviewButtonOwnProps & VireoActionPreviewButtonInheritedProps;

export interface VireoActionPreviewButtonRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoActionPreviewButton }.

/** Replaceable semantic regions exposed by {@link VireoActionPreviewButton}. */
export type VireoActionPreviewButtonSlots = {
    [TSlotName in VireoActionPreviewButtonSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoActionPreviewButton }.

/** Slot props exposed by {@link VireoActionPreviewButton}. */
export type VireoActionPreviewButtonSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoActionPreviewButtonSlots, {
    /** @default Button */
    root: SlotProps<typeof Button, VireoActionPreviewButtonRootSlotPropsOverrides, VireoActionPreviewButtonOwnerState>;
    /** @default 'span' */
    content: SlotProps<typeof Box, VireoActionPreviewButtonContentSlotPropsOverrides, VireoActionPreviewButtonOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoActionPreviewButtonLabelSlotPropsOverrides, VireoActionPreviewButtonOwnerState>;
    /** @default Typography */
    preview: SlotProps<typeof Typography, VireoActionPreviewButtonPreviewSlotPropsOverrides, VireoActionPreviewButtonOwnerState>;
}>;

Provides a named, responsive application-navigation landmark with persistent expanded and compact modes.

/**
 * Provides a named, responsive application-navigation landmark with persistent expanded and compact modes.
 */
export declare const VireoApplicationNavigation: React.ForwardRefExoticComponent<Omit<VireoApplicationNavigationProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoApplicationNavigation utility classes and theme style overrides.

/** Valid keys for VireoApplicationNavigation utility classes and theme style overrides. */
export type VireoApplicationNavigationClassKey = keyof VireoApplicationNavigationClasses;

Utility classes available to VireoApplicationNavigation.

/** Utility classes available to VireoApplicationNavigation. */
export type VireoApplicationNavigationClasses = Record<VireoApplicationNavigationSlotName, string>;

export interface VireoApplicationNavigationContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoApplicationNavigation inherits from its default root after excluding component-owned props.

/** Props VireoApplicationNavigation inherits from its default root after excluding component-owned props. */
export type VireoApplicationNavigationInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

Renders a destination consistently in expanded and compact application navigation.

/**
 * Renders a destination consistently in expanded and compact application navigation.
 */
export declare const VireoApplicationNavigationItem: React.ForwardRefExoticComponent<Omit<VireoApplicationNavigationItemProps, "ref"> & React.RefAttributes<HTMLAnchorElement>>;

Valid keys for VireoApplicationNavigationItem utility classes and theme style overrides.

/** Valid keys for VireoApplicationNavigationItem utility classes and theme style overrides. */
export type VireoApplicationNavigationItemClassKey = keyof VireoApplicationNavigationItemClasses;

Utility classes available to VireoApplicationNavigationItem.

/** Utility classes available to VireoApplicationNavigationItem. */
export type VireoApplicationNavigationItemClasses = Record<VireoApplicationNavigationItemSlotName, string>;

export interface VireoApplicationNavigationItemIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoApplicationNavigationItem inherits from its default root after excluding component-owned props.

/** Props VireoApplicationNavigationItem inherits from its default root after excluding component-owned props. */
export type VireoApplicationNavigationItemInheritedProps = Omit<ListItemButtonProps<"a">, "children" | "component" | "href" | "selected">;

export interface VireoApplicationNavigationItemLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoApplicationNavigationItem }.

/** Props owned by {@link VireoApplicationNavigationItem}. */
export type VireoApplicationNavigationItemOwnProps = VireoApplicationNavigationItemSlotsAndSlotProps & {
    /** Destination URL rendered by the default anchor root. */
    href: string;
    /** Navigation item icon. */
    icon: React.ReactNode;
    /** Full developer-facing and accessible label. */
    label: string;
    /** Optional shorter caption used by compact mode. */
    compactLabel?: string;
    /** Overrides the surrounding navigation mode. */
    mode?: VireoApplicationNavigationMode;
    /** Tooltip shown in compact mode. Pass false to disable it. @default label */
    tooltip?: string | false;
    /** Whether the destination is active. @default false */
    selected?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoApplicationNavigationItemClasses>;
};

export type VireoApplicationNavigationItemOwnerState = {
    mode: VireoApplicationNavigationMode;
    selected: boolean;
    disabled: boolean;
};

Props accepted by {@link VireoApplicationNavigationItem }.

/** Props accepted by {@link VireoApplicationNavigationItem}. */
export type VireoApplicationNavigationItemProps = VireoApplicationNavigationItemOwnProps & VireoApplicationNavigationItemInheritedProps;

export interface VireoApplicationNavigationItemRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoApplicationNavigationItem }.

/** Replaceable semantic regions exposed by {@link VireoApplicationNavigationItem}. */
export type VireoApplicationNavigationItemSlots = {
    [TSlotName in VireoApplicationNavigationItemSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoApplicationNavigationItem }.

/** Slot props exposed by {@link VireoApplicationNavigationItem}. */
export type VireoApplicationNavigationItemSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoApplicationNavigationItemSlots, {
    /** @default ListItemButton rendered as an anchor */
    root: SlotProps<"a", VireoApplicationNavigationItemRootSlotPropsOverrides, VireoApplicationNavigationItemOwnerState>;
    /** @default 'span' */
    icon: SlotProps<typeof Box, VireoApplicationNavigationItemIconSlotPropsOverrides, VireoApplicationNavigationItemOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoApplicationNavigationItemLabelSlotPropsOverrides, VireoApplicationNavigationItemOwnerState>;
}>;

export type VireoApplicationNavigationMode = "compact" | "expanded";

Props owned by {@link VireoApplicationNavigation }.

/** Props owned by {@link VireoApplicationNavigation}. */
export type VireoApplicationNavigationOwnProps = VireoApplicationNavigationSlotsAndSlotProps & {
    /** Localized accessible name for the navigation landmark. */
    navigationLabel: string;
    /** Current desktop navigation presentation. @default 'expanded' */
    mode?: VireoApplicationNavigationMode;
    /** Desktop or modal navigation surface. @default 'permanent' */
    variant?: VireoApplicationNavigationVariant;
    /** Whether a temporary surface is open. Ignored by permanent surfaces. @default false */
    open?: boolean;
    /** Requests that a temporary surface close. */
    onClose?: () => void;
    /** Remembered width used by expanded mode. @default 264 */
    expandedWidth?: number;
    /** Fixed width used by compact mode. @default 80 */
    compactWidth?: number;
    /** Smallest expanded width. @default 220 */
    minExpandedWidth?: number;
    /** Largest expanded width. @default 480 */
    maxExpandedWidth?: number;
    /** Expanded width restored by a resize-handle double click. @default 264 */
    defaultExpandedWidth?: number;
    /** Width below which resizing snaps to compact mode. @default minExpandedWidth */
    collapseThreshold?: number;
    /** Enables pointer and keyboard resizing for a permanent surface. @default true */
    resizable?: boolean;
    /** Locks the current mode and width by disabling mode toggles and resizing. @default false */
    locked?: boolean;
    /** Called when the requested desktop mode changes. */
    onModeChange?: (mode: VireoApplicationNavigationMode) => void;
    /** Called when resizing or a reset commits a new expanded width. */
    onExpandedWidthChange?: (width: number) => void;
    /** Navigation contents, optionally rendered from the resolved navigation state. */
    children: React.ReactNode | ((state: VireoApplicationNavigationRenderState) => React.ReactNode);
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoApplicationNavigationClasses>;
};

export type VireoApplicationNavigationOwnerState = {
    mode: VireoApplicationNavigationMode;
    variant: VireoApplicationNavigationVariant;
    width: number;
    isResizing: boolean;
    resizable: boolean;
    locked: boolean;
};

Props accepted by {@link VireoApplicationNavigation }.

/** Props accepted by {@link VireoApplicationNavigation}. */
export type VireoApplicationNavigationProps = VireoApplicationNavigationOwnProps & VireoApplicationNavigationInheritedProps;

export type VireoApplicationNavigationRenderState = {
    mode: VireoApplicationNavigationMode;
    width: number;
    isResizing: boolean;
    toggleMode: () => void;
};

export interface VireoApplicationNavigationResizeHandleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoApplicationNavigationRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoApplicationNavigation }.

/** Replaceable semantic regions exposed by {@link VireoApplicationNavigation}. */
export type VireoApplicationNavigationSlots = {
    [TSlotName in VireoApplicationNavigationSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoApplicationNavigation }.

/** Slot props exposed by {@link VireoApplicationNavigation}. */
export type VireoApplicationNavigationSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoApplicationNavigationSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoApplicationNavigationRootSlotPropsOverrides, VireoApplicationNavigationOwnerState>;
    /** @default Drawer */
    surface: SlotProps<typeof Drawer, VireoApplicationNavigationSurfaceSlotPropsOverrides, VireoApplicationNavigationOwnerState>;
    /** @default 'nav' */
    content: SlotProps<typeof Box, VireoApplicationNavigationContentSlotPropsOverrides, VireoApplicationNavigationOwnerState>;
    /** @default VireoSidePanelResizeHandle */
    resizeHandle: SlotProps<typeof VireoSidePanelResizeHandle, VireoApplicationNavigationResizeHandleSlotPropsOverrides, VireoApplicationNavigationOwnerState>;
}>;

export interface VireoApplicationNavigationSurfaceSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoApplicationNavigationVariant = "permanent" | "temporary";

Renders the standard swipeable Vireo bottom-sheet surface and grab handle.

/** Renders the standard swipeable Vireo bottom-sheet surface and grab handle. */
export declare const VireoBottomDrawer: React.ForwardRefExoticComponent<Omit<VireoBottomDrawerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoBottomDrawer utility classes and theme style overrides.

/** Valid keys for VireoBottomDrawer utility classes and theme style overrides. */
export type VireoBottomDrawerClassKey = keyof VireoBottomDrawerClasses;

Utility classes available to VireoBottomDrawer.

/** Utility classes available to VireoBottomDrawer. */
export type VireoBottomDrawerClasses = Record<VireoBottomDrawerSlotName, string>;

Props VireoBottomDrawer inherits from its default root after excluding component-owned props.

/** Props VireoBottomDrawer inherits from its default root after excluding component-owned props. */
export type VireoBottomDrawerInheritedProps = Omit<SwipeableDrawerProps, "anchor" | "children" | "disableBackdropTransition" | "disableDiscovery" | "disableSwipeToOpen" | "hideBackdrop" | "keepMounted" | "onClose" | "onOpen" | "open" | "slotProps">;

Props owned by {@link VireoBottomDrawer }.

/** Props owned by {@link VireoBottomDrawer}. */
export type VireoBottomDrawerOwnProps = VireoBottomDrawerSlotsAndSlotProps & {
    open: boolean;
    onClose: () => void;
    onExited?: () => void;
    onOpen?: () => void;
    children: React.ReactNode;
    /** Fixed drawer height. Prefer this or maxHeight, not both. */
    height?: string;
    /** Maximum height for a content-sized drawer. */
    maxHeight?: string;
    keepMounted?: boolean;
    /** Whether the modal backdrop is visible. @default true */
    useBackdrop?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoBottomDrawerClasses>;
};

export type VireoBottomDrawerOwnerState = {
    open: boolean;
    hasFixedHeight: boolean;
    keepMounted: boolean;
    useBackdrop: boolean;
};

Props accepted by {@link VireoBottomDrawer }.

/** Props accepted by {@link VireoBottomDrawer}. */
export type VireoBottomDrawerProps = VireoBottomDrawerOwnProps & VireoBottomDrawerInheritedProps;

export interface VireoBottomDrawerPullerSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoBottomDrawerRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoBottomDrawer }.

/** Replaceable semantic regions exposed by {@link VireoBottomDrawer}. */
export type VireoBottomDrawerSlots = {
    [TSlotName in VireoBottomDrawerSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoBottomDrawer }.

/** Slot props exposed by {@link VireoBottomDrawer}. */
export type VireoBottomDrawerSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoBottomDrawerSlots, {
    /** @default SwipeableDrawer */
    root: SlotProps<typeof SwipeableDrawer, VireoBottomDrawerRootSlotPropsOverrides, VireoBottomDrawerOwnerState>;
    /** @default Box */
    puller: SlotProps<typeof Box, VireoBottomDrawerPullerSlotPropsOverrides, VireoBottomDrawerOwnerState>;
}>;

export type VireoBuiltInIconName = keyof typeof BUILT_IN_ICON_REGISTRY;

export type VireoCanvasPoint = {
    x: number;
    y: number;
};

export type VireoCanvasTransform = {
    scale: number;
    pan: VireoCanvasPoint;
};

export type VireoConfirm = (options: VireoConfirmationOptions) => Promise<boolean>;

Presents a controlled, accessible confirmation decision without interpreting message strings as HTML.

/** Presents a controlled, accessible confirmation decision without interpreting message strings as HTML. */
export declare const VireoConfirmationDialog: React.ForwardRefExoticComponent<Omit<VireoConfirmationDialogProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

export interface VireoConfirmationDialogActionsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoConfirmationDialogCancelButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoConfirmationDialog utility classes and theme style overrides.

/** Valid keys for VireoConfirmationDialog utility classes and theme style overrides. */
export type VireoConfirmationDialogClassKey = keyof VireoConfirmationDialogClasses;

Utility classes available to VireoConfirmationDialog.

/** Utility classes available to VireoConfirmationDialog. */
export type VireoConfirmationDialogClasses = Record<VireoConfirmationDialogSlotName, string>;

export interface VireoConfirmationDialogConfirmButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoConfirmationDialogContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoConfirmationDialogHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoConfirmationDialog inherits from MUI Dialog after excluding component-owned props.

/** Props VireoConfirmationDialog inherits from MUI Dialog after excluding component-owned props. */
export type VireoConfirmationDialogInheritedProps = Omit<DialogProps, "children" | "open" | "onClose" | "onTransitionExited" | "slots" | "slotProps" | "title">;

Props owned by {@link VireoConfirmationDialog }.

/** Props owned by {@link VireoConfirmationDialog}. */
export type VireoConfirmationDialogOwnProps = VireoConfirmationDialogSlotsAndSlotProps & {
    open: boolean;
    title: React.ReactNode;
    message: React.ReactNode;
    onClose: () => void;
    onConfirm: () => void;
    /** Called after the dialog's exit transition has fully completed. */
    onExited?: () => void;
    closeLabel?: string;
    cancelLabel?: string;
    confirmLabel?: string;
    confirmColor?: ButtonProps["color"];
    loading?: boolean;
    classes?: Partial<VireoConfirmationDialogClasses>;
};

export type VireoConfirmationDialogOwnerState = {
    open: boolean;
    loading: boolean;
    confirmColor: ButtonProps["color"];
};

export type VireoConfirmationDialogProps = VireoConfirmationDialogOwnProps & VireoConfirmationDialogInheritedProps;

export interface VireoConfirmationDialogRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoConfirmationDialog }.

/** Replaceable semantic regions exposed by {@link VireoConfirmationDialog}. */
export type VireoConfirmationDialogSlots = {
    [TSlotName in VireoConfirmationDialogSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoConfirmationDialog }.

/** Slot props exposed by {@link VireoConfirmationDialog}. */
export type VireoConfirmationDialogSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoConfirmationDialogSlots, {
    root: SlotProps<typeof Dialog, VireoConfirmationDialogRootSlotPropsOverrides, VireoConfirmationDialogOwnerState>;
    header: SlotProps<typeof VireoOverlayHeader, VireoConfirmationDialogHeaderSlotPropsOverrides, VireoConfirmationDialogOwnerState>;
    content: SlotProps<typeof DialogContent, VireoConfirmationDialogContentSlotPropsOverrides, VireoConfirmationDialogOwnerState>;
    actions: SlotProps<typeof DialogActions, VireoConfirmationDialogActionsSlotPropsOverrides, VireoConfirmationDialogOwnerState>;
    cancelButton: SlotProps<typeof Button, VireoConfirmationDialogCancelButtonSlotPropsOverrides, VireoConfirmationDialogOwnerState>;
    confirmButton: SlotProps<typeof Button, VireoConfirmationDialogConfirmButtonSlotPropsOverrides, VireoConfirmationDialogOwnerState>;
}>;

export type VireoConfirmationOptions = {
    title: React.ReactNode;
    message: React.ReactNode;
    closeLabel?: string;
    cancelLabel?: string;
    confirmLabel?: string;
    confirmColor?: ButtonProps["color"];
    maxWidth?: DialogProps["maxWidth"];
    /** Optional action executed while the confirmation remains open and locked. Rejection keeps it open for retry. */
    onConfirm?: () => unknown | Promise<unknown>;
};

Hosts one shared confirmation dialog and exposes a promise-based decision API to descendants.

/** Hosts one shared confirmation dialog and exposes a promise-based decision API to descendants. */
export declare function VireoConfirmationProvider({ children, defaultCloseLabel, defaultCancelLabel, defaultConfirmLabel, }: VireoConfirmationProviderProps): React.JSX.Element;

export type VireoConfirmationProviderProps = {
    children: React.ReactNode;
    defaultCloseLabel?: string;
    defaultCancelLabel?: string;
    defaultConfirmLabel?: string;
};

Renders a country-flag-icons registry identifier through a consistent, accessible 3:2 flag surface.

/**
 * Renders a country-flag-icons registry identifier through a consistent, accessible 3:2 flag surface.
 */
export declare const VireoCountryFlag: React.ForwardRefExoticComponent<Omit<VireoCountryFlagProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

Valid keys for VireoCountryFlag utility classes and theme style overrides.

/** Valid keys for VireoCountryFlag utility classes and theme style overrides. */
export type VireoCountryFlagClassKey = keyof VireoCountryFlagClasses;

Utility classes available to VireoCountryFlag.

/** Utility classes available to VireoCountryFlag. */
export type VireoCountryFlagClasses = Record<VireoCountryFlagSlotName | "known" | "unknown" | "tooltipEnabled", string>;

Known country codes retain autocomplete while arbitrary strings remain renderable as unknown flags.

/** Known country codes retain autocomplete while arbitrary strings remain renderable as unknown flags. */
export type VireoCountryFlagCode = CountryCode | (string & {});

export interface VireoCountryFlagFlagSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoCountryFlag inherits from its default root after excluding protected component-owned props.

/** Props VireoCountryFlag inherits from its default root after excluding protected component-owned props. */
export type VireoCountryFlagInheritedProps = Omit<BoxProps<"span">, "aria-hidden" | "aria-label" | "children" | "component" | "dangerouslySetInnerHTML" | "role" | "title">;

Props owned by {@link VireoCountryFlag }.

/** Props owned by {@link VireoCountryFlag}. */
export type VireoCountryFlagOwnProps = VireoCountryFlagSlotsAndSlotProps & {
    /** Country or subdivision identifier. Unknown strings render the fallback flag. */
    countryCode: VireoCountryFlagCode;
    /** Accessible flag label and, when enabled, tooltip content. */
    label?: string;
    /** Shows a country-name tooltip. @default false */
    enableTooltip?: boolean;
    /** Rendered width. Height follows the flag's 3:2 aspect ratio. @default 24 */
    width?: number | string;
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoCountryFlagClasses>;
};

export type VireoCountryFlagOwnerState = {
    countryCode: string;
    enableTooltip: boolean;
    known: boolean;
    width: number | string;
};

Props accepted by {@link VireoCountryFlag }.

/** Props accepted by {@link VireoCountryFlag}. */
export type VireoCountryFlagProps = VireoCountryFlagOwnProps & VireoCountryFlagInheritedProps;

export interface VireoCountryFlagRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoCountryFlag }.

/** Replaceable semantic regions exposed by {@link VireoCountryFlag}. */
export type VireoCountryFlagSlots = {
    /** @default 'span' */
    root: React.ElementType;
    /** @default country-flag-icons SVG or the Vireo unknown-flag SVG */
    flag: React.ElementType;
    /** @default Tooltip */
    tooltip: React.ElementType;
};

Slot props exposed by {@link VireoCountryFlag }.

/** Slot props exposed by {@link VireoCountryFlag}. */
export type VireoCountryFlagSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoCountryFlagSlots, {
    root: SlotProps<"span", VireoCountryFlagRootSlotPropsOverrides, VireoCountryFlagOwnerState>;
    flag: SlotProps<"svg", VireoCountryFlagFlagSlotPropsOverrides, VireoCountryFlagOwnerState>;
    tooltip: SlotProps<typeof Tooltip, VireoCountryFlagTooltipSlotPropsOverrides, VireoCountryFlagOwnerState>;
}>;

export interface VireoCountryFlagTooltipSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Values supported by `data-*` attributes on Vireo component slots.

/** Values supported by `data-*` attributes on Vireo component slots. */
export type VireoDataAttributeValue = string | number | boolean | undefined;

export type VireoDebouncedCallback<TArgs extends unknown[], TResult> = {
    /** Schedule the callback with the latest arguments. */
    run: (...args: TArgs) => void;
    /** Cancel the currently pending invocation. */
    cancel: () => void;
    /** Immediately execute and clear the pending invocation, if one exists. */
    flush: () => TResult | undefined;
    /** Read whether an invocation is currently pending without causing React renders. */
    isPending: () => boolean;
};

Defers mounting transient fallback content so fast operations do not produce a distracting flash.

/**
 * Defers mounting transient fallback content so fast operations do not produce a distracting flash.
 */
export declare const VireoDelayedRender: React.ForwardRefExoticComponent<Omit<VireoDelayedRenderProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoDelayedRender utility classes and theme style overrides.

/** Valid keys for VireoDelayedRender utility classes and theme style overrides. */
export type VireoDelayedRenderClassKey = keyof VireoDelayedRenderClasses;

Utility classes available to VireoDelayedRender.

/** Utility classes available to VireoDelayedRender. */
export type VireoDelayedRenderClasses = Record<VireoDelayedRenderSlotName, string>;

Props VireoDelayedRender inherits from its default root after excluding component-owned props.

/** Props VireoDelayedRender inherits from its default root after excluding component-owned props. */
export type VireoDelayedRenderInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

Props owned by {@link VireoDelayedRender }.

/** Props owned by {@link VireoDelayedRender}. */
export type VireoDelayedRenderOwnProps = VireoDelayedRenderSlotsAndSlotProps & {
    /** Content mounted after the delay elapses. */
    children: React.ReactNode;
    /** Time in milliseconds to wait before mounting the content. @default VIREO_LOADING_TOKENS.revealDelay */
    delay?: number;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoDelayedRenderClasses>;
};

export type VireoDelayedRenderOwnerState = {
    delay: number;
};

Props accepted by {@link VireoDelayedRender }.

/** Props accepted by {@link VireoDelayedRender}. */
export type VireoDelayedRenderProps = VireoDelayedRenderOwnProps & VireoDelayedRenderInheritedProps;

export interface VireoDelayedRenderRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoDelayedRender }.

/** Replaceable semantic regions exposed by {@link VireoDelayedRender}. */
export type VireoDelayedRenderSlots = {
    [TSlotName in VireoDelayedRenderSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoDelayedRender }.

/** Slot props exposed by {@link VireoDelayedRender}. */
export type VireoDelayedRenderSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoDelayedRenderSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoDelayedRenderRootSlotPropsOverrides, VireoDelayedRenderOwnerState>;
}>;

Renders an adjacent side-panel surface with coordinated enter and exit transitions.

/**
 * Renders an adjacent side-panel surface with coordinated enter and exit transitions.
 */
export declare const VireoDockedSidePanel: React.ForwardRefExoticComponent<import("./VireoDockedSidePanel.types.js").VireoDockedSidePanelSlotsAndSlotProps & {
    open: boolean;
    width: import("../../../public.js").ResponsiveOverlayFrameDesktopSidePanelWidth;
    minWidth: number;
    maxWidth: number;
    isResizing?: boolean;
    resizeHandle?: React.ReactNode;
    onExited?: () => void;
    children: React.ReactNode;
    classes?: Partial<import("./VireoDockedSidePanel.classes.js").VireoDockedSidePanelClasses>;
} & import("./VireoDockedSidePanel.types.js").VireoDockedSidePanelInheritedProps & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoDockedSidePanel utility classes and theme style overrides.

/** Valid keys for VireoDockedSidePanel utility classes and theme style overrides. */
export type VireoDockedSidePanelClassKey = keyof VireoDockedSidePanelClasses;

Utility classes available to VireoDockedSidePanel.

/** Utility classes available to VireoDockedSidePanel. */
export type VireoDockedSidePanelClasses = Record<VireoDockedSidePanelSlotName, string>;

Props VireoDockedSidePanel inherits from its default root after excluding component-owned props.

/** Props VireoDockedSidePanel inherits from its default root after excluding component-owned props. */
export type VireoDockedSidePanelInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "ref">;

Props owned by {@link VireoDockedSidePanel }.

/** Props owned by {@link VireoDockedSidePanel}. */
export type VireoDockedSidePanelOwnProps = VireoDockedSidePanelSlotsAndSlotProps & {
    /** Whether the panel is entered and interactive. */
    open: boolean;
    /** Width reserved for the visible panel surface. */
    width: ResponsiveOverlayFrameDesktopSidePanelWidth;
    /** Minimum visible panel width in pixels. */
    minWidth: number;
    /** Maximum visible panel width in pixels. */
    maxWidth: number;
    /** Disables surface transitions while pointer resizing is active. @default false */
    isResizing?: boolean;
    /** Optional resize control rendered before panel content. */
    resizeHandle?: React.ReactNode;
    /** Called once after the panel finishes leaving. */
    onExited?: () => void;
    /** Panel contents. */
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoDockedSidePanelClasses>;
};

export type VireoDockedSidePanelOwnerState = {
    open: boolean;
    width: ResponsiveOverlayFrameDesktopSidePanelWidth;
    minWidth: number;
    maxWidth: number;
    isResizing: boolean;
    isPanelPresent: boolean;
    isPanelEntered: boolean;
};

Props accepted by {@link VireoDockedSidePanel }.

/** Props accepted by {@link VireoDockedSidePanel}. */
export type VireoDockedSidePanelProps = VireoDockedSidePanelOwnProps & VireoDockedSidePanelInheritedProps;

export interface VireoDockedSidePanelRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoDockedSidePanel }.

/** Replaceable semantic regions exposed by {@link VireoDockedSidePanel}. */
export type VireoDockedSidePanelSlots = {
    [TSlotName in VireoDockedSidePanelSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoDockedSidePanel }.

/** Slot props exposed by {@link VireoDockedSidePanel}. */
export type VireoDockedSidePanelSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoDockedSidePanelSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoDockedSidePanelRootSlotPropsOverrides, VireoDockedSidePanelOwnerState>;
    /** @default 'aside' */
    surface: SlotProps<"aside", VireoDockedSidePanelSurfaceSlotPropsOverrides, VireoDockedSidePanelOwnerState>;
}>;

export interface VireoDockedSidePanelSurfaceSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Keeps form actions in one horizontal row across every containing surface.

/**
 * Keeps form actions in one horizontal row across every containing surface.
 */
export declare const VireoFormActions: React.ForwardRefExoticComponent<Omit<VireoFormActionsProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoFormActions utility classes and theme style overrides.

/** Valid keys for VireoFormActions utility classes and theme style overrides. */
export type VireoFormActionsClassKey = keyof VireoFormActionsClasses;

Utility classes available to VireoFormActions.

/** Utility classes available to VireoFormActions. */
export type VireoFormActionsClasses = Record<VireoFormActionsSlotName, string>;

Props VireoFormActions inherits from its default root after excluding component-owned props.

/** Props VireoFormActions inherits from its default root after excluding component-owned props. */
export type VireoFormActionsInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export interface VireoFormActionsLayoutSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoFormActions }.

/** Props owned by {@link VireoFormActions}. */
export type VireoFormActionsOwnProps = VireoFormActionsSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormActionsClasses>;
};

export type VireoFormActionsOwnerState = Record<string, never>;

Props accepted by {@link VireoFormActions }.

/** Props accepted by {@link VireoFormActions}. */
export type VireoFormActionsProps = VireoFormActionsOwnProps & VireoFormActionsInheritedProps;

export interface VireoFormActionsRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormActions }.

/** Replaceable semantic regions exposed by {@link VireoFormActions}. */
export type VireoFormActionsSlots = {
    [TSlotName in VireoFormActionsSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormActions }.

/** Slot props exposed by {@link VireoFormActions}. */
export type VireoFormActionsSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormActionsSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormActionsRootSlotPropsOverrides, VireoFormActionsOwnerState>;
    /** @default Box */
    layout: SlotProps<typeof Box, VireoFormActionsLayoutSlotPropsOverrides, VireoFormActionsOwnerState>;
}>;

Groups related form content under an accessible heading and a container-responsive layout.

/** Groups related form content under an accessible heading and a container-responsive layout. */
export declare const VireoFormSection: React.ForwardRefExoticComponent<import("./VireoFormSection.types.js").VireoFormSectionSlotsAndSlotProps & {
    children: React.ReactNode;
    classes?: Partial<import("./VireoFormSection.classes.js").VireoFormSectionClasses>;
    description?: React.ReactNode;
    headingLevel?: import("./VireoFormSection.types.js").VireoFormSectionHeadingLevel;
    layout?: import("./VireoFormSection.types.js").VireoFormSectionLayout;
    label: React.ReactNode;
    maxColumns?: import("./VireoFormSection.types.js").VireoFormSectionMaxColumns;
    variant?: import("./VireoFormSection.types.js").VireoFormSectionVariant;
} & import("./VireoFormSection.types.js").VireoFormSectionInheritedProps & React.RefAttributes<HTMLElement>>;

Valid keys for VireoFormSection utility classes and theme style overrides.

/** Valid keys for VireoFormSection utility classes and theme style overrides. */
export type VireoFormSectionClassKey = keyof VireoFormSectionClasses;

Utility classes available to VireoFormSection.

/** Utility classes available to VireoFormSection. */
export type VireoFormSectionClasses = Record<VireoFormSectionSlotName, string>;

export interface VireoFormSectionContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSectionDescriptionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSectionHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionHeadingLevel = 2 | 3 | 4 | 5 | 6;

export type VireoFormSectionInheritedProps = Omit<BoxProps<"section">, "children" | "component" | "ref">;

Groups one or more elements into a single responsive form-section cell with optional full-row spanning.

/**
 * Groups one or more elements into a single responsive form-section cell with optional full-row spanning.
 */
export declare const VireoFormSectionItem: React.ForwardRefExoticComponent<Omit<VireoFormSectionItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoFormSectionItem utility classes and theme style overrides.

/** Valid keys for VireoFormSectionItem utility classes and theme style overrides. */
export type VireoFormSectionItemClassKey = keyof VireoFormSectionItemClasses;

Utility classes available to VireoFormSectionItem.

/** Utility classes available to VireoFormSectionItem. */
export type VireoFormSectionItemClasses = Record<VireoFormSectionItemSlotName, string>;

Props VireoFormSectionItem inherits from its default root after excluding component-owned props.

/** Props VireoFormSectionItem inherits from its default root after excluding component-owned props. */
export type VireoFormSectionItemInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

Props owned by {@link VireoFormSectionItem }.

/** Props owned by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemOwnProps = VireoFormSectionItemSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormSectionItemClasses>;
    /** Controls whether the item occupies one cell or the complete responsive row. @default 'auto' */
    span?: VireoFormSectionItemSpan;
};

export type VireoFormSectionItemOwnerState = {
    span: VireoFormSectionItemSpan;
};

Props accepted by {@link VireoFormSectionItem }.

/** Props accepted by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemProps = VireoFormSectionItemOwnProps & VireoFormSectionItemInheritedProps;

export interface VireoFormSectionItemRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormSectionItem }.

/** Replaceable semantic regions exposed by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemSlots = {
    [TSlotName in VireoFormSectionItemSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormSectionItem }.

/** Slot props exposed by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSectionItemSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormSectionItemRootSlotPropsOverrides, VireoFormSectionItemOwnerState>;
}>;

export type VireoFormSectionItemSpan = "auto" | "full";

export interface VireoFormSectionLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionLayout = "grid" | "stack";

export interface VireoFormSectionLayoutSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionMaxColumns = 1 | 2 | 3;

export type VireoFormSectionOwnProps = VireoFormSectionSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormSectionClasses>;
    /** Supporting text associated with the named section. */
    description?: React.ReactNode;
    /** Semantic heading level used for the section label. @default 2 */
    headingLevel?: VireoFormSectionHeadingLevel;
    /** Controls whether fields use a responsive grid or an always-stacked layout. @default 'grid' */
    layout?: VireoFormSectionLayout;
    /** Accessible section heading. */
    label: React.ReactNode;
    /** Maximum number of responsive grid columns. @default 2 */
    maxColumns?: VireoFormSectionMaxColumns;
    /** Controls the section's visual separation from surrounding form content. @default 'divided' */
    variant?: VireoFormSectionVariant;
};

export type VireoFormSectionOwnerState = {
    hasDescription: boolean;
    headingLevel: VireoFormSectionHeadingLevel;
    layout: VireoFormSectionLayout;
    maxColumns: VireoFormSectionMaxColumns;
    variant: VireoFormSectionVariant;
};

export type VireoFormSectionProps = VireoFormSectionOwnProps & VireoFormSectionInheritedProps;

export interface VireoFormSectionRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionSlots = {
    [T in VireoFormSectionSlotName]: React.ElementType;
};

export type VireoFormSectionSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSectionSlots, {
    /** @default 'section' */
    root: SlotProps<typeof Box, VireoFormSectionRootSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Box */
    header: SlotProps<typeof Box, VireoFormSectionHeaderSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoFormSectionLabelSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Typography */
    description: SlotProps<typeof Typography, VireoFormSectionDescriptionSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Box */
    content: SlotProps<typeof Box, VireoFormSectionContentSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Box */
    layout: SlotProps<typeof Box, VireoFormSectionLayoutSlotPropsOverrides, VireoFormSectionOwnerState>;
}>;

export type VireoFormSectionVariant = "divided" | "outlined" | "plain";

export type VireoFullscreen = {
    /** Whether the target's owner document exposes the standard Fullscreen API. */
    isSupported: boolean;
    /** Whether the target itself is the current fullscreen element. */
    isFullscreen: boolean;
    /** The target owner document's current fullscreen element, including external owners. */
    fullscreenElement: Element | null;
    /** Requests fullscreen for the target. */
    enterFullscreen: (options?: FullscreenOptions) => Promise<void>;
    /** Exits fullscreen only when the target owns it. */
    exitFullscreen: () => Promise<void>;
    /** Enters or exits fullscreen according to whether the target owns it. */
    toggleFullscreen: (options?: FullscreenOptions) => Promise<void>;
};

Presents one typed entity change as an expandable, nested, read-only history entry.

/** Presents one typed entity change as an expandable, nested, read-only history entry. */
export declare const VireoHistoryEntry: VireoHistoryEntryComponent;

Valid keys for VireoHistoryEntry utility classes and theme style overrides.

/** Valid keys for VireoHistoryEntry utility classes and theme style overrides. */
export type VireoHistoryEntryClassKey = keyof VireoHistoryEntryClasses;

Utility classes available to VireoHistoryEntry.

/** Utility classes available to VireoHistoryEntry. */
export type VireoHistoryEntryClasses = Record<VireoHistoryEntrySlotName | VireoHistoryEntryStateClassKey, string>;

Loaded snapshot or boundary-coordinated loading state rendered by VireoHistoryEntry.

/** Loaded snapshot or boundary-coordinated loading state rendered by VireoHistoryEntry. */
export type VireoHistoryEntryContentProps<TEntity extends object> = {
    /** Renders the real entry anatomy with silent skeleton leaves. */
    loading: true;
    /** Visibility supplied by the owning VireoLoadingRegion after its reveal delay. */
    loadingVisible: boolean;
    current?: never;
    previous?: never;
} | {
    loading?: false;
    loadingVisible?: never;
    /** Snapshot before the recorded change. Use `null` for a newly added entity. */
    previous: NoInfer<TEntity> | null;
    /** Snapshot after the recorded change. Use `null` for a removed entity. */
    current: NoInfer<TEntity> | null;
};

Props VireoHistoryEntry inherits from its default root after excluding component-owned props.

/** Props VireoHistoryEntry inherits from its default root after excluding component-owned props. */
export type VireoHistoryEntryInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoHistoryEntryLabels = {
    expandSection: string;
    collapseSection: string;
    showUnchanged: string;
    hideUnchanged: string;
    showMore: string;
    showLess: string;
    added: string;
    removed: string;
    updated: string;
    moved: string;
    unchanged: string;
    field: string;
    previous: string;
    current: string;
    value: string;
    notPresent: string;
    changes: (count: number) => React.ReactNode;
};

export type VireoHistoryEntryOwnProps<TEntity extends object = Record<string, unknown>> = VireoHistoryEntrySlotsAndSlotProps & {
    /** Typed history definition used to validate, render, and diff both snapshots. */
    definition: HistoryDefinition<TEntity>;
    /** Content rendered for nullish or otherwise empty field values. */
    emptyValue?: React.ReactNode;
    /** Metadata displayed beside the root expansion control. */
    rootMeta?: React.ReactNode;
    /** Displays the root definition label and rendered entity identity. @default true */
    showRootEntityLabel?: boolean;
    /** Initially includes unchanged fields in the rendered entry. @default false */
    defaultShowUnchanged?: boolean;
    /** Deepest group level expanded initially. The root group is depth 1. @default 3 */
    defaultExpandedDepth?: number;
    /** Override the default English interaction and accessibility labels. */
    labels?: Partial<VireoHistoryEntryLabels>;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoHistoryEntryClasses>;
};

export type VireoHistoryEntryOwnerState = {
    defaultExpandedDepth: number;
    defaultShowUnchanged: boolean;
    expanded: boolean;
    hasUnchanged: boolean;
    hasRootMeta: boolean;
    loading: boolean;
    showRootEntityLabel: boolean;
};

Props accepted by {@link VireoHistoryEntry }.

/** Props accepted by {@link VireoHistoryEntry}. */
export type VireoHistoryEntryProps<TEntity extends object = Record<string, unknown>> = VireoHistoryEntryOwnProps<TEntity> & VireoHistoryEntryContentProps<TEntity> & VireoHistoryEntryInheritedProps;

export interface VireoHistoryEntryRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoHistoryEntry }.

/** Replaceable semantic regions exposed by {@link VireoHistoryEntry}. */
export type VireoHistoryEntrySlots = {
    [TSlotName in VireoHistoryEntrySlotName]: React.ElementType;
};

Slot props exposed by {@link VireoHistoryEntry }.

/** Slot props exposed by {@link VireoHistoryEntry}. */
export type VireoHistoryEntrySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoHistoryEntrySlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoHistoryEntryRootSlotPropsOverrides, VireoHistoryEntryOwnerState>;
}>;

Props owned by {@link VireoHistoryEntry }.

/** Props owned by {@link VireoHistoryEntry}. */
export type VireoHistoryEntrySnapshot<TDefinition> = TDefinition extends HistoryDefinition<infer TEntity> ? TEntity : unknown;

export type VireoHistoryEntryStateClassKey = "loading";

Renders a type-safe icon from the nearest Vireo icon registry.

/** Renders a type-safe icon from the nearest Vireo icon registry. */
export declare const VireoIcon: React.ForwardRefExoticComponent<Omit<VireoIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;

Valid keys for VireoIcon utility classes and theme style overrides.

/** Valid keys for VireoIcon utility classes and theme style overrides. */
export type VireoIconClassKey = keyof VireoIconClasses;

Utility classes available to VireoIcon.

/** Utility classes available to VireoIcon. */
export type VireoIconClasses = Record<VireoIconSlotName, string>;

Proportionally scales and centers SVG geometry within Vireo's standard 24×24 icon coordinate system.

/**
 * Proportionally scales and centers SVG geometry within Vireo's standard 24×24 icon coordinate system.
 */
export declare const VireoIconContainer: React.ForwardRefExoticComponent<import("./VireoIconContainer.types.js").VireoIconContainerSlotsAndSlotProps & {
    viewBoxWidth: number;
    viewBoxHeight: number;
    children: React.ReactNode;
    classes?: Partial<import("./VireoIconContainer.classes.js").VireoIconContainerClasses>;
} & Omit<Omit<React.SVGProps<SVGGElement>, "ref">, "children" | "transform"> & {
    sx?: import("@mui/system").SxProps<import("@mui/material").Theme>;
} & React.RefAttributes<SVGGElement>>;

Valid keys for VireoIconContainer utility classes and theme style overrides.

/** Valid keys for VireoIconContainer utility classes and theme style overrides. */
export type VireoIconContainerClassKey = keyof VireoIconContainerClasses;

Utility classes available to VireoIconContainer.

/** Utility classes available to VireoIconContainer. */
export type VireoIconContainerClasses = Record<VireoIconContainerSlotName, string>;

Props VireoIconContainer inherits from its default root after excluding component-owned props.

/** Props VireoIconContainer inherits from its default root after excluding component-owned props. */
export type VireoIconContainerInheritedProps = Omit<React.ComponentPropsWithoutRef<"g">, "children" | "transform"> & {
    sx?: SxProps<Theme>;
};

Props owned by {@link VireoIconContainer }.

/** Props owned by {@link VireoIconContainer}. */
export type VireoIconContainerOwnProps = VireoIconContainerSlotsAndSlotProps & {
    /** Width of the coordinate system in which the child SVG geometry was authored. */
    viewBoxWidth: number;
    /** Height of the coordinate system in which the child SVG geometry was authored. */
    viewBoxHeight: number;
    /** SVG geometry proportionally scaled and centered in the standard 24×24 Vireo icon coordinate system. */
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoIconContainerClasses>;
};

export type VireoIconContainerOwnerState = {
    viewBoxWidth: number;
    viewBoxHeight: number;
};

Props accepted by {@link VireoIconContainer }.

/** Props accepted by {@link VireoIconContainer}. */
export type VireoIconContainerProps = VireoIconContainerOwnProps & VireoIconContainerInheritedProps;

export interface VireoIconContainerRootSlotPropsOverrides {
    sx?: SxProps<Theme>;
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoIconContainer }.

/** Replaceable semantic regions exposed by {@link VireoIconContainer}. */
export type VireoIconContainerSlots = {
    [TSlotName in VireoIconContainerSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoIconContainer }.

/** Slot props exposed by {@link VireoIconContainer}. */
export type VireoIconContainerSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoIconContainerSlots, {
    /** @default 'g' */
    root: SlotProps<"g", VireoIconContainerRootSlotPropsOverrides, VireoIconContainerOwnerState>;
}>;

Props VireoIcon inherits from its default root after excluding component-owned props.

/** Props VireoIcon inherits from its default root after excluding component-owned props. */
export type VireoIconInheritedProps = Omit<SvgIconProps, "children" | "component">;

export type VireoIconName = keyof VireoIconRegistry;

Props owned by {@link VireoIcon }.

/** Props owned by {@link VireoIcon}. */
export type VireoIconOwnProps = VireoIconSlotsAndSlotProps & {
    /** Name of an icon registered through VireoIconRegistryProvider. */
    icon: VireoIconName;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoIconClasses>;
};

export type VireoIconOwnerState = {
    icon: VireoIconName;
};

Props accepted by {@link VireoIcon }.

/** Props accepted by {@link VireoIcon}. */
export type VireoIconProps = VireoIconOwnProps & VireoIconInheritedProps;

Augment this interface to register application-owned icons by name.

/** Augment this interface to register application-owned icons by name. */
export interface VireoIconRegistry extends Record<VireoBuiltInIconName, React.ComponentType> {
}

export declare const VireoIconRegistryContext: React.Context<VireoIconRegistryContextValue | undefined>;

export type VireoIconRegistryContextValue = {
    muiIconsMap: {
        [TIconName in VireoIconName]: typeof SvgIcon;
    };
};

Provides the typed icon registry consumed by VireoIcon.

/** Provides the typed icon registry consumed by VireoIcon. */
export declare function VireoIconRegistryProvider({ children, icons }: VireoIconRegistryProviderProps): React.JSX.Element;

export type VireoIconRegistryProviderProps = React.PropsWithChildren<{
    /** Application icon geometry keyed by the augmented registry names. Built-in icons may be overridden. */
    icons?: Partial<IconsFromRegistry> & Record<string, React.ComponentType>;
}>;

export interface VireoIconRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoIcon }.

/** Replaceable semantic regions exposed by {@link VireoIcon}. */
export type VireoIconSlots = {
    [TSlotName in VireoIconSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoIcon }.

/** Slot props exposed by {@link VireoIcon}. */
export type VireoIconSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoIconSlots, {
    /** @default Registered icon component */
    root: SlotProps<typeof SvgIcon, VireoIconRootSlotPropsOverrides, VireoIconOwnerState>;
}>;

Provides a controlled-or-uncontrolled pannable, zoomable world coordinate surface.

/** Provides a controlled-or-uncontrolled pannable, zoomable world coordinate surface. */
export declare const VireoInfiniteCanvas: React.ForwardRefExoticComponent<(Omit<import("./VireoInfiniteCanvas.types.js").VireoInfiniteCanvasSlotsAndSlotProps & {
    children?: React.ReactNode;
    transform?: VireoCanvasTransform;
    defaultTransform?: VireoCanvasTransform;
    onTransformChange?: (transform: VireoCanvasTransform) => void;
    minScale?: number;
    maxScale?: number;
    zoomStep?: number;
    gridSize?: number;
    horizontalGridFactor?: number;
    verticalGridFactor?: number;
    panEnabled?: boolean;
    keyboardControlsEnabled?: boolean;
    keyboardPanStep?: number;
    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
    touchPanEnabled?: boolean;
    wheelZoomEnabled?: boolean;
    classes?: Partial<import("./VireoInfiniteCanvas.classes.js").VireoInfiniteCanvasClasses>;
} & {
    "aria-label": string;
    "aria-labelledby"?: never;
} & import("./VireoInfiniteCanvas.types.js").VireoInfiniteCanvasInheritedProps, "ref"> | Omit<import("./VireoInfiniteCanvas.types.js").VireoInfiniteCanvasSlotsAndSlotProps & {
    children?: React.ReactNode;
    transform?: VireoCanvasTransform;
    defaultTransform?: VireoCanvasTransform;
    onTransformChange?: (transform: VireoCanvasTransform) => void;
    minScale?: number;
    maxScale?: number;
    zoomStep?: number;
    gridSize?: number;
    horizontalGridFactor?: number;
    verticalGridFactor?: number;
    panEnabled?: boolean;
    keyboardControlsEnabled?: boolean;
    keyboardPanStep?: number;
    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
    touchPanEnabled?: boolean;
    wheelZoomEnabled?: boolean;
    classes?: Partial<import("./VireoInfiniteCanvas.classes.js").VireoInfiniteCanvasClasses>;
} & {
    "aria-label"?: never;
    "aria-labelledby": string;
} & import("./VireoInfiniteCanvas.types.js").VireoInfiniteCanvasInheritedProps, "ref">) & React.RefAttributes<HTMLDivElement>>;

Accessible-name alternatives accepted by VireoInfiniteCanvas.

/** Accessible-name alternatives accepted by VireoInfiniteCanvas. */
export type VireoInfiniteCanvasAccessibleNameProps = {
    /** Localized accessible name for the canvas region. */
    "aria-label": string;
    "aria-labelledby"?: never;
} | {
    "aria-label"?: never;
    /** ID of visible text that provides the localized accessible name for the canvas region. */
    "aria-labelledby": string;
};

Applies the canvas world transform to positioned content.

/** Applies the canvas world transform to positioned content. */
export declare const VireoInfiniteCanvasBody: React.ForwardRefExoticComponent<Omit<VireoInfiniteCanvasBodyProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoInfiniteCanvasBody utility classes and theme style overrides.

/** Valid keys for VireoInfiniteCanvasBody utility classes and theme style overrides. */
export type VireoInfiniteCanvasBodyClassKey = keyof VireoInfiniteCanvasBodyClasses;

Utility classes available to VireoInfiniteCanvasBody.

/** Utility classes available to VireoInfiniteCanvasBody. */
export type VireoInfiniteCanvasBodyClasses = Record<VireoInfiniteCanvasBodySlotName, string>;

export type VireoInfiniteCanvasBodyInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoInfiniteCanvasBodyOwnProps = VireoInfiniteCanvasBodySlotsAndSlotProps & {
    children: React.ReactNode;
    classes?: Partial<VireoInfiniteCanvasBodyClasses>;
};

export type VireoInfiniteCanvasBodyOwnerState = {
    transform: VireoCanvasTransform;
};

export type VireoInfiniteCanvasBodyProps = VireoInfiniteCanvasBodyOwnProps & VireoInfiniteCanvasBodyInheritedProps;

export interface VireoInfiniteCanvasBodyRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoInfiniteCanvasBodySlots = {
    [TSlotName in VireoInfiniteCanvasBodySlotName]: React.ElementType;
};

export type VireoInfiniteCanvasBodySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoInfiniteCanvasBodySlots, {
    root: SlotProps<"div", VireoInfiniteCanvasBodyRootSlotPropsOverrides, VireoInfiniteCanvasBodyOwnerState>;
}>;

Valid keys for VireoInfiniteCanvas utility classes and theme style overrides.

/** Valid keys for VireoInfiniteCanvas utility classes and theme style overrides. */
export type VireoInfiniteCanvasClassKey = keyof VireoInfiniteCanvasClasses;

Utility classes available to VireoInfiniteCanvas.

/** Utility classes available to VireoInfiniteCanvas. */
export type VireoInfiniteCanvasClasses = Record<VireoInfiniteCanvasSlotName, string>;

export type VireoInfiniteCanvasContextValue = {
    transform: VireoCanvasTransform;
    scale: number;
    pan: VireoCanvasPoint;
    minScale: number;
    maxScale: number;
    target: HTMLDivElement | null;
    clientToWorld: (point: VireoCanvasPoint) => VireoCanvasPoint;
    worldToClient: (point: VireoCanvasPoint) => VireoCanvasPoint;
    getViewportCenterWorld: () => VireoCanvasPoint;
    setTransform: (transform: VireoCanvasTransform) => void;
    resetTransform: () => void;
    zoomIn: () => void;
    zoomOut: () => void;
    isFullscreen: boolean;
    isFullscreenSupported: boolean;
    toggleFullscreen: () => Promise<void>;
};

Props VireoInfiniteCanvas inherits from its default root after excluding component-owned props.

/** Props VireoInfiniteCanvas inherits from its default root after excluding component-owned props. */
export type VireoInfiniteCanvasInheritedProps = Omit<BoxProps<"div">, "aria-label" | "aria-labelledby" | "children" | "component" | "onChange" | "onKeyDown" | "role" | "tabIndex">;

Pins interactive controls above the canvas without applying the world transform.

/** Pins interactive controls above the canvas without applying the world transform. */
export declare const VireoInfiniteCanvasOverlay: React.ForwardRefExoticComponent<Omit<VireoInfiniteCanvasOverlayProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoInfiniteCanvasOverlay utility classes and theme style overrides.

/** Valid keys for VireoInfiniteCanvasOverlay utility classes and theme style overrides. */
export type VireoInfiniteCanvasOverlayClassKey = keyof VireoInfiniteCanvasOverlayClasses;

Utility classes available to VireoInfiniteCanvasOverlay.

/** Utility classes available to VireoInfiniteCanvasOverlay. */
export type VireoInfiniteCanvasOverlayClasses = Record<VireoInfiniteCanvasOverlaySlotName, string>;

export interface VireoInfiniteCanvasOverlayContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoInfiniteCanvasOverlayInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "position">;

export type VireoInfiniteCanvasOverlayOwnProps = VireoInfiniteCanvasOverlaySlotsAndSlotProps & {
    children: React.ReactNode;
    position?: VireoInfiniteCanvasOverlayPosition;
    offset?: number;
    classes?: Partial<VireoInfiniteCanvasOverlayClasses>;
};

export type VireoInfiniteCanvasOverlayOwnerState = {
    position: VireoInfiniteCanvasOverlayPosition;
};

export type VireoInfiniteCanvasOverlayPosition = "top-left" | "top" | "top-right" | "right" | "bottom-right" | "bottom" | "bottom-left" | "left";

export type VireoInfiniteCanvasOverlayProps = VireoInfiniteCanvasOverlayOwnProps & VireoInfiniteCanvasOverlayInheritedProps;

export interface VireoInfiniteCanvasOverlayRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoInfiniteCanvasOverlaySlots = {
    [TSlotName in VireoInfiniteCanvasOverlaySlotName]: React.ElementType;
};

export type VireoInfiniteCanvasOverlaySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoInfiniteCanvasOverlaySlots, {
    root: SlotProps<"div", VireoInfiniteCanvasOverlayRootSlotPropsOverrides, VireoInfiniteCanvasOverlayOwnerState>;
    content: SlotProps<"div", VireoInfiniteCanvasOverlayContentSlotPropsOverrides, VireoInfiniteCanvasOverlayOwnerState>;
}>;

export type VireoInfiniteCanvasOwnProps = VireoInfiniteCanvasSlotsAndSlotProps & {
    children?: React.ReactNode;
    transform?: VireoCanvasTransform;
    defaultTransform?: VireoCanvasTransform;
    onTransformChange?: (transform: VireoCanvasTransform) => void;
    minScale?: number;
    maxScale?: number;
    zoomStep?: number;
    gridSize?: number;
    horizontalGridFactor?: number;
    verticalGridFactor?: number;
    panEnabled?: boolean;
    /** Enables focus and the built-in Arrow-key pan, +/- zoom, and 0 reset shortcuts. @default true */
    keyboardControlsEnabled?: boolean;
    /** Positive distance, in CSS pixels, that an Arrow key pans the viewport. Invalid values fall back to 40. @default 40 */
    keyboardPanStep?: number;
    /** Runs after `slotProps.root.onKeyDown` and before a built-in keyboard action. Prevent the event to cancel that action. */
    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
    /** Captures single-finger touch gestures for canvas panning. Keep disabled when the canvas is embedded in a scrollable page. @default false */
    touchPanEnabled?: boolean;
    /** Captures wheel gestures for pointer-centered zooming. Keep disabled when the canvas is embedded in a scrollable page. @default false */
    wheelZoomEnabled?: boolean;
    classes?: Partial<VireoInfiniteCanvasClasses>;
};

export type VireoInfiniteCanvasOwnerState = {
    transform: VireoCanvasTransform;
    gridSize: number;
    horizontalGridFactor: number;
    verticalGridFactor: number;
    keyboardControlsEnabled: boolean;
    keyboardPanStep: number;
    panEnabled: boolean;
    touchPanEnabled: boolean;
    panning: boolean;
};

Props accepted by {@link VireoInfiniteCanvas }.

/** Props accepted by {@link VireoInfiniteCanvas}. */
export type VireoInfiniteCanvasProps = VireoInfiniteCanvasOwnProps & VireoInfiniteCanvasAccessibleNameProps & VireoInfiniteCanvasInheritedProps;

export interface VireoInfiniteCanvasRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoInfiniteCanvasSlots = {
    [TSlotName in VireoInfiniteCanvasSlotName]: React.ElementType;
};

export type VireoInfiniteCanvasSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoInfiniteCanvasSlots, {
    root: SlotProps<"div", VireoInfiniteCanvasRootSlotPropsOverrides, VireoInfiniteCanvasOwnerState>;
}>;

Gates a subtree until an abortable asynchronous initialization lifecycle is ready.

/** Gates a subtree until an abortable asynchronous initialization lifecycle is ready. */
export declare const VireoInitializationBoundary: React.ForwardRefExoticComponent<Omit<VireoInitializationBoundaryProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoInitializationBoundary utility classes and theme style overrides.

/** Valid keys for VireoInitializationBoundary utility classes and theme style overrides. */
export type VireoInitializationBoundaryClassKey = keyof VireoInitializationBoundaryClasses;

export type VireoInitializationBoundaryClasses = Record<VireoInitializationBoundarySlotName | VireoInitializationBoundaryStateClassKey, string>;

Props VireoInitializationBoundary inherits from its default root after excluding component-owned props.

/** Props VireoInitializationBoundary inherits from its default root after excluding component-owned props. */
export type VireoInitializationBoundaryInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export interface VireoInitializationBoundaryLoadingIndicatorSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoInitializationBoundary }.

/** Props owned by {@link VireoInitializationBoundary}. */
export type VireoInitializationBoundaryOwnProps = VireoInitializationBoundarySlotsAndSlotProps & {
    children: React.ReactNode;
    initialize: VireoInitializer;
    /** Whether prolonged initialization is announced. Disable for a boundary covered by an announcing ancestor. @default true */
    announceLoading?: boolean;
    /** Content rendered after the shared reveal delay. When omitted, a decorative Level C progress indicator is used. */
    fallback?: React.ReactNode;
    /** Concise status announced after the reveal delay. @default 'Initializing' */
    loadingLabel?: React.ReactNode;
    /** Delay before fallback content and the loading announcement become visible. @default VIREO_LOADING_TOKENS.revealDelay */
    loadingRevealDelay?: number;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoInitializationBoundaryClasses>;
};

export type VireoInitializationBoundaryOwnerState = {
    status: VireoInitializationBoundaryStatus;
};

Props accepted by {@link VireoInitializationBoundary }.

/** Props accepted by {@link VireoInitializationBoundary}. */
export type VireoInitializationBoundaryProps = VireoInitializationBoundaryOwnProps & VireoInitializationBoundaryInheritedProps;

export interface VireoInitializationBoundaryRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoInitializationBoundary }.

/** Replaceable semantic regions exposed by {@link VireoInitializationBoundary}. */
export type VireoInitializationBoundarySlots = {
    [TSlotName in VireoInitializationBoundarySlotName]: React.ElementType;
};

Slot props exposed by {@link VireoInitializationBoundary }.

/** Slot props exposed by {@link VireoInitializationBoundary}. */
export type VireoInitializationBoundarySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoInitializationBoundarySlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoInitializationBoundaryRootSlotPropsOverrides, VireoInitializationBoundaryOwnerState>;
    /** @default CircularProgress */
    loadingIndicator: SlotProps<typeof CircularProgress, VireoInitializationBoundaryLoadingIndicatorSlotPropsOverrides, VireoInitializationBoundaryOwnerState>;
}>;

Utility classes available to VireoInitializationBoundary.

/** Utility classes available to VireoInitializationBoundary. */
export type VireoInitializationBoundaryStateClassKey = (typeof VIREO_INITIALIZATION_BOUNDARY_STATES)[number];

export type VireoInitializationBoundaryStatus = "pending" | "ready";

export type VireoInitializationCleanup = () => void | Promise<void>;

export type VireoInitializationContext = {
    signal: AbortSignal;
};

export type VireoInitializer = (context: VireoInitializationContext) => void | VireoInitializationCleanup | Promise<void | VireoInitializationCleanup>;

Pretty-prints arbitrary values as inspectable JSON with resilient serialization and copy-to-clipboard feedback.

/** Pretty-prints arbitrary values as inspectable JSON with resilient serialization and copy-to-clipboard feedback. */
export declare const VireoJsonViewer: React.ForwardRefExoticComponent<Omit<VireoJsonViewerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoJsonViewer utility classes and theme style overrides.

/** Valid keys for VireoJsonViewer utility classes and theme style overrides. */
export type VireoJsonViewerClassKey = keyof VireoJsonViewerClasses;

Utility classes available to VireoJsonViewer.

/** Utility classes available to VireoJsonViewer. */
export type VireoJsonViewerClasses = Record<VireoJsonViewerSlotName, string>;

export interface VireoJsonViewerContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoJsonViewerCopyButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoJsonViewerCopyIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoJsonViewer inherits from its default root after excluding component-owned props.

/** Props VireoJsonViewer inherits from its default root after excluding component-owned props. */
export type VireoJsonViewerInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "maxHeight">;

Props owned by {@link VireoJsonViewer }.

/** Props owned by {@link VireoJsonViewer}. */
export type VireoJsonViewerOwnProps = VireoJsonViewerSlotsAndSlotProps & {
    /** Arbitrary value serialized for read-only inspection. */
    data: unknown;
    /** Accessible label shown while the JSON is ready to copy. */
    copyLabel: string;
    /** Accessible feedback shown briefly after copying succeeds. */
    copiedLabel: string;
    /** Accessible feedback shown briefly after clipboard access fails. */
    copyErrorLabel: string;
    /** Maximum height of the scrollable JSON content. @default '24rem' */
    maxHeight?: string | number;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoJsonViewerClasses>;
};

export type VireoJsonViewerOwnerState = {
    copied: boolean;
    copyStatus: "idle" | "copied" | "failed";
    maxHeight: string | number;
};

Props accepted by {@link VireoJsonViewer }.

/** Props accepted by {@link VireoJsonViewer}. */
export type VireoJsonViewerProps = VireoJsonViewerOwnProps & VireoJsonViewerInheritedProps;

export interface VireoJsonViewerRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoJsonViewer }.

/** Replaceable semantic regions exposed by {@link VireoJsonViewer}. */
export type VireoJsonViewerSlots = {
    [TSlotName in VireoJsonViewerSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoJsonViewer }.

/** Slot props exposed by {@link VireoJsonViewer}. */
export type VireoJsonViewerSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoJsonViewerSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoJsonViewerRootSlotPropsOverrides, VireoJsonViewerOwnerState>;
    /** @default 'div' */
    toolbar: SlotProps<"div", VireoJsonViewerToolbarSlotPropsOverrides, VireoJsonViewerOwnerState>;
    /** @default IconButton */
    copyButton: SlotProps<typeof IconButton, VireoJsonViewerCopyButtonSlotPropsOverrides, VireoJsonViewerOwnerState>;
    /** @default ContentCopy */
    copyIcon: SlotProps<typeof ContentCopy, VireoJsonViewerCopyIconSlotPropsOverrides, VireoJsonViewerOwnerState>;
    /** Visually hidden polite live region for copy success and failure feedback. @default 'span' */
    status: SlotProps<"span", VireoJsonViewerStatusSlotPropsOverrides, VireoJsonViewerOwnerState>;
    /** @default 'pre' */
    content: SlotProps<"pre", VireoJsonViewerContentSlotPropsOverrides, VireoJsonViewerOwnerState>;
}>;

export interface VireoJsonViewerStatusSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoJsonViewerToolbarSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Renders consistent label, helper-text, and content anatomy around form controls or grouped content.

/**
 * Renders consistent label, helper-text, and content anatomy around form controls or grouped content.
 */
export declare const VireoLabelBox: React.ForwardRefExoticComponent<(Omit<import("./VireoLabelBox.types.js").VireoLabelBoxSlotsAndSlotProps & {
    helperText?: React.ReactNode;
    color?: VireoLabelBoxColor;
    required?: boolean;
    fontWeight?: React.CSSProperties["fontWeight"];
    direction?: import("./VireoLabelBox.types.js").VireoLabelBoxDirection;
    classes?: Partial<import("./VireoLabelBox.classes.js").VireoLabelBoxClasses>;
} & import("./VireoLabelBox.types.js").VireoLabelBoxAssociatedControlProps & import("./VireoLabelBox.types.js").VireoLabelBoxInheritedProps, "ref"> | Omit<import("./VireoLabelBox.types.js").VireoLabelBoxSlotsAndSlotProps & {
    helperText?: React.ReactNode;
    color?: VireoLabelBoxColor;
    required?: boolean;
    fontWeight?: React.CSSProperties["fontWeight"];
    direction?: import("./VireoLabelBox.types.js").VireoLabelBoxDirection;
    classes?: Partial<import("./VireoLabelBox.classes.js").VireoLabelBoxClasses>;
} & import("./VireoLabelBox.types.js").VireoLabelBoxStaticContentProps & import("./VireoLabelBox.types.js").VireoLabelBoxInheritedProps, "ref">) & React.RefAttributes<HTMLDivElement>>;

Content that opts into the generated accessible control association.

/** Content that opts into the generated accessible control association. */
export type VireoLabelBoxAssociatedControlProps = {
    /** Visible label content used as the associated control's accessible name. */
    label: React.ReactNode;
    /** Render the single associated control and apply its generated accessibility relationships. */
    children: (association: VireoLabelBoxControlAssociation) => React.ReactNode;
};

Valid keys for VireoLabelBox utility classes and theme style overrides.

/** Valid keys for VireoLabelBox utility classes and theme style overrides. */
export type VireoLabelBoxClassKey = keyof VireoLabelBoxClasses;

Utility classes available to VireoLabelBox.

/** Utility classes available to VireoLabelBox. */
export type VireoLabelBoxClasses = Record<VireoLabelBoxSlotName, string>;

A fixed label color or a theme-aware color resolver.

/** A fixed label color or a theme-aware color resolver. */
export type VireoLabelBoxColor = string | ((theme: Theme) => string);

export interface VireoLabelBoxContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Generated relationships supplied to associated-control render content.

/** Generated relationships supplied to associated-control render content. */
export type VireoLabelBoxControlAssociation = {
    /** Apply every property to controls that accept standard ARIA relationship props. */
    controlProps: VireoLabelBoxControlProps;
    /** Use for controls such as MUI Select that expose a dedicated label-ID prop. */
    labelId: string;
    /** Use for controls that expose a dedicated description-ID prop. */
    helperTextId?: string;
};

Accessibility props generated for the single control associated with a label box.

/** Accessibility props generated for the single control associated with a label box. */
export type VireoLabelBoxControlProps = {
    /** References the rendered visible label. */
    "aria-labelledby": string;
    /** References the rendered helper text when one is present. */
    "aria-describedby"?: string;
    /** Mirrors the visible required indicator when `required` is true. */
    "aria-required"?: true;
};

Supported layout directions for the label anatomy and its content.

/** Supported layout directions for the label anatomy and its content. */
export type VireoLabelBoxDirection = "column" | "row";

export interface VireoLabelBoxHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoLabelBoxHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoLabelBox inherits from its default root after excluding component-owned props.

/** Props VireoLabelBox inherits from its default root after excluding component-owned props. */
export type VireoLabelBoxInheritedProps = Omit<BoxProps<"div">, "children" | "color" | "component" | "direction" | "required">;

export interface VireoLabelBoxLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoLabelBox }.

/** Props owned by {@link VireoLabelBox}. */
export type VireoLabelBoxOwnProps = VireoLabelBoxSlotsAndSlotProps & {
    /** Optional supporting content aligned opposite the label. */
    helperText?: React.ReactNode;
    /** Color applied to the visible label and required indicator. @default theme.palette.text.primary */
    color?: VireoLabelBoxColor;
    /** Shows a visual required indicator after the label. @default false */
    required?: boolean;
    /** Font weight applied to the label header. @default theme.typography.subtitle2.fontWeight */
    fontWeight?: React.CSSProperties["fontWeight"];
    /** Lays out the label anatomy above or beside its content. @default 'column' */
    direction?: VireoLabelBoxDirection;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoLabelBoxClasses>;
};

export type VireoLabelBoxOwnerState = {
    direction: VireoLabelBoxDirection;
    color: VireoLabelBoxColor;
    fontWeight: NonNullable<React.CSSProperties["fontWeight"]>;
    required: boolean;
    hasLabel: boolean;
    hasHelperText: boolean;
    hasHeader: boolean;
};

Props accepted by {@link VireoLabelBox }.

/** Props accepted by {@link VireoLabelBox}. */
export type VireoLabelBoxProps = VireoLabelBoxOwnProps & (VireoLabelBoxAssociatedControlProps | VireoLabelBoxStaticContentProps) & VireoLabelBoxInheritedProps;

export interface VireoLabelBoxRequiredIndicatorSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoLabelBoxRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoLabelBox }.

/** Replaceable semantic regions exposed by {@link VireoLabelBox}. */
export type VireoLabelBoxSlots = {
    [TSlotName in VireoLabelBoxSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoLabelBox }.

/** Slot props exposed by {@link VireoLabelBox}. */
export type VireoLabelBoxSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoLabelBoxSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoLabelBoxRootSlotPropsOverrides, VireoLabelBoxOwnerState>;
    /** @default 'div' */
    header: SlotProps<"div", VireoLabelBoxHeaderSlotPropsOverrides, VireoLabelBoxOwnerState>;
    /** @default 'span' */
    label: SlotProps<"span", VireoLabelBoxLabelSlotPropsOverrides, VireoLabelBoxOwnerState>;
    /** @default 'span' */
    requiredIndicator: SlotProps<"span", VireoLabelBoxRequiredIndicatorSlotPropsOverrides, VireoLabelBoxOwnerState>;
    /** @default 'span' */
    helperText: SlotProps<"span", VireoLabelBoxHelperTextSlotPropsOverrides, VireoLabelBoxOwnerState>;
    /** @default 'div' */
    content: SlotProps<"div", VireoLabelBoxContentSlotPropsOverrides, VireoLabelBoxOwnerState>;
}>;

Backward-compatible static content that manages its own accessible relationships.

/** Backward-compatible static content that manages its own accessible relationships. */
export type VireoLabelBoxStaticContentProps = {
    /** Content laid out beneath or beside the label anatomy. */
    children: React.ReactNode;
    /** Optional visible label content. */
    label?: React.ReactNode;
};

Renders a compact icon-over-label action with optional selected and status states.

/** Renders a compact icon-over-label action with optional selected and status states. */
export declare const VireoLabeledIconButton: React.ForwardRefExoticComponent<Omit<VireoLabeledIconButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

Valid keys for VireoLabeledIconButton utility classes and theme style overrides.

/** Valid keys for VireoLabeledIconButton utility classes and theme style overrides. */
export type VireoLabeledIconButtonClassKey = keyof VireoLabeledIconButtonClasses;

Utility classes available to VireoLabeledIconButton.

/** Utility classes available to VireoLabeledIconButton. */
export type VireoLabeledIconButtonClasses = Record<VireoLabeledIconButtonSlotName, string>;

Props VireoLabeledIconButton inherits from its default root after excluding component-owned props.

/** Props VireoLabeledIconButton inherits from its default root after excluding component-owned props. */
export type VireoLabeledIconButtonInheritedProps = Omit<ButtonProps, "children" | "component" | "selected">;

export interface VireoLabeledIconButtonLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoLabeledIconButtonOwnProps = VireoLabeledIconButtonSlotsAndSlotProps & {
    label: React.ReactNode;
    icon?: VireoIconName | React.ReactElement;
    selected?: boolean;
    showStatusDot?: boolean;
    classes?: Partial<VireoLabeledIconButtonClasses>;
};

export type VireoLabeledIconButtonOwnerState = {
    disabled: boolean;
    selected: boolean;
    showStatusDot: boolean;
    hasIcon: boolean;
};

Props accepted by {@link VireoLabeledIconButton }.

/** Props accepted by {@link VireoLabeledIconButton}. */
export type VireoLabeledIconButtonProps = VireoLabeledIconButtonOwnProps & VireoLabeledIconButtonInheritedProps;

export interface VireoLabeledIconButtonRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoLabeledIconButtonSlots = {
    [TSlotName in VireoLabeledIconButtonSlotName]: React.ElementType;
};

export type VireoLabeledIconButtonSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoLabeledIconButtonSlots, {
    /** @default Button */ root: SlotProps<typeof Button, VireoLabeledIconButtonRootSlotPropsOverrides, VireoLabeledIconButtonOwnerState>;
    /** @default 'span' */ visual: SlotProps<typeof Box, VireoLabeledIconButtonVisualSlotPropsOverrides, VireoLabeledIconButtonOwnerState>;
    /** @default 'span' */ statusDot: SlotProps<typeof Box, VireoLabeledIconButtonStatusDotSlotPropsOverrides, VireoLabeledIconButtonOwnerState>;
    /** @default Typography */ label: SlotProps<typeof Typography, VireoLabeledIconButtonLabelSlotPropsOverrides, VireoLabeledIconButtonOwnerState>;
}>;

export interface VireoLabeledIconButtonStatusDotSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoLabeledIconButtonVisualSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Owns reveal timing, busy semantics, and one polite announcement for a loading region.

/** Owns reveal timing, busy semantics, and one polite announcement for a loading region. */
export declare const VireoLoadingRegion: React.ForwardRefExoticComponent<Omit<VireoLoadingRegionProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoLoadingRegion utility classes and theme style overrides.

/** Valid keys for VireoLoadingRegion utility classes and theme style overrides. */
export type VireoLoadingRegionClassKey = keyof VireoLoadingRegionClasses;

export type VireoLoadingRegionClasses = Record<VireoLoadingRegionSlotName | VireoLoadingRegionStateClassKey, string>;

Props VireoLoadingRegion inherits from its default root after excluding component-owned props.

/** Props VireoLoadingRegion inherits from its default root after excluding component-owned props. */
export type VireoLoadingRegionInheritedProps = Omit<BoxProps<"div">, "aria-busy" | "children" | "component">;

Props owned by {@link VireoLoadingRegion }.

/** Props owned by {@link VireoLoadingRegion}. */
export type VireoLoadingRegionOwnProps = VireoLoadingRegionSlotsAndSlotProps & {
    /** Whether this boundary should announce prolonged loading. Nested visual-only regions should disable this. @default true */
    announce?: boolean;
    /** Stable content or a render function receiving the normalized loading state. */
    children: React.ReactNode | ((state: VireoLoadingRegionRenderState) => React.ReactNode);
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoLoadingRegionClasses>;
    /** Whether this region is waiting for content. */
    loading: boolean;
    /** Concise status announced after the reveal delay. */
    loadingLabel: React.ReactNode;
    /** Delay before visual placeholders and the status announcement become visible. */
    revealDelay?: number;
};

export type VireoLoadingRegionOwnerState = VireoLoadingRegionRenderState & {
    announce: boolean;
    revealDelay: number;
};

Props accepted by {@link VireoLoadingRegion }.

/** Props accepted by {@link VireoLoadingRegion}. */
export type VireoLoadingRegionProps = VireoLoadingRegionOwnProps & VireoLoadingRegionInheritedProps;

export type VireoLoadingRegionRenderState = {
    loading: boolean;
    loadingVisible: boolean;
};

export interface VireoLoadingRegionRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoLoadingRegion }.

/** Replaceable semantic regions exposed by {@link VireoLoadingRegion}. */
export type VireoLoadingRegionSlots = {
    [TSlotName in VireoLoadingRegionSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoLoadingRegion }.

/** Slot props exposed by {@link VireoLoadingRegion}. */
export type VireoLoadingRegionSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoLoadingRegionSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoLoadingRegionRootSlotPropsOverrides, VireoLoadingRegionOwnerState>;
    /** @default 'span' */
    status: SlotProps<"span", VireoLoadingRegionStatusSlotPropsOverrides, VireoLoadingRegionOwnerState>;
}>;

Utility classes available to VireoLoadingRegion.

/** Utility classes available to VireoLoadingRegion. */
export type VireoLoadingRegionStateClassKey = "loading" | "loadingVisible";

export interface VireoLoadingRegionStatusSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoLoadingTokens = typeof VIREO_LOADING_TOKENS;

Renders a controlled, router-agnostic set of primary mobile destinations with safe-area-aware shell styling.

/**
 * Renders a controlled, router-agnostic set of primary mobile destinations with safe-area-aware shell styling.
 */
export declare const VireoMobileBottomNavigation: React.ForwardRefExoticComponent<Omit<VireoMobileBottomNavigationProps, "ref"> & React.RefAttributes<HTMLElement>>;

export interface VireoMobileBottomNavigationActionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoMobileBottomNavigation utility classes and theme style overrides.

/** Valid keys for VireoMobileBottomNavigation utility classes and theme style overrides. */
export type VireoMobileBottomNavigationClassKey = keyof VireoMobileBottomNavigationClasses;

Utility classes available to VireoMobileBottomNavigation.

/** Utility classes available to VireoMobileBottomNavigation. */
export type VireoMobileBottomNavigationClasses = Record<VireoMobileBottomNavigationSlotName, string>;

Props VireoMobileBottomNavigation inherits from its default root after excluding component-owned props.

/** Props VireoMobileBottomNavigation inherits from its default root after excluding component-owned props. */
export type VireoMobileBottomNavigationInheritedProps = Omit<BoxProps<"nav">, "children" | "component" | "onChange">;

export type VireoMobileBottomNavigationItem = {
    /** Stable opaque value reported when the destination is selected. */
    value: string;
    /** Visible destination label. */
    label: string;
    /** Decorative destination icon. */
    icon: React.ReactNode;
    /** Optional accessible name when it must differ from the visible label. */
    ariaLabel?: string;
    /** Whether the destination is unavailable. @default false */
    disabled?: boolean;
};

export interface VireoMobileBottomNavigationNavigationSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoMobileBottomNavigation }.

/** Props owned by {@link VireoMobileBottomNavigation}. */
export type VireoMobileBottomNavigationOwnProps = VireoMobileBottomNavigationSlotsAndSlotProps & {
    /** Destinations rendered in their supplied order. Three to five concise destinations are recommended. */
    items: readonly VireoMobileBottomNavigationItem[];
    /** Selected opaque destination value, or false when the current location has no quick-navigation destination. @default false */
    value?: string | false;
    /** Called after a destination is selected. */
    onChange?: (value: string, event: React.SyntheticEvent) => void;
    /** Adds the device bottom safe-area inset below the navigation actions. @default true */
    safeAreaInset?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoMobileBottomNavigationClasses>;
};

export type VireoMobileBottomNavigationOwnerState = {
    itemCount: number;
    safeAreaInset: boolean;
    selected: boolean;
};

Props accepted by {@link VireoMobileBottomNavigation }.

/** Props accepted by {@link VireoMobileBottomNavigation}. */
export type VireoMobileBottomNavigationProps = VireoMobileBottomNavigationOwnProps & VireoMobileBottomNavigationInheritedProps;

export interface VireoMobileBottomNavigationRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoMobileBottomNavigation }.

/** Replaceable semantic regions exposed by {@link VireoMobileBottomNavigation}. */
export type VireoMobileBottomNavigationSlots = {
    [TSlotName in VireoMobileBottomNavigationSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoMobileBottomNavigation }.

/** Slot props exposed by {@link VireoMobileBottomNavigation}. */
export type VireoMobileBottomNavigationSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoMobileBottomNavigationSlots, {
    /** @default 'nav' */
    root: SlotProps<"nav", VireoMobileBottomNavigationRootSlotPropsOverrides, VireoMobileBottomNavigationOwnerState>;
    /** @default BottomNavigation */
    navigation: SlotProps<typeof BottomNavigation, VireoMobileBottomNavigationNavigationSlotPropsOverrides, VireoMobileBottomNavigationOwnerState>;
    /** @default BottomNavigationAction */
    action: SlotProps<typeof BottomNavigationAction, VireoMobileBottomNavigationActionSlotPropsOverrides, VireoMobileBottomNavigationOwnerState>;
}>;

export type VireoMotionTokens = typeof VIREO_MOTION_TOKENS;

export interface VireoNullableSearchParamStateOptions<T> extends Omit<VireoSearchParamCommonOptions, "keepDefaultInUrl"> {
    defaultValue: null;
    codec: VireoSearchParamCodec<T>;
    keepDefaultInUrl?: false;
}

Renders the standard header anatomy for Vireo dialogs, drawers, bottom sheets, and side panels.

/**
 * Renders the standard header anatomy for Vireo dialogs, drawers, bottom sheets, and side panels.
 */
export declare const VireoOverlayHeader: React.ForwardRefExoticComponent<(Omit<import("./VireoOverlayHeader.types.js").VireoOverlayHeaderSlotsAndSlotProps & {
    title: React.ReactNode;
    titleId?: string;
    leadingAction?: React.ReactNode;
    actions?: React.ReactNode;
    sticky?: boolean;
    classes?: Partial<import("./VireoOverlayHeader.classes.js").VireoOverlayHeaderClasses>;
} & {
    onClose: React.MouseEventHandler<HTMLButtonElement>;
    closeLabel: string;
    closeDisabled?: boolean;
} & import("./VireoOverlayHeader.types.js").VireoOverlayHeaderInheritedProps, "ref"> | Omit<import("./VireoOverlayHeader.types.js").VireoOverlayHeaderSlotsAndSlotProps & {
    title: React.ReactNode;
    titleId?: string;
    leadingAction?: React.ReactNode;
    actions?: React.ReactNode;
    sticky?: boolean;
    classes?: Partial<import("./VireoOverlayHeader.classes.js").VireoOverlayHeaderClasses>;
} & {
    onClose?: undefined;
    closeLabel?: never;
    closeDisabled?: never;
} & import("./VireoOverlayHeader.types.js").VireoOverlayHeaderInheritedProps, "ref">) & React.RefAttributes<HTMLElement>>;

export interface VireoOverlayHeaderActionsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoOverlayHeader utility classes and theme style overrides.

/** Valid keys for VireoOverlayHeader utility classes and theme style overrides. */
export type VireoOverlayHeaderClassKey = keyof VireoOverlayHeaderClasses;

Utility classes available to VireoOverlayHeader.

/** Utility classes available to VireoOverlayHeader. */
export type VireoOverlayHeaderClasses = Record<VireoOverlayHeaderSlotName, string>;

export interface VireoOverlayHeaderCloseButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoOverlayHeaderCloseIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

A close button is only valid when both its callback and accessible label are provided.

/** A close button is only valid when both its callback and accessible label are provided. */
export type VireoOverlayHeaderCloseProps = {
    onClose: React.MouseEventHandler<HTMLButtonElement>;
    closeLabel: string;
    closeDisabled?: boolean;
} | {
    onClose?: undefined;
    closeLabel?: never;
    closeDisabled?: never;
};

Props VireoOverlayHeader inherits from its default root after excluding component-owned props.

/** Props VireoOverlayHeader inherits from its default root after excluding component-owned props. */
export type VireoOverlayHeaderInheritedProps = Omit<BoxProps<"header">, "children" | "component" | "onClose" | "title">;

export interface VireoOverlayHeaderLeadingActionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props shared by closable and non-closable overlay headers.

/** Props shared by closable and non-closable overlay headers. */
export type VireoOverlayHeaderOwnProps = VireoOverlayHeaderSlotsAndSlotProps & {
    /** Visible overlay title. String values are rendered as text, never parsed as HTML. */
    title: React.ReactNode;
    /** ID applied to the title and referenced by the containing overlay surface. */
    titleId?: string;
    /** Optional leading navigation or action control. */
    leadingAction?: React.ReactNode;
    /** Optional status or action content rendered after the title. */
    actions?: React.ReactNode;
    /** Keeps the header above scrolling overlay content. @default true */
    sticky?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoOverlayHeaderClasses>;
};

export type VireoOverlayHeaderOwnerState = {
    sticky: boolean;
    closable: boolean;
    closeDisabled: boolean;
    hasLeadingAction: boolean;
    hasActions: boolean;
};

Props accepted by {@link VireoOverlayHeader }.

/** Props accepted by {@link VireoOverlayHeader}. */
export type VireoOverlayHeaderProps = VireoOverlayHeaderOwnProps & VireoOverlayHeaderCloseProps & VireoOverlayHeaderInheritedProps;

export interface VireoOverlayHeaderRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoOverlayHeader }.

/** Replaceable semantic regions exposed by {@link VireoOverlayHeader}. */
export type VireoOverlayHeaderSlots = {
    [TSlotName in VireoOverlayHeaderSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoOverlayHeader }.

/** Slot props exposed by {@link VireoOverlayHeader}. */
export type VireoOverlayHeaderSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoOverlayHeaderSlots, {
    /** @default 'header' */
    root: SlotProps<"header", VireoOverlayHeaderRootSlotPropsOverrides, VireoOverlayHeaderOwnerState>;
    /** @default 'div' */
    leadingAction: SlotProps<"div", VireoOverlayHeaderLeadingActionSlotPropsOverrides, VireoOverlayHeaderOwnerState>;
    /** @default Typography */
    title: SlotProps<typeof Typography, VireoOverlayHeaderTitleSlotPropsOverrides, VireoOverlayHeaderOwnerState>;
    /** @default 'div' */
    actions: SlotProps<"div", VireoOverlayHeaderActionsSlotPropsOverrides, VireoOverlayHeaderOwnerState>;
    /** @default IconButton */
    closeButton: SlotProps<typeof IconButton, VireoOverlayHeaderCloseButtonSlotPropsOverrides, VireoOverlayHeaderOwnerState>;
    /** @default Close */
    closeIcon: SlotProps<typeof Close, VireoOverlayHeaderCloseIconSlotPropsOverrides, VireoOverlayHeaderOwnerState>;
}>;

export interface VireoOverlayHeaderTitleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Establishes a container-measured page-layout context and the standard bounded page frame.

/** Establishes a container-measured page-layout context and the standard bounded page frame. */
export declare const VireoPage: React.ForwardRefExoticComponent<Omit<VireoPageProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Supplies the standard scrolling page content region and optional sibling drawer.

/** Supplies the standard scrolling page content region and optional sibling drawer. */
export declare const VireoPageBody: React.ForwardRefExoticComponent<Omit<VireoPageBodyProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoPageBody utility classes and theme style overrides.

/** Valid keys for VireoPageBody utility classes and theme style overrides. */
export type VireoPageBodyClassKey = keyof VireoPageBodyClasses;

Utility classes available to VireoPageBody.

/** Utility classes available to VireoPageBody. */
export type VireoPageBodyClasses = Record<VireoPageBodySlotName, string>;

export interface VireoPageBodyContainerSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPageBodyContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPageBodyDrawerSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoPageBodyInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoPageBodyOwnProps = VireoPageBodySlotsAndSlotProps & {
    children: React.ReactNode;
    drawer?: React.ReactNode;
    maxWidth?: ContainerProps["maxWidth"];
    paddingOnCompact?: boolean;
    regularPadding?: number;
    compactPadding?: number;
    classes?: Partial<VireoPageBodyClasses>;
};

export type VireoPageBodyOwnerState = {
    mode: VireoPageLayoutMode;
    paddingOnCompact: boolean;
};

export type VireoPageBodyProps = VireoPageBodyOwnProps & VireoPageBodyInheritedProps;

export interface VireoPageBodyRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoPageBodySlots = {
    [TSlotName in VireoPageBodySlotName]: React.ElementType;
};

export type VireoPageBodySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoPageBodySlots, {
    root: SlotProps<"div", VireoPageBodyRootSlotPropsOverrides, VireoPageBodyOwnerState>;
    content: SlotProps<"div", VireoPageBodyContentSlotPropsOverrides, VireoPageBodyOwnerState>;
    container: SlotProps<typeof Container, VireoPageBodyContainerSlotPropsOverrides, VireoPageBodyOwnerState>;
    drawer: SlotProps<"aside", VireoPageBodyDrawerSlotPropsOverrides, VireoPageBodyOwnerState>;
}>;

Valid keys for VireoPage utility classes and theme style overrides.

/** Valid keys for VireoPage utility classes and theme style overrides. */
export type VireoPageClassKey = keyof VireoPageClasses;

Utility classes available to VireoPage.

/** Utility classes available to VireoPage. */
export type VireoPageClasses = Record<VireoPageSlotName, string>;

Renders the standard page title row with optional leading navigation and trailing actions.

/** Renders the standard page title row with optional leading navigation and trailing actions. */
export declare const VireoPageHeader: React.ForwardRefExoticComponent<Omit<VireoPageHeaderProps, "ref"> & React.RefAttributes<HTMLElement>>;

export interface VireoPageHeaderActionsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoPageHeader utility classes and theme style overrides.

/** Valid keys for VireoPageHeader utility classes and theme style overrides. */
export type VireoPageHeaderClassKey = keyof VireoPageHeaderClasses;

Utility classes available to VireoPageHeader.

/** Utility classes available to VireoPageHeader. */
export type VireoPageHeaderClasses = Record<VireoPageHeaderSlotName, string>;

export type VireoPageHeaderInheritedProps = Omit<BoxProps<"header">, "children" | "component" | "title">;

export interface VireoPageHeaderLeadingSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoPageHeaderOwnProps = VireoPageHeaderSlotsAndSlotProps & {
    title?: React.ReactNode;
    leading?: React.ReactNode;
    actions?: React.ReactNode;
    classes?: Partial<VireoPageHeaderClasses>;
};

export type VireoPageHeaderOwnerState = {
    mode: VireoPageLayoutMode;
    hasLeading: boolean;
    hasActions: boolean;
};

export type VireoPageHeaderProps = VireoPageHeaderOwnProps & VireoPageHeaderInheritedProps;

export interface VireoPageHeaderRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoPageHeaderSlots = {
    [TSlotName in VireoPageHeaderSlotName]: React.ElementType;
};

export type VireoPageHeaderSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoPageHeaderSlots, {
    root: SlotProps<"header", VireoPageHeaderRootSlotPropsOverrides, VireoPageHeaderOwnerState>;
    leading: SlotProps<"div", VireoPageHeaderLeadingSlotPropsOverrides, VireoPageHeaderOwnerState>;
    title: SlotProps<typeof Typography, VireoPageHeaderTitleSlotPropsOverrides, VireoPageHeaderOwnerState>;
    actions: SlotProps<"div", VireoPageHeaderActionsSlotPropsOverrides, VireoPageHeaderOwnerState>;
}>;

export interface VireoPageHeaderTitleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoPageInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoPageLayout = {
    mode: VireoPageLayoutMode;
    isCompact: boolean;
    isRegular: boolean;
    isWide: boolean;
};

export type VireoPageLayoutMode = "compact" | "regular" | "wide";

Supplies an explicitly controlled page-layout mode to a subtree.

/** Supplies an explicitly controlled page-layout mode to a subtree. */
export declare function VireoPageLayoutProvider({ value, children }: VireoPageLayoutProviderProps): React.JSX.Element;

export type VireoPageLayoutProviderProps = {
    value: VireoPageLayout;
    children: React.ReactNode;
};

export type VireoPageOwnProps = VireoPageSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Controls the page-layout mode without measuring a container. */
    mode?: VireoPageLayoutMode;
    /** Resolves compact mode without measuring a container. @default false */
    forceCompact?: boolean;
    /** Measures the page's parent instead of the page root. @default false */
    measureParent?: boolean;
    /** Suspends measurement while preserving the last resolved mode. @default false */
    measurementPaused?: boolean;
    /** Inline space to subtract from the measured container width. @default 0 */
    reservedInlineSize?: number;
    classes?: Partial<VireoPageClasses>;
};

export type VireoPageOwnerState = {
    mode: VireoPageLayoutMode;
};

export type VireoPageProps = VireoPageOwnProps & VireoPageInheritedProps;

export interface VireoPageRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoPageSlots = {
    [TSlotName in VireoPageSlotName]: React.ElementType;
};

export type VireoPageSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoPageSlots, {
    root: SlotProps<"div", VireoPageRootSlotPropsOverrides, VireoPageOwnerState>;
}>;

export type VireoPreferenceItemDefinition = {
    id: string;
    title: string;
    description?: string;
    searchKeywords?: readonly string[];
    icon?: React.ReactNode;
    control: React.ReactNode;
};

Renders searchable, container-responsive groups of application preference controls.

/** Renders searchable, container-responsive groups of application preference controls. */
export declare const VireoPreferencePanel: React.ForwardRefExoticComponent<Omit<VireoPreferencePanelProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoPreferencePanel utility classes and theme style overrides.

/** Valid keys for VireoPreferencePanel utility classes and theme style overrides. */
export type VireoPreferencePanelClassKey = keyof VireoPreferencePanelClasses;

Utility classes available to VireoPreferencePanel.

/** Utility classes available to VireoPreferencePanel. */
export type VireoPreferencePanelClasses = Record<VireoPreferencePanelSlotName, string>;

export interface VireoPreferencePanelEmptyStateSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoPreferencePanel inherits from its default root after excluding component-owned props.

/** Props VireoPreferencePanel inherits from its default root after excluding component-owned props. */
export type VireoPreferencePanelInheritedProps = Omit<CardProps, "children" | "component">;

export interface VireoPreferencePanelItemContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelItemControlSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelItemDescriptionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelItemIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelItemSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelItemTitleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoPreferencePanel }.

/** Props owned by {@link VireoPreferencePanel}. */
export type VireoPreferencePanelOwnProps = VireoPreferencePanelSlotsAndSlotProps & {
    sections: readonly VireoPreferenceSectionDefinition[];
    emptyState: React.ReactNode;
    searchQuery?: string;
    expandedSectionIds?: readonly string[];
    defaultExpandedSectionIds?: readonly string[];
    onExpandedSectionIdsChange?: (ids: readonly string[]) => void;
    controlWidth?: number | string;
    stickySectionHeaders?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoPreferencePanelClasses>;
};

export type VireoPreferencePanelOwnerState = {
    controlWidth: number | string;
    hasVisibleItems: boolean;
    isCompact: boolean;
    isFiltering: boolean;
    stickySectionHeaders: boolean;
};

Props accepted by {@link VireoPreferencePanel }.

/** Props accepted by {@link VireoPreferencePanel}. */
export type VireoPreferencePanelProps = VireoPreferencePanelOwnProps & VireoPreferencePanelInheritedProps;

export interface VireoPreferencePanelRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelSectionActionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelSectionDetailsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelSectionHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelSectionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoPreferencePanelSectionSummarySlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoPreferencePanel }.

/** Replaceable semantic regions exposed by {@link VireoPreferencePanel}. */
export type VireoPreferencePanelSlots = {
    [TSlotName in VireoPreferencePanelSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoPreferencePanel }.

/** Slot props exposed by {@link VireoPreferencePanel}. */
export type VireoPreferencePanelSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoPreferencePanelSlots, {
    /** @default Card */
    root: SlotProps<typeof Card, VireoPreferencePanelRootSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Accordion */
    section: SlotProps<typeof Accordion, VireoPreferencePanelSectionSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    sectionHeader: SlotProps<typeof Box, VireoPreferencePanelSectionHeaderSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default AccordionSummary */
    sectionSummary: SlotProps<typeof AccordionSummary, VireoPreferencePanelSectionSummarySlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    sectionAction: SlotProps<typeof Box, VireoPreferencePanelSectionActionSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default AccordionDetails */
    sectionDetails: SlotProps<typeof AccordionDetails, VireoPreferencePanelSectionDetailsSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    item: SlotProps<typeof Box, VireoPreferencePanelItemSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    itemIcon: SlotProps<typeof Box, VireoPreferencePanelItemIconSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    itemContent: SlotProps<typeof Box, VireoPreferencePanelItemContentSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Typography */
    itemTitle: SlotProps<typeof Typography, VireoPreferencePanelItemTitleSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Typography */
    itemDescription: SlotProps<typeof Typography, VireoPreferencePanelItemDescriptionSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    itemControl: SlotProps<typeof Box, VireoPreferencePanelItemControlSlotPropsOverrides, VireoPreferencePanelOwnerState>;
    /** @default Box */
    emptyState: SlotProps<typeof Box, VireoPreferencePanelEmptyStateSlotPropsOverrides, VireoPreferencePanelOwnerState>;
}>;

export type VireoPreferenceSectionDefinition = {
    id: string;
    title: string;
    action?: React.ReactNode;
    items: readonly VireoPreferenceItemDefinition[];
};

Composes configured provider wrappers from outermost to innermost without obscuring their props.

/** Composes configured provider wrappers from outermost to innermost without obscuring their props. */
export declare function VireoProviderComposer({ children, providers }: VireoProviderComposerProps): import("react").JSX.Element;

export type VireoProviderComposerProps = {
    children: React.ReactNode;
    /** Provider wrappers ordered from outermost to innermost. */
    providers: readonly VireoProviderWrapper[];
};

Wraps already-composed children with one configured provider.

/** Wraps already-composed children with one configured provider. */
export type VireoProviderWrapper = (children: React.ReactNode) => React.ReactElement;

Keeps stable card markup while adapting its visual surface to the nearest page container mode.

/** Keeps stable card markup while adapting its visual surface to the nearest page container mode. */
export declare const VireoResponsiveCard: React.ForwardRefExoticComponent<Omit<VireoResponsiveCardProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoResponsiveCard utility classes and theme style overrides.

/** Valid keys for VireoResponsiveCard utility classes and theme style overrides. */
export type VireoResponsiveCardClassKey = keyof VireoResponsiveCardClasses;

Utility classes available to VireoResponsiveCard.

/** Utility classes available to VireoResponsiveCard. */
export type VireoResponsiveCardClasses = Record<VireoResponsiveCardSlotName, string>;

export type VireoResponsiveCardInheritedProps = Omit<CardProps, "children" | "slots" | "slotProps">;

export type VireoResponsiveCardOwnProps = VireoResponsiveCardSlotsAndSlotProps & {
    children: React.ReactNode;
    surfaceOnCompact?: boolean;
    classes?: Partial<VireoResponsiveCardClasses>;
};

export type VireoResponsiveCardOwnerState = {
    mode: VireoPageLayoutMode;
    surfaceOnCompact: boolean;
};

export type VireoResponsiveCardProps = VireoResponsiveCardOwnProps & VireoResponsiveCardInheritedProps;

export interface VireoResponsiveCardRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoResponsiveCardSlots = {
    [TSlotName in VireoResponsiveCardSlotName]: React.ElementType;
};

export type VireoResponsiveCardSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoResponsiveCardSlots, {
    root: SlotProps<typeof Card, VireoResponsiveCardRootSlotPropsOverrides, VireoResponsiveCardOwnerState>;
}>;

Coordinates a guarded form across mobile full-screen-dialog and desktop overlay surfaces.

/** Coordinates a guarded form across mobile full-screen-dialog and desktop overlay surfaces. */
export declare const VireoResponsiveFormOverlay: React.ForwardRefExoticComponent<import("./VireoResponsiveFormOverlay.types.js").VireoResponsiveFormOverlaySlotsAndSlotProps & {
    title: React.ReactNode;
    closeLabel: string;
    closeDisabled?: boolean;
    children: React.ReactNode;
    actions?: import("./VireoResponsiveFormOverlay.types.js").VireoResponsiveFormOverlayActions;
    renderForm?: (children: React.ReactNode) => React.ReactNode;
    guardUnsavedChanges?: boolean;
    classes?: Partial<import("./VireoResponsiveFormOverlay.classes.js").VireoResponsiveFormOverlayClasses>;
} & Omit<import("../../../../../../index.js").VireoResponsiveOverlayFrameProps, "aria-label" | "aria-labelledby" | "children" | "classes" | "onClose" | "open" | "slotProps" | "slots" | "title"> & {
    open: boolean;
    onClose: () => void;
} & React.RefAttributes<HTMLDivElement>>;

Guarded actions available to a rendered overlay action row.

/** Guarded actions available to a rendered overlay action row. */
export type VireoResponsiveFormOverlayActionContext = {
    /** Requests closure through close disabling and the current unsaved-changes scope. */
    requestClose: () => void;
};

Static actions or a render callback that receives the guarded close request.

/** Static actions or a render callback that receives the guarded close request. */
export type VireoResponsiveFormOverlayActions = React.ReactNode | ((context: VireoResponsiveFormOverlayActionContext) => React.ReactNode);

export interface VireoResponsiveFormOverlayActionsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoResponsiveFormOverlayBodySlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoResponsiveFormOverlay utility classes and theme style overrides.

/** Valid keys for VireoResponsiveFormOverlay utility classes and theme style overrides. */
export type VireoResponsiveFormOverlayClassKey = keyof VireoResponsiveFormOverlayClasses;

Utility classes available to VireoResponsiveFormOverlay.

/** Utility classes available to VireoResponsiveFormOverlay. */
export type VireoResponsiveFormOverlayClasses = Record<VireoResponsiveFormOverlaySlotName, string>;

export interface VireoResponsiveFormOverlayContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoResponsiveFormOverlayHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoResponsiveFormOverlay inherits from its default root after excluding component-owned props.

/** Props VireoResponsiveFormOverlay inherits from its default root after excluding component-owned props. */
export type VireoResponsiveFormOverlayInheritedProps = Omit<VireoResponsiveOverlayFrameProps, "aria-label" | "aria-labelledby" | "children" | "classes" | "onClose" | "open" | "slotProps" | "slots" | "title"> & {
    open: boolean;
    onClose: () => void;
};

Props owned by {@link VireoResponsiveFormOverlay }.

/** Props owned by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlayOwnProps = VireoResponsiveFormOverlaySlotsAndSlotProps & {
    /** Visible overlay heading. */
    title: React.ReactNode;
    /** Accessible label for the close action. */
    closeLabel: string;
    /** Prevents dismissal while a form operation is in progress. @default false */
    closeDisabled?: boolean;
    /** Form content rendered inside the responsive surface. */
    children: React.ReactNode;
    /** Optional persistent action row rendered after the scrolling content. */
    actions?: VireoResponsiveFormOverlayActions;
    /**
     * Wraps the content and action regions in one semantic form boundary.
     * The returned wrapper is normalized to fill the responsive overlay body.
     */
    renderForm?: (children: React.ReactNode) => React.ReactNode;
    /** Whether close requests participate in the nearest unsaved-changes scope. @default true */
    guardUnsavedChanges?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoResponsiveFormOverlayClasses>;
};

export type VireoResponsiveFormOverlayOwnerState = {
    open: boolean;
    closeDisabled: boolean;
    hasActions: boolean;
    hasFormWrapper: boolean;
};

Props accepted by {@link VireoResponsiveFormOverlay }.

/** Props accepted by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlayProps = VireoResponsiveFormOverlayOwnProps & VireoResponsiveFormOverlayInheritedProps;

export interface VireoResponsiveFormOverlayRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoResponsiveFormOverlay }.

/** Replaceable semantic regions exposed by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlaySlots = {
    [TSlotName in VireoResponsiveFormOverlaySlotName]: React.ElementType;
};

Slot props exposed by {@link VireoResponsiveFormOverlay }.

/** Slot props exposed by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlaySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoResponsiveFormOverlaySlots, {
    /** @default VireoResponsiveOverlayFrame */
    root: SlotProps<typeof VireoResponsiveOverlayFrame, VireoResponsiveFormOverlayRootSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default VireoOverlayHeader */
    header: SlotProps<typeof VireoOverlayHeader, VireoResponsiveFormOverlayHeaderSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default Box */
    body: SlotProps<typeof Box, VireoResponsiveFormOverlayBodySlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default DialogContent */
    content: SlotProps<typeof DialogContent, VireoResponsiveFormOverlayContentSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default DialogActions */
    actions: SlotProps<typeof DialogActions, VireoResponsiveFormOverlayActionsSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
}>;

Selects and coordinates the appropriate mobile or desktop overlay surface for one responsive content flow.

/**
 * Selects and coordinates the appropriate mobile or desktop overlay surface for one responsive content flow.
 */
export declare const VireoResponsiveOverlayFrame: React.ForwardRefExoticComponent<VireoResponsiveOverlayFrameProps & React.RefAttributes<HTMLDivElement>>;

An explicit accessible name for every responsive overlay surface.

/** An explicit accessible name for every responsive overlay surface. */
export type VireoResponsiveOverlayFrameAccessibleName = {
    /** Direct accessible name for the selected overlay surface. */
    "aria-label": string;
    /** Optional visible heading relationship; takes precedence for assistive technology. */
    "aria-labelledby"?: string;
} | {
    /** Optional direct fallback when the referenced heading is unavailable. */
    "aria-label"?: string;
    /** ID of the visible heading that names the selected overlay surface. */
    "aria-labelledby": string;
};

Valid keys for VireoResponsiveOverlayFrame utility classes and theme style overrides.

/** Valid keys for VireoResponsiveOverlayFrame utility classes and theme style overrides. */
export type VireoResponsiveOverlayFrameClassKey = keyof VireoResponsiveOverlayFrameClasses;

Utility classes available to VireoResponsiveOverlayFrame.

/** Utility classes available to VireoResponsiveOverlayFrame. */
export type VireoResponsiveOverlayFrameClasses = Record<VireoResponsiveOverlayFrameSlotName, string>;

Width accepted by desktop side-panel surface modes.

/** Width accepted by desktop side-panel surface modes. */
export type VireoResponsiveOverlayFrameDesktopSidePanelWidth = ResponsiveOverlayFrameDesktopSidePanelWidth;

Desktop surface coordinated by the responsive frame.

/** Desktop surface coordinated by the responsive frame. */
export type VireoResponsiveOverlayFrameDesktopSurface = ResponsiveOverlayFrameDesktopSurface;

Props VireoResponsiveOverlayFrame inherits from its default root after excluding component-owned props.

/** Props VireoResponsiveOverlayFrame inherits from its default root after excluding component-owned props. */
export type VireoResponsiveOverlayFrameInheritedProps = Omit<BoxProps<"div">, "aria-label" | "aria-labelledby" | "children" | "component" | "maxWidth" | "ref">;

Mobile surface coordinated by the responsive frame.

/** Mobile surface coordinated by the responsive frame. */
export type VireoResponsiveOverlayFrameMobileSurface = ResponsiveOverlayFrameMobileSurface;

Props owned by {@link VireoResponsiveOverlayFrame }.

/** Props owned by {@link VireoResponsiveOverlayFrame}. */
export type VireoResponsiveOverlayFrameOwnProps = VireoResponsiveOverlayFrameSlotsAndSlotProps & VireoResponsiveOverlayFrameAccessibleName & {
    /** Whether the selected overlay surface is open. */
    open: boolean;
    /** Closes the selected overlay surface. */
    onClose: () => void;
    /** Called after the selected overlay surface finishes leaving. */
    onExited?: () => void;
    /** Maximum width of the desktop dialog surface. @default 'lg' */
    maxWidth?: DialogProps["maxWidth"];
    /** Surface used on mobile. @default 'fullScreenDialog' */
    mobileSurface?: VireoResponsiveOverlayFrameMobileSurface;
    /** Fixed height of the mobile bottom sheet. Ignored by the full-screen dialog surface. */
    mobileHeight?: string;
    /** Maximum height of a content-sized mobile bottom sheet. Ignored by the full-screen dialog surface. @default '92dvh' */
    mobileMaxHeight?: string;
    /** MUI system customization for the desktop dialog paper. */
    desktopPaperSx?: SxProps<Theme>;
    /** Requested width of desktop side-panel surfaces. */
    desktopSidePanelWidth?: VireoResponsiveOverlayFrameDesktopSidePanelWidth;
    /** Minimum width of desktop side-panel surfaces. @default 360 */
    desktopSidePanelMinWidth?: number;
    /** Minimum workspace width retained beside a docked panel. */
    desktopSidePanelMinContentWidth?: number;
    /** MUI system customization for desktop side-panel papers. */
    desktopSidePanelSx?: SxProps<Theme>;
    /** Surface used on desktop. @default 'dialog' */
    desktopSurface?: VireoResponsiveOverlayFrameDesktopSurface;
    /** Enables pointer and keyboard resizing for desktop side-panel surfaces. @default false */
    allowSidePanelResize?: boolean;
    /** Width reserved by desktop navigation when deciding whether a docked panel fits. @default 0 */
    desktopNavWidth?: number;
    /** Contents rendered inside the selected surface. */
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoResponsiveOverlayFrameClasses>;
};

export type VireoResponsiveOverlayFrameOwnerState = {
    open: boolean;
    isMobile: boolean;
    mobileSurface: VireoResponsiveOverlayFrameMobileSurface;
    desktopSurface: VireoResponsiveOverlayFrameDesktopSurface;
    effectiveDesktopSurface: VireoResponsiveOverlayFrameDesktopSurface;
    allowSidePanelResize: boolean;
    sidePanelResizeEnabled: boolean;
    isResizing: boolean;
};

Props accepted by {@link VireoResponsiveOverlayFrame }.

/** Props accepted by {@link VireoResponsiveOverlayFrame}. */
export type VireoResponsiveOverlayFrameProps = VireoResponsiveOverlayFrameOwnProps & VireoResponsiveOverlayFrameInheritedProps;

export interface VireoResponsiveOverlayFrameRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoResponsiveOverlayFrame }.

/** Replaceable semantic regions exposed by {@link VireoResponsiveOverlayFrame}. */
export type VireoResponsiveOverlayFrameSlots = {
    [TSlotName in VireoResponsiveOverlayFrameSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoResponsiveOverlayFrame }.

/** Slot props exposed by {@link VireoResponsiveOverlayFrame}. */
export type VireoResponsiveOverlayFrameSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoResponsiveOverlayFrameSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoResponsiveOverlayFrameRootSlotPropsOverrides, VireoResponsiveOverlayFrameOwnerState>;
}>;

Presents one typed data model as a container-aware desktop table or mobile accordion workflow.

/**
 * Presents one typed data model as a container-aware desktop table or mobile accordion workflow.
 */
export declare const VireoResponsiveTable: VireoResponsiveTableComponent;

export type VireoResponsiveTableCellContext = {
    placement: VireoResponsiveTableCellPlacement;
};

export type VireoResponsiveTableCellPlacement = "desktop" | "mobile-summary" | "mobile-detail";

Valid keys for VireoResponsiveTable utility classes and theme style overrides.

/** Valid keys for VireoResponsiveTable utility classes and theme style overrides. */
export type VireoResponsiveTableClassKey = keyof VireoResponsiveTableClasses;

Utility classes available to VireoResponsiveTable.

/** Utility classes available to VireoResponsiveTable. */
export type VireoResponsiveTableClasses = Record<VireoResponsiveTableSlotName, string>;

export type VireoResponsiveTableColumn<TItem, TId extends string = string> = {
    id: TId;
    renderHeader: () => ReactNode;
    renderBody: (item: TItem, rowIndex: number, context: VireoResponsiveTableCellContext) => ReactNode;
    align?: "left" | "center" | "right";
    /** Arbitrary frontend or backend sort identifier. */
    sort?: string;
    sticky?: "left" | "right" | false;
    minWidthPx?: number;
    /** Pins the column to exactly `minWidthPx` so it never absorbs leftover space. */
    fixedWidth?: boolean;
    /** Required for predictable cumulative offsets when columns are sticky. */
    width?: number;
};

export type VireoResponsiveTableFilters = {
    page: number;
    rowsPerPage: number;
    sortBy: string;
    sortDirection: VireoResponsiveTableSortDirection;
};

export type VireoResponsiveTableInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoResponsiveTableLabels = {
    table: string;
    loadingTable: string;
    loadingNextPage: string;
    loadedNextPage: string;
    noData: string;
    showMore: string;
    showLess: string;
    rowsPerPage: string;
    paginationMoreThan: (from: number, to: number) => string;
    paginationRange: (from: number, to: number, count: number) => string;
    paginationItem: (type: "first" | "last" | "next" | "previous") => string;
    filters: string;
    clearFilters: string;
    filtersDone: string;
    sortBy: string;
    sortDirection: string;
    ascending: string;
    descending: string;
    ascendingSortDirection: string;
    descendingSortDirection: string;
};

export type VireoResponsiveTableLayers = {
    stickyToolbar: number;
    stickyRowHeader: number;
};

export type VireoResponsiveTableLayout = "mobile" | "desktop";

export type VireoResponsiveTableMobileScrollAnchor = {
    rowKey: Key;
    offsetTop: number;
    rowIndex: number;
};

export type VireoResponsiveTableOwnProps<TItem, TColumns extends readonly VireoResponsiveTableColumn<NoInfer<TItem>, string>[]> = VireoResponsiveTableSlotsAndSlotProps & {
    columns: TColumns;
    data: readonly TItem[];
    filters: VireoResponsiveTableFilters;
    onFiltersChange: (filters: VireoResponsiveTableFilters) => void;
    labels: VireoResponsiveTableLabels;
    layers: VireoResponsiveTableLayers;
    renderFilters?: () => ReactNode;
    /** Replaces the default empty-state label in both layouts. */
    renderEmptyState?: () => ReactNode;
    renderMobileFilters?: () => ReactNode;
    /**
     * Shows geometry-preserving placeholder rows for an initial load with no usable records.
     * Do not enable this during refresh; keep existing `data` visible and present refresh feedback outside the table.
     * @default false
     */
    skeleton?: boolean;
    titleColumn?: VireoResponsiveTableColumnId<TColumns>;
    titleEndAdornmentColumn?: VireoResponsiveTableColumnId<TColumns>;
    titleEndAdornmentHelperColumn?: VireoResponsiveTableColumnId<TColumns>;
    actionsColumn?: VireoResponsiveTableColumnId<TColumns>;
    getRowKey?: (item: TItem, rowIndex: number) => Key;
    /** Adds per-row visual feedback without replacing responsive row anatomy. */
    getRowSx?: (item: TItem, rowIndex: number, layout: VireoResponsiveTableLayout) => SxProps<Theme> | undefined;
    totalCount?: number;
    renderMobileSearch?: () => ReactNode;
    filtersCount?: number;
    onClearFilters?: () => void;
    onOpenFilters?: () => void;
    onMobileFiltersDone?: () => void;
    renderTitleEndAdornment?: (item: TItem, rowIndex: number) => ReactNode;
    hasNextPage?: boolean;
    /** Preserves loaded mobile rows and adds local progress while the next incremental page is fetched. */
    isFetchingNextPage?: boolean;
    onLoadNextPage?: () => void;
    filtersLabel?: string;
    clearFiltersLabel?: string;
    filtersDoneLabel?: string;
    rowsPerPageOptions?: readonly number[];
    size?: "small" | "medium";
    initialMobileScrollTop?: number;
    initialMobileScrollAnchor?: VireoResponsiveTableMobileScrollAnchor;
    onMobileScrollTopChange?: (scrollTop: number, anchor?: VireoResponsiveTableMobileScrollAnchor) => void;
    initialExpandedMobileRowKey?: Key | null;
    onExpandedMobileRowKeyChange?: (rowKey: Key | null) => void;
    /** Keeps the table in lockstep with an enclosing responsive layout when provided. */
    layout?: VireoResponsiveTableLayout;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoResponsiveTableClasses>;
};

export type VireoResponsiveTableOwnerState = {
    layout: VireoResponsiveTableLayout | null;
    skeleton: boolean;
};

export type VireoResponsiveTableProps<TItem = unknown, TColumns extends readonly VireoResponsiveTableColumn<NoInfer<TItem>, string>[] = readonly VireoResponsiveTableColumn<NoInfer<TItem>, string>[]> = VireoResponsiveTableOwnProps<TItem, TColumns> & VireoResponsiveTableInheritedProps;

export interface VireoResponsiveTableRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoResponsiveTableSlots = {
    [TSlotName in VireoResponsiveTableSlotName]: React.ElementType;
};

export type VireoResponsiveTableSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoResponsiveTableSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoResponsiveTableRootSlotPropsOverrides, VireoResponsiveTableOwnerState>;
}>;

export type VireoResponsiveTableSortDirection = "asc" | "desc";

export interface VireoSearchParamCodec<T> {
    /** Parses one decoded URLSearchParams value. Throw when the external value is invalid. */
    parse(rawValue: string): T;
    /** Serializes one value without applying URL percent encoding. */
    serialize(value: T): string;
}

export type VireoSearchParamHistory = "replace" | "push";

export interface VireoSearchParamStateOptions<T extends NonNullable<unknown>> extends VireoSearchParamCommonOptions {
    defaultValue: T;
    codec: VireoSearchParamCodec<T>;
}

export type VireoSearchParamStateResult<T> = readonly [
    value: T,
    setValue: VireoSearchParamStateSetter<T>
];

export type VireoSearchParamStateSetter<T> = (value: T | ((currentValue: T) => T)) => void;

Renders the pointer and keyboard interaction target for resizing a Vireo side panel.

/**
 * Renders the pointer and keyboard interaction target for resizing a Vireo side panel.
 */
export declare const VireoSidePanelResizeHandle: React.ForwardRefExoticComponent<Omit<VireoSidePanelResizeHandleProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoSidePanelResizeHandle utility classes and theme style overrides.

/** Valid keys for VireoSidePanelResizeHandle utility classes and theme style overrides. */
export type VireoSidePanelResizeHandleClassKey = keyof VireoSidePanelResizeHandleClasses;

Utility classes available to VireoSidePanelResizeHandle.

/** Utility classes available to VireoSidePanelResizeHandle. */
export type VireoSidePanelResizeHandleClasses = Record<VireoSidePanelResizeHandleSlotName | "resizing", string>;

Props VireoSidePanelResizeHandle inherits from its default root after excluding component-owned props.

/** Props VireoSidePanelResizeHandle inherits from its default root after excluding component-owned props. */
export type VireoSidePanelResizeHandleInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "onDoubleClick" | "onKeyDown" | "onMouseDown" | "onPointerDown" | "role" | "tabIndex">;

Props owned by {@link VireoSidePanelResizeHandle }.

/** Props owned by {@link VireoSidePanelResizeHandle}. */
export type VireoSidePanelResizeHandleOwnProps = VireoSidePanelResizeHandleSlotsAndSlotProps & {
    /** Whether the resize handle is rendered. @default true */
    enabled?: boolean;
    /** Whether an active pointer resize is in progress. @default false */
    isResizing?: boolean;
    /** Starts pointer-driven resizing. */
    onResizeStart: React.MouseEventHandler<HTMLDivElement>;
    /** Handles keyboard-driven resizing when value metadata is also provided. */
    onResizeKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
    /** Restores the owning panel's initial width. */
    onResizeDoubleClick: React.MouseEventHandler<HTMLDivElement>;
    /** Smallest keyboard-adjustable width. */
    valueMin?: number;
    /** Largest keyboard-adjustable width. */
    valueMax?: number;
    /** Current keyboard-adjustable width. */
    valueNow?: number;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoSidePanelResizeHandleClasses>;
};

export type VireoSidePanelResizeHandleOwnerState = {
    enabled: boolean;
    isResizing: boolean;
};

Props accepted by {@link VireoSidePanelResizeHandle }.

/** Props accepted by {@link VireoSidePanelResizeHandle}. */
export type VireoSidePanelResizeHandleProps = VireoSidePanelResizeHandleOwnProps & VireoSidePanelResizeHandleInheritedProps;

export interface VireoSidePanelResizeHandleRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoSidePanelResizeHandle }.

/** Replaceable semantic regions exposed by {@link VireoSidePanelResizeHandle}. */
export type VireoSidePanelResizeHandleSlots = {
    [TSlotName in VireoSidePanelResizeHandleSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoSidePanelResizeHandle }.

/** Slot props exposed by {@link VireoSidePanelResizeHandle}. */
export type VireoSidePanelResizeHandleSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoSidePanelResizeHandleSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoSidePanelResizeHandleRootSlotPropsOverrides, VireoSidePanelResizeHandleOwnerState>;
}>;

Silent placeholder leaf for preserving text, icon, or media geometry while content loads.

/** Silent placeholder leaf for preserving text, icon, or media geometry while content loads. */
export declare const VireoSkeleton: React.ForwardRefExoticComponent<Omit<VireoSkeletonProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

Valid keys for VireoSkeleton utility classes and theme style overrides.

/** Valid keys for VireoSkeleton utility classes and theme style overrides. */
export type VireoSkeletonClassKey = keyof VireoSkeletonClasses;

Utility classes available to VireoSkeleton.

/** Utility classes available to VireoSkeleton. */
export type VireoSkeletonClasses = Record<VireoSkeletonSlotName, string>;

Props VireoSkeleton inherits from its default root after excluding component-owned props.

/** Props VireoSkeleton inherits from its default root after excluding component-owned props. */
export type VireoSkeletonInheritedProps = Omit<SkeletonProps, "animation" | "children" | "classes" | "component" | "variant">;

Props owned by {@link VireoSkeleton }.

/** Props owned by {@link VireoSkeleton}. */
export type VireoSkeletonOwnProps = VireoSkeletonSlotsAndSlotProps & {
    /** Optional content whose rendered geometry the skeleton should preserve. */
    children?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoSkeletonClasses>;
    /** Shape of the placeholder. @default 'text' */
    variant?: VireoSkeletonVariant;
};

export type VireoSkeletonOwnerState = {
    hasChildren: boolean;
    variant: VireoSkeletonVariant;
};

Props accepted by {@link VireoSkeleton }.

/** Props accepted by {@link VireoSkeleton}. */
export type VireoSkeletonProps = VireoSkeletonOwnProps & VireoSkeletonInheritedProps;

export interface VireoSkeletonRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoSkeleton }.

/** Replaceable semantic regions exposed by {@link VireoSkeleton}. */
export type VireoSkeletonSlots = {
    [TSlotName in VireoSkeletonSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoSkeleton }.

/** Slot props exposed by {@link VireoSkeleton}. */
export type VireoSkeletonSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoSkeletonSlots, {
    /** @default MUI Skeleton */
    root: SlotProps<"span", VireoSkeletonRootSlotPropsOverrides, VireoSkeletonOwnerState>;
}>;

export type VireoSkeletonVariant = NonNullable<SkeletonProps["variant"]>;

Animates a controlled collection of full-width screens along one horizontal track.

/** Animates a controlled collection of full-width screens along one horizontal track. */
export declare const VireoSlidingScreenStack: React.ForwardRefExoticComponent<Omit<VireoSlidingScreenStackProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoSlidingScreenStack utility classes and theme style overrides.

/** Valid keys for VireoSlidingScreenStack utility classes and theme style overrides. */
export type VireoSlidingScreenStackClassKey = keyof VireoSlidingScreenStackClasses;

Utility classes available to VireoSlidingScreenStack.

/** Utility classes available to VireoSlidingScreenStack. */
export type VireoSlidingScreenStackClasses = Record<VireoSlidingScreenStackSlotName, string>;

Props VireoSlidingScreenStack inherits from its default root after excluding component-owned props.

/** Props VireoSlidingScreenStack inherits from its default root after excluding component-owned props. */
export type VireoSlidingScreenStackInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoSlidingScreenStackOwnProps = VireoSlidingScreenStackSlotsAndSlotProps & {
    /** Screen id currently positioned in the viewport. Unknown ids fall back to the first screen. */
    activeScreen: string;
    /** Ordered screens retained in the DOM while the track moves between them. */
    screens: readonly VireoSlidingScreenStackScreen[];
    classes?: Partial<VireoSlidingScreenStackClasses>;
};

export type VireoSlidingScreenStackOwnerState = {
    activeScreenIndex: number;
    screenCount: number;
};

Props accepted by {@link VireoSlidingScreenStack }.

/** Props accepted by {@link VireoSlidingScreenStack}. */
export type VireoSlidingScreenStackProps = VireoSlidingScreenStackOwnProps & VireoSlidingScreenStackInheritedProps;

export interface VireoSlidingScreenStackRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

One stable, keyed screen rendered by VireoSlidingScreenStack.

/** One stable, keyed screen rendered by VireoSlidingScreenStack. */
export type VireoSlidingScreenStackScreen = {
    id: string;
    children: React.ReactNode;
};

export interface VireoSlidingScreenStackScreenSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoSlidingScreenStackSlots = {
    [T in VireoSlidingScreenStackSlotName]: React.ElementType;
};

export type VireoSlidingScreenStackSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoSlidingScreenStackSlots, {
    /** @default 'div' */ root: SlotProps<typeof Box, VireoSlidingScreenStackRootSlotPropsOverrides, VireoSlidingScreenStackOwnerState>;
    /** @default 'div' */ track: SlotProps<typeof Box, VireoSlidingScreenStackTrackSlotPropsOverrides, VireoSlidingScreenStackOwnerState>;
    /** @default 'div' */ screen: SlotProps<typeof Box, VireoSlidingScreenStackScreenSlotPropsOverrides, VireoSlidingScreenStackOwnerState>;
}>;

export interface VireoSlidingScreenStackTrackSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Ordered public slot-name tuple requiring `root` as its first entry.

/** Ordered public slot-name tuple requiring `root` as its first entry. */
export type VireoSlotNameTuple = readonly [
    "root",
    ...string[]
];

Displays a compact semantic status marker with theme-aware colors and optional standalone labelling.

/**
 * Displays a compact semantic status marker with theme-aware colors and optional standalone labelling.
 */
export declare const VireoStatusDot: React.ForwardRefExoticComponent<Omit<VireoStatusDotProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

Valid keys for VireoStatusDot utility classes and theme style overrides.

/** Valid keys for VireoStatusDot utility classes and theme style overrides. */
export type VireoStatusDotClassKey = keyof VireoStatusDotClasses;

Utility classes available to VireoStatusDot.

/** Utility classes available to VireoStatusDot. */
export type VireoStatusDotClasses = Record<VireoStatusDotSlotName | "selected", string>;

export type VireoStatusDotColor = "success" | "error" | "warning" | "info" | "standard";

Props VireoStatusDot inherits from its default root after excluding component-owned props.

/** Props VireoStatusDot inherits from its default root after excluding component-owned props. */
export type VireoStatusDotInheritedProps = Omit<BoxProps<"span">, "aria-hidden" | "aria-label" | "children" | "color" | "component" | "role">;

Props owned by {@link VireoStatusDot }.

/** Props owned by {@link VireoStatusDot}. */
export type VireoStatusDotOwnProps = VireoStatusDotSlotsAndSlotProps & {
    /** Semantic color represented by the dot. */
    color: VireoStatusDotColor;
    /** Accessible label for a standalone dot. Omit when adjacent text already conveys its meaning. */
    label?: string;
    /** Inverts the dot for selected or emphasized surfaces. @default false */
    selected?: boolean;
    /** Diameter of the dot. Numbers are interpreted as pixels. @default 8 */
    size?: VireoStatusDotSize;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoStatusDotClasses>;
};

export type VireoStatusDotOwnerState = {
    color: VireoStatusDotColor;
    labeled: boolean;
    selected: boolean;
    size: VireoStatusDotSize;
};

Props accepted by {@link VireoStatusDot }.

/** Props accepted by {@link VireoStatusDot}. */
export type VireoStatusDotProps = VireoStatusDotOwnProps & VireoStatusDotInheritedProps;

export interface VireoStatusDotRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoStatusDotSize = number | string;

Replaceable semantic regions exposed by {@link VireoStatusDot }.

/** Replaceable semantic regions exposed by {@link VireoStatusDot}. */
export type VireoStatusDotSlots = {
    [TSlotName in VireoStatusDotSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoStatusDot }.

/** Slot props exposed by {@link VireoStatusDot}. */
export type VireoStatusDotSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoStatusDotSlots, {
    /** @default 'span' */
    root: SlotProps<"span", VireoStatusDotRootSlotPropsOverrides, VireoStatusDotOwnerState>;
}>;

Displays a live or stopped duration measured from a supplied timestamp. Long durations use fixed 365-day years and 30-day months.

/**
 * Displays a live or stopped duration measured from a supplied timestamp.
 * Long durations use fixed 365-day years and 30-day months.
 */
export declare const VireoStopwatch: React.ForwardRefExoticComponent<Omit<VireoStopwatchProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

Valid keys for VireoStopwatch utility classes and theme style overrides.

/** Valid keys for VireoStopwatch utility classes and theme style overrides. */
export type VireoStopwatchClassKey = keyof VireoStopwatchClasses;

Utility classes available to VireoStopwatch.

/** Utility classes available to VireoStopwatch. */
export type VireoStopwatchClasses = Record<VireoStopwatchSlotName, string>;

Props VireoStopwatch inherits from its default root after excluding component-owned props.

/** Props VireoStopwatch inherits from its default root after excluding component-owned props. */
export type VireoStopwatchInheritedProps = Omit<BoxProps<"span">, "aria-atomic" | "aria-label" | "children" | "component" | "role">;

Props owned by {@link VireoStopwatch }.

/** Props owned by {@link VireoStopwatch}. */
export type VireoStopwatchOwnProps = VireoStopwatchSlotsAndSlotProps & {
    /** Timestamp at which elapsed-time measurement stops. Omit or set to null for a live stopwatch. */
    endDate?: VireoStopwatchTimestamp | null;
    /** Accessible description announced together with the formatted duration. @default 'Elapsed time' */
    label?: string;
    /** Timestamp from which elapsed time is measured. Omit or set to null to start when the component mounts. */
    startDate?: VireoStopwatchTimestamp | null;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoStopwatchClasses>;
};

export type VireoStopwatchOwnerState = {
    running: boolean;
    valid: boolean;
};

Props accepted by {@link VireoStopwatch }.

/** Props accepted by {@link VireoStopwatch}. */
export type VireoStopwatchProps = VireoStopwatchOwnProps & VireoStopwatchInheritedProps;

export interface VireoStopwatchRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoStopwatch }.

/** Replaceable semantic regions exposed by {@link VireoStopwatch}. */
export type VireoStopwatchSlots = {
    [TSlotName in VireoStopwatchSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoStopwatch }.

/** Slot props exposed by {@link VireoStopwatch}. */
export type VireoStopwatchSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoStopwatchSlots, {
    /** @default 'span' */
    root: SlotProps<"span", VireoStopwatchRootSlotPropsOverrides, VireoStopwatchOwnerState>;
}>;

export type VireoStopwatchTimestamp = Date | number;

export interface VireoStringSearchParamStateOptions extends VireoSearchParamCommonOptions {
    defaultValue: string;
    codec?: VireoSearchParamCodec<string>;
}

export type VireoTabItem = {
    value: string;
    label: React.ReactNode;
    content: React.ReactNode;
    disabled?: boolean;
};

Renders accessible controlled or uncontrolled tab navigation with its associated panels.

/** Renders accessible controlled or uncontrolled tab navigation with its associated panels. */
export declare const VireoTabs: React.ForwardRefExoticComponent<Omit<VireoTabsProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoTabs utility classes and theme style overrides.

/** Valid keys for VireoTabs utility classes and theme style overrides. */
export type VireoTabsClassKey = keyof VireoTabsClasses;

Utility classes available to VireoTabs.

/** Utility classes available to VireoTabs. */
export type VireoTabsClasses = Record<VireoTabsSlotName, string>;

export type VireoTabsInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "defaultValue" | "onChange">;

export type VireoTabsOwnProps = VireoTabsSlotsAndSlotProps & {
    tabs: readonly VireoTabItem[];
    value?: string;
    defaultValue?: string;
    onChange?: (value: string, event: React.SyntheticEvent) => void;
    classes?: Partial<VireoTabsClasses>;
};

export type VireoTabsOwnerState = {
    value: string;
    tabCount: number;
};

export interface VireoTabsPanelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoTabsProps = VireoTabsOwnProps & VireoTabsInheritedProps;

export interface VireoTabsRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoTabsSlots = {
    [T in VireoTabsSlotName]: React.ElementType;
};

export type VireoTabsSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoTabsSlots, {
    /** @default 'div' */ root: SlotProps<typeof Box, VireoTabsRootSlotPropsOverrides, VireoTabsOwnerState>;
    /** @default Tabs */ tabs: SlotProps<typeof Tabs, VireoTabsTabsSlotPropsOverrides, VireoTabsOwnerState>;
    /** @default Tab */ tab: SlotProps<typeof Tab, VireoTabsTabSlotPropsOverrides, VireoTabsOwnerState>;
    /** @default 'div' */ panel: SlotProps<typeof Box, VireoTabsPanelSlotPropsOverrides, VireoTabsOwnerState>;
}>;

export interface VireoTabsTabSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoTabsTabsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Owns one browser theme-color meta tag without disturbing other media-specific variants.

/** Owns one browser theme-color meta tag without disturbing other media-specific variants. */
export declare function VireoThemeColorMeta({ color, media: mediaProp }: VireoThemeColorMetaProps): null;

export type VireoThemeColorMetaProps = {
    /** Explicit browser theme color. Defaults to `theme.palette.background.paper`. */
    color?: string;
    /** Optional media query identifying a dedicated theme-color tag. */
    media?: string;
};

Direct, compiler-scalable theme contract for one Vireo component.

/** Direct, compiler-scalable theme contract for one Vireo component. */
export type VireoThemeComponent<TProps extends object, TClassKey extends string, TOwnerState extends object, TTheme = unknown> = {
    defaultProps?: Partial<TProps>;
    styleOverrides?: Partial<Record<TClassKey, Interpolation<TProps & {
        ownerState: TOwnerState;
        theme: TTheme;
    }>>>;
    variants?: Array<{
        props: Partial<TProps> | ((props: Partial<TProps> & {
            ownerState: TOwnerState;
        }) => boolean);
        style: Interpolation<{
            theme: TTheme;
        }>;
    }>;
};

export type VireoTransitionPresence<TValue> = {
    /** Whether the transition should currently render its entered state. */
    visible: boolean;
    /** The latest non-null value retained until an active exit completes. */
    renderedValue: TValue | null;
    /** Starts an exit while preserving the rendered value. */
    dismiss: () => void;
    /** Completes the active exit and clears the rendered value. */
    completeExit: () => void;
};

Collapses overflowing React content and exposes an accessible control that lets users reveal or hide it.

/** Collapses overflowing React content and exposes an accessible control that lets users reveal or hide it. */
export declare const VireoTruncatedContent: React.ForwardRefExoticComponent<Omit<VireoTruncatedContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoTruncatedContent utility classes and theme style overrides.

/** Valid keys for VireoTruncatedContent utility classes and theme style overrides. */
export type VireoTruncatedContentClassKey = keyof VireoTruncatedContentClasses;

Utility classes available to VireoTruncatedContent.

/** Utility classes available to VireoTruncatedContent. */
export type VireoTruncatedContentClasses = Record<VireoTruncatedContentSlotName, string>;

export interface VireoTruncatedContentContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoTruncatedContent inherits from its default root after excluding component-owned props.

/** Props VireoTruncatedContent inherits from its default root after excluding component-owned props. */
export type VireoTruncatedContentInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

Props owned by {@link VireoTruncatedContent }.

/** Props owned by {@link VireoTruncatedContent}. */
export type VireoTruncatedContentOwnProps = VireoTruncatedContentSlotsAndSlotProps & {
    /** Content that is collapsed only when its rendered dimensions overflow the configured height or available width. */
    children: React.ReactNode;
    /** Maximum visible height while collapsed. @default 40 */
    collapsedHeight?: number;
    /** Accessible label rendered by the toggle while content is collapsed. */
    expandLabel: React.ReactNode;
    /** Accessible label rendered by the toggle while content is expanded. */
    collapseLabel: React.ReactNode;
    /** Initial expansion state when expansion is uncontrolled. @default false */
    defaultExpanded?: boolean;
    /** Controlled expansion state. */
    expanded?: boolean;
    /** Called when the user requests a change to the expansion state. */
    onExpandedChange?: (expanded: boolean) => void;
    /** Stops toggle click propagation, useful inside clickable rows. @default false */
    stopPropagation?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoTruncatedContentClasses>;
};

export type VireoTruncatedContentOwnerState = {
    collapsedHeight: number;
    expanded: boolean;
    canExpand: boolean;
};

Props accepted by {@link VireoTruncatedContent }.

/** Props accepted by {@link VireoTruncatedContent}. */
export type VireoTruncatedContentProps = VireoTruncatedContentOwnProps & VireoTruncatedContentInheritedProps;

export interface VireoTruncatedContentRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoTruncatedContent }.

/** Replaceable semantic regions exposed by {@link VireoTruncatedContent}. */
export type VireoTruncatedContentSlots = {
    [TSlotName in VireoTruncatedContentSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoTruncatedContent }.

/** Slot props exposed by {@link VireoTruncatedContent}. */
export type VireoTruncatedContentSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoTruncatedContentSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoTruncatedContentRootSlotPropsOverrides, VireoTruncatedContentOwnerState>;
    /** @default 'div' */
    viewport: SlotProps<"div", VireoTruncatedContentViewportSlotPropsOverrides, VireoTruncatedContentOwnerState>;
    /** @default 'div' */
    content: SlotProps<"div", VireoTruncatedContentContentSlotPropsOverrides, VireoTruncatedContentOwnerState>;
    /** @default Button */
    toggle: SlotProps<typeof Button, VireoTruncatedContentToggleSlotPropsOverrides, VireoTruncatedContentOwnerState>;
}>;

export interface VireoTruncatedContentToggleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoTruncatedContentViewportSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export declare function areNumbersEqual(a: number, b: number, tolerance?: number): boolean;

export declare function assertUnreachable(_: never): never;

export declare function clampCanvasScale(scale: number, minScale: number, maxScale: number): number;

export declare function clampSidePanelWidth(width: number, minWidth: number, maxWidth: number): number;

/**
 * @see {@link https://mui.com/system/getting-started/the-sx-prop/#passing-the-sx-prop Passing the sx prop docs}
 */
export declare function composeSx(sx?: SxProps<Theme>, defaultSx?: SxProps<Theme>): SxProps<Theme>;

export declare function createCurrencyFormatter(locale: string, currency?: string): Intl.NumberFormat;

/**
 * @deprecated Prefer `createVireoTheme({ mode: "dark" })` so both schemes share one source of truth.
 * Derives a dark theme while preserving the source theme's non-color foundations and brand palette channels.
 */
export declare function createDarkTheme(lightTheme: Theme, overrides?: ThemeOptions): Theme;

export declare function createMonthFormatter(locale: string): Intl.DateTimeFormat;

export declare function createMonthYearFormatter(locale: string): Intl.DateTimeFormat;

export declare function createUnsavedChangesRegistry(): UnsavedChangesRegistry;

export declare function createVireoPageLayout(mode: VireoPageLayoutMode): VireoPageLayout;

export declare function filterOptionsNoop<T>(item: T): T;

export declare function formatCompactCurrency(value: number, currencyCode?: string): string;

export declare function formatDate(timestamp: number | null, config?: DateFormatConfig): string;

Formats an uppercase English month name (e.g. `"JANUARY"`) into a localized full month name via `dayjs`. Returns `"-"` for `null`, and the original string when the value is not a recognized month.

/**
 * Formats an uppercase English month name (e.g. `"JANUARY"`) into a localized
 * full month name via `dayjs`. Returns `"-"` for `null`, and the original
 * string when the value is not a recognized month.
 */
export declare function formatMonth(month: string | null): string;

export declare function formatPrimitive(value: string | number | boolean | null | undefined): string;

export declare function getCompassDirectionFromDegrees(deg: number): string;

Resolves a localized display name for a supported country-flag-icons identifier.

/** Resolves a localized display name for a supported country-flag-icons identifier. */
export declare function getCountryName(countryCode: CountryCode, locale: string, options?: CountryNameOptions): string;

export declare function getDefaultDesktopSidePanelWidth(maxWidth: DialogProps["maxWidth"]): number;

Calculates the difference in milliseconds between now and the provided start time.

/**
 * Calculates the difference in milliseconds between now and the provided start time.
 * @param start - The start time as a Date object or a timestamp (number).
 * @returns The number of milliseconds elapsed since the start time.
 */
export declare function getElapsedMilliseconds(start: number): number;

export declare function getNumericDesktopSidePanelWidth(width: ResponsiveOverlayFrameDesktopSidePanelWidth, maxWidth: DialogProps["maxWidth"]): number;

export declare function getTimestamp(date: dayjs.Dayjs | null | undefined): number | null;

export declare function getUnsavedChangesStatus(registrations: ReadonlyMap<string, UnsavedChangesRegistration>, scopeId: UnsavedChangesScopeId): UnsavedChangesStatus;

Returns the generated utility class name for a VireoActionPreviewButton slot or state.

/** Returns the generated utility class name for a VireoActionPreviewButton slot or state. */
export declare function getVireoActionPreviewButtonUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoApplicationNavigationItem slot or state.

/** Returns the generated utility class name for a VireoApplicationNavigationItem slot or state. */
export declare function getVireoApplicationNavigationItemUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoApplicationNavigation slot or state.

/** Returns the generated utility class name for a VireoApplicationNavigation slot or state. */
export declare function getVireoApplicationNavigationUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoBottomDrawer slot or state.

/** Returns the generated utility class name for a VireoBottomDrawer slot or state. */
export declare function getVireoBottomDrawerUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoConfirmationDialog slot or state.

/** Returns the generated utility class name for a VireoConfirmationDialog slot or state. */
export declare function getVireoConfirmationDialogUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoCountryFlag slot or state.

/** Returns the generated utility class name for a VireoCountryFlag slot or state. */
export declare function getVireoCountryFlagUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoDelayedRender slot or state.

/** Returns the generated utility class name for a VireoDelayedRender slot or state. */
export declare function getVireoDelayedRenderUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoDockedSidePanel slot or state.

/** Returns the generated utility class name for a VireoDockedSidePanel slot or state. */
export declare function getVireoDockedSidePanelUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormActions slot or state.

/** Returns the generated utility class name for a VireoFormActions slot or state. */
export declare function getVireoFormActionsUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSectionItem slot or state.

/** Returns the generated utility class name for a VireoFormSectionItem slot or state. */
export declare function getVireoFormSectionItemUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSection slot or state.

/** Returns the generated utility class name for a VireoFormSection slot or state. */
export declare function getVireoFormSectionUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoHistoryEntry slot or state.

/** Returns the generated utility class name for a VireoHistoryEntry slot or state. */
export declare function getVireoHistoryEntryUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoIconContainer slot or state.

/** Returns the generated utility class name for a VireoIconContainer slot or state. */
export declare function getVireoIconContainerUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoIcon slot or state.

/** Returns the generated utility class name for a VireoIcon slot or state. */
export declare function getVireoIconUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoInfiniteCanvasBody slot or state.

/** Returns the generated utility class name for a VireoInfiniteCanvasBody slot or state. */
export declare function getVireoInfiniteCanvasBodyUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoInfiniteCanvasOverlay slot or state.

/** Returns the generated utility class name for a VireoInfiniteCanvasOverlay slot or state. */
export declare function getVireoInfiniteCanvasOverlayUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoInfiniteCanvas slot or state.

/** Returns the generated utility class name for a VireoInfiniteCanvas slot or state. */
export declare function getVireoInfiniteCanvasUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoInitializationBoundary slot or state.

/** Returns the generated utility class name for a VireoInitializationBoundary slot or state. */
export declare function getVireoInitializationBoundaryUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoJsonViewer slot or state.

/** Returns the generated utility class name for a VireoJsonViewer slot or state. */
export declare function getVireoJsonViewerUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoLabelBox slot or state.

/** Returns the generated utility class name for a VireoLabelBox slot or state. */
export declare function getVireoLabelBoxUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoLabeledIconButton slot or state.

/** Returns the generated utility class name for a VireoLabeledIconButton slot or state. */
export declare function getVireoLabeledIconButtonUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoLoadingRegion slot or state.

/** Returns the generated utility class name for a VireoLoadingRegion slot or state. */
export declare function getVireoLoadingRegionUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoMobileBottomNavigation slot or state.

/** Returns the generated utility class name for a VireoMobileBottomNavigation slot or state. */
export declare function getVireoMobileBottomNavigationUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoOverlayHeader slot or state.

/** Returns the generated utility class name for a VireoOverlayHeader slot or state. */
export declare function getVireoOverlayHeaderUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoPageBody slot or state.

/** Returns the generated utility class name for a VireoPageBody slot or state. */
export declare function getVireoPageBodyUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoPageHeader slot or state.

/** Returns the generated utility class name for a VireoPageHeader slot or state. */
export declare function getVireoPageHeaderUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoPage slot or state.

/** Returns the generated utility class name for a VireoPage slot or state. */
export declare function getVireoPageUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoPreferencePanel slot or state.

/** Returns the generated utility class name for a VireoPreferencePanel slot or state. */
export declare function getVireoPreferencePanelUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoResponsiveCard slot or state.

/** Returns the generated utility class name for a VireoResponsiveCard slot or state. */
export declare function getVireoResponsiveCardUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoResponsiveFormOverlay slot or state.

/** Returns the generated utility class name for a VireoResponsiveFormOverlay slot or state. */
export declare function getVireoResponsiveFormOverlayUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoResponsiveOverlayFrame slot or state.

/** Returns the generated utility class name for a VireoResponsiveOverlayFrame slot or state. */
export declare function getVireoResponsiveOverlayFrameUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoResponsiveTable slot or state.

/** Returns the generated utility class name for a VireoResponsiveTable slot or state. */
export declare function getVireoResponsiveTableUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoSidePanelResizeHandle slot or state.

/** Returns the generated utility class name for a VireoSidePanelResizeHandle slot or state. */
export declare function getVireoSidePanelResizeHandleUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoSkeleton slot or state.

/** Returns the generated utility class name for a VireoSkeleton slot or state. */
export declare function getVireoSkeletonUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoSlidingScreenStack slot or state.

/** Returns the generated utility class name for a VireoSlidingScreenStack slot or state. */
export declare function getVireoSlidingScreenStackUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoStatusDot slot or state.

/** Returns the generated utility class name for a VireoStatusDot slot or state. */
export declare function getVireoStatusDotUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoStopwatch slot or state.

/** Returns the generated utility class name for a VireoStopwatch slot or state. */
export declare function getVireoStopwatchUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoTabs slot or state.

/** Returns the generated utility class name for a VireoTabs slot or state. */
export declare function getVireoTabsUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoTruncatedContent slot or state.

/** Returns the generated utility class name for a VireoTruncatedContent slot or state. */
export declare function getVireoTruncatedContentUtilityClass(slot: string): string;

Returns whether a value is a country-flag-icons registry identifier.

/** Returns whether a value is a country-flag-icons registry identifier. */
export declare function isCountryCode(value: unknown): value is CountryCode;

export declare function isUnsavedChangesRegistrationInScope(registration: UnsavedChangesRegistration, scopeId: UnsavedChangesScopeId): boolean;

Joins optional class names, omitting empty values.

/** Joins optional class names, omitting empty values. */
export declare function joinClassNames(...values: Array<string | undefined>): string | undefined;

Combines optional MUI `sx` values in precedence order.

/** Combines optional MUI `sx` values in precedence order. */
export declare function mergeSx(first?: SxProps<Theme>, second?: SxProps<Theme>): SxProps<Theme> | undefined;

export declare function normalizeCanvasTransform(transform: VireoCanvasTransform, minScale: number, maxScale: number): VireoCanvasTransform;

export declare function omitKeys<T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

export declare function rangesOverlap(range1: [
    number,
    number
], range2: [
    number,
    number
]): boolean;

Resolves docked side panel width.

/** Resolves docked side panel width. */
export declare function resolveDockedSidePanelWidth(requestedWidth: ResponsiveOverlayFrameDesktopSidePanelWidth, maxWidth: number, minWidth: number): ResponsiveOverlayFrameDesktopSidePanelWidth;

Resolves optional static or owner-state callback props into a partial prop object.

/** Resolves optional static or owner-state callback props into a partial prop object. */
export declare function resolveSlotProps<TOwnerState, TSlotProps extends object>(slotProps: TSlotProps | ((ownerState: TOwnerState) => TSlotProps) | undefined, ownerState: TOwnerState): Partial<TSlotProps>;

Resolves a stable container mode with hysteresis around compact and wide boundaries.

/** Resolves a stable container mode with hysteresis around compact and wide boundaries. */
export declare function resolveVireoPageLayoutMode(width: number, previousMode?: VireoPageLayoutMode): VireoPageLayoutMode;

Reverses the numeric entries of an arbitrary shade scale without changing named entries.

/** Reverses the numeric entries of an arbitrary shade scale without changing named entries. */
export declare function reverseNumericScale<T extends Record<string, unknown>>(scale: T): Partial<T>;

export declare function roundToDecimals(value: number | null, decimals?: number): number | null;

export declare function svg(strings: TemplateStringsArray, ...values: string[]): string;

export declare const trimText: (text: string, length: number) => string;

export declare function useDelayedOverlayMount(): UseDelayedOverlayMountReturn;

export declare function useGuardedOverlayModeSwitch<TPayloadByMode extends Record<string, unknown>>(overlayOpen: boolean, openMode: (mode: keyof TPayloadByMode, payload: TPayloadByMode[keyof TPayloadByMode]) => void): GuardedOverlayModeSwitch<TPayloadByMode>;

Resolves page layout from an element container after mount. Uncontrolled rendering starts in `regular` mode on both the server and the hydrating client, then synchronizes to the measured container before paint.

/**
 * Resolves page layout from an element container after mount.
 *
 * Uncontrolled rendering starts in `regular` mode on both the server and the
 * hydrating client, then synchronizes to the measured container before paint.
 */
export declare function useMeasuredVireoPageLayout<E extends HTMLElement = HTMLDivElement>({ mode, forceCompact, measureParent, paused, reservedInlineSize, }?: UseMeasuredVireoPageLayoutOptions): {
    ref: React.RefObject<E | null>;
    mode: VireoPageLayoutMode;
};

export declare function usePageOverlayController(): PageOverlayControllerValue;

export declare function usePageOverlayModes<TMap extends OverlayPayloadMap>(renderers: OverlayRenderers<TMap>): UsePageOverlayModesReturn<TMap>;

Tracks viewport width at most once per animation frame while enabled.

/** Tracks viewport width at most once per animation frame while enabled. */
export declare function useRafViewportWidth(enabled: boolean): number;

export declare function useSidePanelResize({ enabled, initialWidth, minWidth, maxWidth, }: {
    enabled: boolean;
    initialWidth: number;
    minWidth: number;
    maxWidth: number;
}): {
    isResizing: boolean;
    onResizeDoubleClick: (event: React.MouseEvent<HTMLDivElement>) => void;
    onResizeKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
    onResizeStart: (event: React.MouseEvent<HTMLDivElement>) => void;
    rootRef: (element: HTMLDivElement | null) => void;
    width: number;
};

export declare function useUnsavedChanges(): UnsavedChangesContextValue;

export declare function useUnsavedChangesRegistration({ busy, dirty, enabled, scopeId: explicitScopeId, }: UseUnsavedChangesRegistrationProps): void;

export declare function useUnsavedChangesRequestDiscard(onDiscard: () => void | Promise<void>, { disabled, scopeId: requestedScopeId }?: UseUnsavedChangesRequestDiscardOptions): () => void;

export declare function useUnsavedChangesScopeId(): string | undefined;

Opens the nearest shared confirmation dialog and resolves the user's decision.

/** Opens the nearest shared confirmation dialog and resolves the user's decision. */
export declare function useVireoConfirmation(): import("../../../../../capabilities/overlays/confirmation/contexts/VireoConfirmationContext/VireoConfirmationContext.js").VireoConfirm;

Creates a trailing debounced callback with explicit cancellation and flushing controls.

/**
 * Creates a trailing debounced callback with explicit cancellation and flushing controls.
 */
export declare function useVireoDebouncedCallback<TArgs extends unknown[], TResult>(callback: (...args: TArgs) => TResult, { delayMs }: UseVireoDebouncedCallbackOptions): VireoDebouncedCallback<TArgs, TResult>;

Observes and controls the standard Fullscreen API for one target element.

/**
 * Observes and controls the standard Fullscreen API for one target element.
 */
export declare function useVireoFullscreen(target: Element | null): VireoFullscreen;

Returns the icon components registered by VireoIconRegistryProvider.

/** Returns the icon components registered by VireoIconRegistryProvider. */
export declare function useVireoIcons(): import("../../../core/providers/VireoIconRegistryProvider/VireoIconRegistryProvider.js").VireoIconRegistryContextValue;

Accesses transform state and coordinate/fullscreen actions for the nearest VireoInfiniteCanvas.

/** Accesses transform state and coordinate/fullscreen actions for the nearest VireoInfiniteCanvas. */
export declare function useVireoInfiniteCanvas(): import("../../../../capabilities/infinite-canvas/contexts/VireoInfiniteCanvasContext/VireoInfiniteCanvasContext.js").VireoInfiniteCanvasContextValue;

Subscribes a React owner to the browser's online/offline status. The browser signal is a connectivity hint, not proof that an application endpoint is reachable. Use Infrastructure's connectivity state when a heartbeat-backed health decision is required.

/**
 * Subscribes a React owner to the browser's online/offline status.
 *
 * The browser signal is a connectivity hint, not proof that an application
 * endpoint is reachable. Use Infrastructure's connectivity state when a
 * heartbeat-backed health decision is required.
 */
export declare function useVireoOnlineStatus(): boolean;

Returns the nearest container-aware page mode, with a viewport fallback outside VireoPage.

/** Returns the nearest container-aware page mode, with a viewport fallback outside VireoPage. */
export declare function useVireoPageLayout(): VireoPageLayout;

export declare function useVireoSearchParamState(key: string, options: VireoStringSearchParamStateOptions): VireoSearchParamStateResult<string>;
export declare function useVireoSearchParamState<T>(key: string, options: VireoNullableSearchParamStateOptions<T>): VireoSearchParamStateResult<T | null>;
export declare function useVireoSearchParamState<T extends NonNullable<unknown>>(key: string, options: VireoSearchParamStateOptions<T>): VireoSearchParamStateResult<T>;

Retains a non-null value while an external transition finishes its exit.

/**
 * Retains a non-null value while an external transition finishes its exit.
 */
export declare function useVireoTransitionPresence<TValue>(value: TValue | null, { onExited }?: UseVireoTransitionPresenceOptions): VireoTransitionPresence<TValue>;

Generated utility class names keyed by each public VireoActionPreviewButton class key.

/** Generated utility class names keyed by each public VireoActionPreviewButton class key. */
export declare const vireoActionPreviewButtonClasses: VireoActionPreviewButtonClasses;

Generated utility class names keyed by each public VireoApplicationNavigation class key.

/** Generated utility class names keyed by each public VireoApplicationNavigation class key. */
export declare const vireoApplicationNavigationClasses: VireoApplicationNavigationClasses;

Generated utility class names keyed by each public VireoApplicationNavigationItem class key.

/** Generated utility class names keyed by each public VireoApplicationNavigationItem class key. */
export declare const vireoApplicationNavigationItemClasses: VireoApplicationNavigationItemClasses;

Generated utility class names keyed by each public VireoBottomDrawer class key.

/** Generated utility class names keyed by each public VireoBottomDrawer class key. */
export declare const vireoBottomDrawerClasses: VireoBottomDrawerClasses;

Generated utility class names keyed by each public VireoConfirmationDialog class key.

/** Generated utility class names keyed by each public VireoConfirmationDialog class key. */
export declare const vireoConfirmationDialogClasses: VireoConfirmationDialogClasses;

Generated utility class names keyed by each public VireoCountryFlag class key.

/** Generated utility class names keyed by each public VireoCountryFlag class key. */
export declare const vireoCountryFlagClasses: VireoCountryFlagClasses;

Generated utility class names keyed by each public VireoDelayedRender class key.

/** Generated utility class names keyed by each public VireoDelayedRender class key. */
export declare const vireoDelayedRenderClasses: VireoDelayedRenderClasses;

Generated utility class names keyed by each public VireoDockedSidePanel class key.

/** Generated utility class names keyed by each public VireoDockedSidePanel class key. */
export declare const vireoDockedSidePanelClasses: VireoDockedSidePanelClasses;

Generated utility class names keyed by each public VireoFormActions class key.

/** Generated utility class names keyed by each public VireoFormActions class key. */
export declare const vireoFormActionsClasses: VireoFormActionsClasses;

Generated utility class names keyed by each public VireoFormSection class key.

/** Generated utility class names keyed by each public VireoFormSection class key. */
export declare const vireoFormSectionClasses: VireoFormSectionClasses;

Generated utility class names keyed by each public VireoFormSectionItem class key.

/** Generated utility class names keyed by each public VireoFormSectionItem class key. */
export declare const vireoFormSectionItemClasses: VireoFormSectionItemClasses;

Generated utility class names keyed by each public VireoHistoryEntry class key.

/** Generated utility class names keyed by each public VireoHistoryEntry class key. */
export declare const vireoHistoryEntryClasses: VireoHistoryEntryClasses;

Generated utility class names keyed by each public VireoIcon class key.

/** Generated utility class names keyed by each public VireoIcon class key. */
export declare const vireoIconClasses: VireoIconClasses;

Generated utility class names keyed by each public VireoIconContainer class key.

/** Generated utility class names keyed by each public VireoIconContainer class key. */
export declare const vireoIconContainerClasses: VireoIconContainerClasses;

Generated utility class names keyed by each public VireoInfiniteCanvasBody class key.

/** Generated utility class names keyed by each public VireoInfiniteCanvasBody class key. */
export declare const vireoInfiniteCanvasBodyClasses: VireoInfiniteCanvasBodyClasses;

Generated utility class names keyed by each public VireoInfiniteCanvas class key.

/** Generated utility class names keyed by each public VireoInfiniteCanvas class key. */
export declare const vireoInfiniteCanvasClasses: VireoInfiniteCanvasClasses;

Generated utility class names keyed by each public VireoInfiniteCanvasOverlay class key.

/** Generated utility class names keyed by each public VireoInfiniteCanvasOverlay class key. */
export declare const vireoInfiniteCanvasOverlayClasses: VireoInfiniteCanvasOverlayClasses;

Generated utility class names keyed by each public VireoInitializationBoundary class key.

/** Generated utility class names keyed by each public VireoInitializationBoundary class key. */
export declare const vireoInitializationBoundaryClasses: VireoInitializationBoundaryClasses;

Generated utility class names keyed by each public VireoJsonViewer class key.

/** Generated utility class names keyed by each public VireoJsonViewer class key. */
export declare const vireoJsonViewerClasses: VireoJsonViewerClasses;

Generated utility class names keyed by each public VireoLabelBox class key.

/** Generated utility class names keyed by each public VireoLabelBox class key. */
export declare const vireoLabelBoxClasses: VireoLabelBoxClasses;

Generated utility class names keyed by each public VireoLabeledIconButton class key.

/** Generated utility class names keyed by each public VireoLabeledIconButton class key. */
export declare const vireoLabeledIconButtonClasses: VireoLabeledIconButtonClasses;

Generated utility class names keyed by each public VireoLoadingRegion class key.

/** Generated utility class names keyed by each public VireoLoadingRegion class key. */
export declare const vireoLoadingRegionClasses: VireoLoadingRegionClasses;

Generated utility class names keyed by each public VireoMobileBottomNavigation class key.

/** Generated utility class names keyed by each public VireoMobileBottomNavigation class key. */
export declare const vireoMobileBottomNavigationClasses: VireoMobileBottomNavigationClasses;

Generated utility class names keyed by each public VireoOverlayHeader class key.

/** Generated utility class names keyed by each public VireoOverlayHeader class key. */
export declare const vireoOverlayHeaderClasses: VireoOverlayHeaderClasses;

Generated utility class names keyed by each public VireoPageBody class key.

/** Generated utility class names keyed by each public VireoPageBody class key. */
export declare const vireoPageBodyClasses: VireoPageBodyClasses;

Generated utility class names keyed by each public VireoPage class key.

/** Generated utility class names keyed by each public VireoPage class key. */
export declare const vireoPageClasses: VireoPageClasses;

Generated utility class names keyed by each public VireoPageHeader class key.

/** Generated utility class names keyed by each public VireoPageHeader class key. */
export declare const vireoPageHeaderClasses: VireoPageHeaderClasses;

Generated utility class names keyed by each public VireoPreferencePanel class key.

/** Generated utility class names keyed by each public VireoPreferencePanel class key. */
export declare const vireoPreferencePanelClasses: VireoPreferencePanelClasses;

Generated utility class names keyed by each public VireoResponsiveCard class key.

/** Generated utility class names keyed by each public VireoResponsiveCard class key. */
export declare const vireoResponsiveCardClasses: VireoResponsiveCardClasses;

Generated utility class names keyed by each public VireoResponsiveFormOverlay class key.

/** Generated utility class names keyed by each public VireoResponsiveFormOverlay class key. */
export declare const vireoResponsiveFormOverlayClasses: VireoResponsiveFormOverlayClasses;

Generated utility class names keyed by each public VireoResponsiveOverlayFrame class key.

/** Generated utility class names keyed by each public VireoResponsiveOverlayFrame class key. */
export declare const vireoResponsiveOverlayFrameClasses: VireoResponsiveOverlayFrameClasses;

Generated utility class names keyed by each public VireoResponsiveTable class key.

/** Generated utility class names keyed by each public VireoResponsiveTable class key. */
export declare const vireoResponsiveTableClasses: VireoResponsiveTableClasses;

export declare const vireoSearchParamCodecs: Readonly<{
    string: VireoSearchParamCodec<string>;
    number: VireoSearchParamCodec<number>;
    boolean: VireoSearchParamCodec<boolean>;
}>;

Generated utility class names keyed by each public VireoSidePanelResizeHandle class key.

/** Generated utility class names keyed by each public VireoSidePanelResizeHandle class key. */
export declare const vireoSidePanelResizeHandleClasses: VireoSidePanelResizeHandleClasses;

Generated utility class names keyed by each public VireoSkeleton class key.

/** Generated utility class names keyed by each public VireoSkeleton class key. */
export declare const vireoSkeletonClasses: VireoSkeletonClasses;

Generated utility class names keyed by each public VireoSlidingScreenStack class key.

/** Generated utility class names keyed by each public VireoSlidingScreenStack class key. */
export declare const vireoSlidingScreenStackClasses: VireoSlidingScreenStackClasses;

Generated utility class names keyed by each public VireoStatusDot class key.

/** Generated utility class names keyed by each public VireoStatusDot class key. */
export declare const vireoStatusDotClasses: VireoStatusDotClasses;

Generated utility class names keyed by each public VireoStopwatch class key.

/** Generated utility class names keyed by each public VireoStopwatch class key. */
export declare const vireoStopwatchClasses: VireoStopwatchClasses;

Generated utility class names keyed by each public VireoTabs class key.

/** Generated utility class names keyed by each public VireoTabs class key. */
export declare const vireoTabsClasses: VireoTabsClasses;

Generated utility class names keyed by each public VireoTruncatedContent class key.

/** Generated utility class names keyed by each public VireoTruncatedContent class key. */
export declare const vireoTruncatedContentClasses: VireoTruncatedContentClasses;

export declare function zoomCanvasAtPoint(transform: VireoCanvasTransform, scale: number, point: VireoCanvasPoint): VireoCanvasTransform;