@almadar/ui 5.79.1 → 5.79.2

package/dist/components/core/molecules/ActivationBlock.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ActivationBlock Molecule Component
+ *
+ * Pre-lesson activation prompt. Invites learners to surface prior knowledge
+ * before content begins. Emits `UI:SAVE_ACTIVATION { response }`.
+ *
+ * Event Contract:
+ * - Emits: UI:SAVE_ACTIVATION { response }
+ * - entityAware: false
+ */
+import React from 'react';
+export interface ActivationBlockProps {
+    /** The prior-knowledge question */
+    question: string;
+    /** Pre-filled response from saved state */
+    savedResponse?: string;
+    /** Event name emitted on save/skip (as `UI:<saveEvent>`). Defaults to 'SAVE_ACTIVATION'. */
+    saveEvent?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare const ActivationBlock: React.FC<ActivationBlockProps>;

package/dist/components/core/molecules/Alert.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Alert Molecule Component
+ *
+ * A component for displaying alert messages with different variants and actions.
+ * Uses theme-aware CSS variables for styling.
+ */
+import React from "react";
+import type { EventKey } from "@almadar/core";
+export type AlertVariant = "info" | "success" | "warning" | "error";
+export interface AlertProps {
+    /** Alert content (children or message) */
+    children?: React.ReactNode;
+    /** Alert message (alias for children) */
+    message?: string;
+    variant?: AlertVariant;
+    title?: string;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    onClose?: () => void;
+    actions?: React.ReactNode;
+    className?: string;
+    /** Declarative dismiss event — emits UI:{dismissEvent} via eventBus when alert is dismissed */
+    dismissEvent?: EventKey;
+}
+export declare const Alert: React.FC<AlertProps>;

package/dist/components/core/molecules/AnimatedCounter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * AnimatedCounter Molecule Component
+ *
+ * Counts from 0 to a target value on scroll-into-view using IntersectionObserver.
+ * Replaces static stat numbers with animated versions for visual impact.
+ */
+import React from 'react';
+export interface AnimatedCounterProps {
+    /** Target value to count to. Strings allow display formats (e.g. "500+", "99.9%", "3x"); numbers are coerced. */
+    value: string | number;
+    /** Label displayed below the number */
+    label: string;
+    /** Animation duration in ms */
+    duration?: number;
+    /** Additional class names */
+    className?: string;
+}
+export declare const AnimatedCounter: React.FC<AnimatedCounterProps>;

package/dist/components/core/molecules/AssetPicker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AssetPicker Molecule Component
+ *
+ * Catalog-driven asset chooser built on the GridPicker base. Maps an
+ * AssetCatalog into picker cells and renders a kind-aware thumbnail: an
+ * <img> for visual kinds, an Icon affordance for audio/model/other. Pure
+ * presentational — the host supplies the catalog and owns the selected url.
+ */
+import React from 'react';
+import type { AssetCatalog } from '@almadar/core';
+export interface AssetPickerProps {
+    /** Browsable asset catalog supplied by the host. */
+    assets: AssetCatalog;
+    /** Currently selected asset url (controlled highlight). */
+    value?: string;
+    /** Fired with the chosen asset's url. */
+    onChange: (url: string) => void;
+    /** Additional CSS classes applied to the root. */
+    className?: string;
+}
+export declare const AssetPicker: React.FC<AssetPickerProps>;

package/dist/components/core/molecules/BloomQuizBlock.d.ts

@@ -0,0 +1,25 @@
+/**
+ * BloomQuizBlock Molecule Component
+ *
+ * Practice Q&A with Bloom's Taxonomy level badge. Emits `UI:ANSWER_BLOOM { index, level }`.
+ *
+ * Event Contract:
+ * - Emits: UI:ANSWER_BLOOM { index, level }
+ * - entityAware: false
+ */
+import React from 'react';
+export type BloomLevel = 'remember' | 'understand' | 'apply' | 'analyze' | 'evaluate' | 'create';
+export interface BloomQuizBlockProps {
+    level: BloomLevel;
+    question: string;
+    answer: string;
+    /** Zero-based index (used in the emitted event payload) */
+    index?: number;
+    /** Whether the learner has already answered */
+    isAnswered?: boolean;
+    /** Event name emitted on first reveal (as `UI:<answerEvent>`). Defaults to 'ANSWER_BLOOM'. */
+    answerEvent?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare const BloomQuizBlock: React.FC<BloomQuizBlockProps>;

package/dist/components/core/molecules/BranchingLogicBuilder.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { EventEmit, EventPayload, EventPayloadValue } from '@almadar/core';
+export interface BranchingQuestion {
+    id: string;
+    label: string;
+    optionValues?: string[];
+}
+export type BranchingOperator = 'equals' | 'not-equals' | 'contains' | 'in';
+export declare const END_OF_SURVEY = "end-of-survey";
+export interface BranchingRule extends EventPayload {
+    id: string;
+    sourceQuestionId: string;
+    operator: BranchingOperator;
+    value: string | string[];
+    targetQuestionId: string | typeof END_OF_SURVEY;
+}
+export interface BranchingLogicBuilderProps {
+    questions: readonly BranchingQuestion[] | EventPayloadValue;
+    /**
+     * Rules. Accepts either a typed array (direct consumers) or the runtime
+     * payload shape from a render-ui binding (`@payload.data`). Narrowed to
+     * `[]` internally when the value isn't an array.
+     */
+    rules: readonly BranchingRule[] | EventPayloadValue;
+    onRulesChange?: (rules: BranchingRule[]) => void;
+    /** Event name dispatched via event bus when rules change. Payload: `{ rules }`. */
+    rulesChangeEvent?: EventEmit<{
+        rules: BranchingRule[];
+    }>;
+    readOnly?: boolean;
+    className?: string;
+}
+export declare const BranchingLogicBuilder: React.FC<BranchingLogicBuilderProps>;

package/dist/components/core/molecules/Breadcrumb.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Breadcrumb Molecule Component
+ *
+ * A breadcrumb navigation component with separators and icons.
+ * Uses Button, Icon, and Typography atoms.
+ */
+import React from "react";
+import type { IconInput } from "../atoms/index";
+export interface BreadcrumbItem {
+    /**
+     * Item label
+     */
+    label: string;
+    /**
+     * Item href (if provided, renders as link)
+     */
+    href?: string;
+    /**
+     * Item path (alias for href, for schema compatibility)
+     */
+    path?: string;
+    /**
+     * Item icon (canonical kebab-case name or LucideIcon component)
+     */
+    icon?: IconInput;
+    /**
+     * Click handler (if href not provided)
+     */
+    onClick?: () => void;
+    /**
+     * Is current page
+     */
+    isCurrent?: boolean;
+    /** Event name to emit when clicked (for trait state machine integration) */
+    event?: string;
+}
+export interface BreadcrumbProps {
+    /**
+     * Breadcrumb items
+     */
+    items: BreadcrumbItem[];
+    /**
+     * Separator icon (canonical kebab-case name or LucideIcon component)
+     */
+    separator?: IconInput;
+    /**
+     * Maximum items to show (truncates with ellipsis)
+     */
+    maxItems?: number;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+export declare const Breadcrumb: React.FC<BreadcrumbProps>;

package/dist/components/core/molecules/ButtonGroup.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ButtonGroup Molecule Component
+ *
+ * A component for grouping buttons together with connected styling.
+ * Supports both children-based and form-actions pattern (primary/secondary) usage.
+ * Uses Button atoms.
+ */
+import React from 'react';
+export type ButtonGroupVariant = 'default' | 'segmented' | 'toggle';
+/**
+ * Layer 2 visual treatment for the action-cluster (form-actions) pattern —
+ * orthogonal to the semantic `variant` (which conveys grouping shape).
+ */
+export type ActionClusterLook = 'right-aligned-buttons' | 'floating-bar' | 'inline-row' | 'dropdown-menu' | 'command-palette-trigger';
+/** Action button config for form-actions pattern */
+export interface ActionButton {
+    label: string;
+    /** Action type - 'submit' renders as submit button, others render as button */
+    actionType?: string;
+    event?: string;
+    navigatesTo?: string;
+    /** Button variant - matches Button component variants. Accepts string for schema compatibility. */
+    variant?: string;
+}
+/** Filter definition for filter-group pattern */
+export interface FilterDefinition {
+    field: string;
+    label: string;
+    /** Filter type (checkbox, select, etc.) */
+    type?: 'checkbox' | 'select' | 'toggle';
+    /** Options for select filters */
+    options?: readonly string[];
+}
+export interface ButtonGroupProps {
+    /**
+     * Button group content (Button components) - use this OR primary/secondary
+     */
+    children?: React.ReactNode;
+    /**
+     * Primary action button config (for form-actions pattern)
+     * Accepts Readonly for compatibility with generated const objects
+     */
+    primary?: Readonly<ActionButton>;
+    /**
+     * Secondary action buttons config (for form-actions pattern)
+     * Accepts readonly array for compatibility with generated const arrays
+     */
+    secondary?: readonly Readonly<ActionButton>[];
+    /**
+     * Visual variant
+     * @default 'default'
+     */
+    variant?: ButtonGroupVariant;
+    /**
+     * Orientation
+     * @default 'horizontal'
+     */
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+    /**
+     * Entity type for filter-group pattern (schema metadata)
+     */
+    entity?: string;
+    /**
+     * Filter definitions for filter-group pattern
+     */
+    filters?: readonly FilterDefinition[];
+    /**
+     * Layer 2 visual treatment for the action-cluster (form-actions) pattern.
+     * @default 'right-aligned-buttons'
+     */
+    look?: ActionClusterLook;
+}
+export declare const ButtonGroup: React.FC<ButtonGroupProps>;

package/dist/components/core/molecules/CalendarGrid.d.ts

@@ -0,0 +1,61 @@
+/**
+ * CalendarGrid
+ *
+ * Pure presentational weekly calendar grid molecule.
+ * No entity binding, no event bus, no translations.
+ * Composes DayCell and TimeSlotCell atoms into a 7-day grid.
+ */
+import React from "react";
+import type { EventEmit, EventPayload, EntityRow, EntityWith } from "@almadar/core";
+/**
+ * Number of day columns rendered at once. Matches the responsiveness-
+ * audit tiers exactly: 1 day on mobile (≤640), 3 on tablet (641–1024),
+ * 7 on laptop+ (≥1025).
+ */
+export type CalendarDayWindow = 1 | 3 | 7;
+/** The per-event entity fields this grid reads. `startTime`/`endTime` are ISO
+ *  strings; `color` is a Tailwind class string applied to the event chip. */
+export interface CalendarEventRow {
+    title: string;
+    startTime: string;
+    endTime?: string;
+    color?: string;
+}
+export interface CalendarGridProps {
+    /** Start of the week (defaults to current week's Monday) */
+    weekStart?: Date;
+    /** Time slot labels (defaults to 09:00-17:00) */
+    timeSlots?: string[];
+    /** Events to display on the grid */
+    events?: readonly EntityWith<CalendarEventRow>[];
+    /** Called when a time slot is clicked */
+    onSlotClick?: (day: Date, time: string) => void;
+    /** Called when a day header is clicked */
+    onDayClick?: (day: Date) => void;
+    /** Called when an event is clicked */
+    onEventClick?: (event: EntityRow) => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** Event emitted on long-press of a time slot: UI:{longPressEvent} with { date, time, ...longPressPayload } */
+    longPressEvent?: EventEmit<{
+        date: string;
+        time?: string;
+    }>;
+    /** Additional payload for long-press events */
+    longPressPayload?: EventPayload;
+    /** Event emitted on swipe left (next week): UI:{swipeLeftEvent} */
+    swipeLeftEvent?: EventEmit<Record<string, never>>;
+    /** Event emitted on swipe right (prev week): UI:{swipeRightEvent} */
+    swipeRightEvent?: EventEmit<Record<string, never>>;
+    /**
+     * Override the viewport-driven day window. `'auto'` (default) tracks
+     * `window.innerWidth` — 1 day on mobile, 3 on tablet, 7 on laptop+.
+     * Pass an explicit number to force a fixed window (useful for print
+     * layouts or screenshot tests).
+     */
+    dayWindow?: CalendarDayWindow | 'auto';
+}
+export declare function CalendarGrid({ weekStart, timeSlots, events, onSlotClick, onDayClick, onEventClick, className, longPressEvent, longPressPayload, swipeLeftEvent, swipeRightEvent, dayWindow, }: CalendarGridProps): React.JSX.Element;
+export declare namespace CalendarGrid {
+    var displayName: string;
+}

package/dist/components/core/molecules/Card.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Card Component
+ *
+ * A generic card container for displaying content with optional title,
+ * subtitle, and action buttons.
+ *
+ * @generated by Orbital Compiler
+ */
+import React from "react";
+import type { AssetUrl, EventEmit, EventKey, EventPayload } from "@almadar/core";
+import type { IconInput } from "../atoms/index";
+export interface CardAction {
+    label: string;
+    onClick?: () => void;
+    /** Event name to emit when clicked (for trait state machine integration) */
+    event?: string;
+    variant?: "default" | "primary" | "danger";
+    icon?: IconInput;
+    disabled?: boolean;
+}
+export interface CardProps {
+    /** Card title */
+    title?: string;
+    /** Card subtitle or description */
+    subtitle?: string;
+    /** Image URL to display at top of card */
+    image?: AssetUrl;
+    /** Action buttons to display in card footer */
+    actions?: CardAction[];
+    /** Card content */
+    children?: React.ReactNode;
+    /** Click handler for the entire card */
+    onClick?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** Declarative event name — emits UI:{action} via eventBus on card click */
+    action?: EventKey;
+    /** Whether the card is selected (highlighted state) */
+    isSelected?: boolean;
+    /** Card name (alias for title) */
+    name?: string;
+    /** Level indicator */
+    level?: number;
+    /** Maximum level */
+    maxLevel?: number;
+    /** Event emitted on long press: UI:{longPressEvent} (payload: longPressPayload spread — variable) */
+    longPressEvent?: EventEmit<EventPayload>;
+    /** Additional payload for long-press events */
+    longPressPayload?: EventPayload;
+}
+/**
+ * Card component for displaying content in a contained box
+ */
+export declare function Card({ title, subtitle, image, actions, children, onClick, className, action, longPressEvent, longPressPayload, }: CardProps): React.JSX.Element;
+export declare namespace Card {
+    var displayName: string;
+}
+export default Card;

package/dist/components/core/molecules/Carousel.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Carousel Molecule Component
+ *
+ * Horizontal scrolling container with snap points, swipe gestures,
+ * prev/next arrow buttons, and dot indicators.
+ * Pure UI molecule with no entity binding.
+ */
+import React from 'react';
+import type { AssetUrl, EventEmit, JsonObject } from '@almadar/core';
+/** Default shape for carousel slide items when no generic is provided. */
+export interface CarouselItem {
+    id?: string;
+    title?: string;
+    image?: AssetUrl;
+}
+export interface CarouselProps<T = CarouselItem> {
+    /** Array of items to display as slides */
+    items: T[];
+    /** Render function for each slide */
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    /** Children-as-function fallback for renderItem (compiler compatibility) */
+    children?: (item: T, index: number) => React.ReactNode;
+    /** Enable auto-play rotation */
+    autoPlay?: boolean;
+    /** Auto-play interval in milliseconds (default: 5000) */
+    autoPlayInterval?: number;
+    /** Show dot indicators */
+    showDots?: boolean;
+    /** Show prev/next arrow buttons */
+    showArrows?: boolean;
+    /** Enable infinite loop */
+    loop?: boolean;
+    /** Declarative event name for slide change */
+    slideChangeEvent?: EventEmit<{
+        index: number;
+    }>;
+    /** Payload to include with the slide change event */
+    slideChangePayload?: JsonObject;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare const Carousel: <T = CarouselItem>({ items, renderItem, children, autoPlay, autoPlayInterval, showDots, showArrows, loop, slideChangeEvent, slideChangePayload, className, }: CarouselProps<T>) => React.ReactElement | null;

package/dist/components/core/molecules/Chart.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Chart Organism Component
+ *
+ * Data visualization. Supports bar / line / pie / area / donut / scatter /
+ * histogram chart types. Renders multi-series natively for bar / line / area
+ * via the `series` prop. Pie / donut consume the first series only. Scatter
+ * plots raw {x,y} points; histogram renders pre-binned data as gap-less bars.
+ *
+ * Bus integration:
+ *  - top-level `actions[].event` → `UI:{event}` on click (existing behavior)
+ *  - per-data-point `drillEvent` → `UI:{drillEvent}` with `{ label, value, seriesLabel? }`
+ *
+ * Time axis: when `timeAxis: true`, ISO date labels are formatted via Intl
+ * (e.g. "Mar 2026"). Positioning remains evenly spaced (real time-scale
+ * alignment is deliberately deferred).
+ */
+import React from "react";
+import type { UiError } from '../atoms/types';
+export type ChartType = "bar" | "line" | "pie" | "area" | "donut" | "scatter" | "histogram";
+/**
+ * Layer 2 visual treatment for the chart pattern — drives the chart
+ * sub-renderer (bar / line / pie / etc.). The chart "look" axis is the chart
+ * KIND, not pure visual styling. `look` is the primary surface; the legacy
+ * `chartType` prop remains as an alias.
+ *
+ * Mapping to `chartType`:
+ *  - `bar-vertical`   ↔ `bar`        (default)
+ *  - `bar-horizontal` ↔ (new)        renders bars laid out horizontally
+ *  - `line`           ↔ `line`
+ *  - `area`           ↔ `area`
+ *  - `pie`            ↔ `pie`
+ *  - `donut`          ↔ `donut`
+ *  - `scatter`        ↔ `scatter`
+ *  - `histogram`      ↔ `histogram`
+ */
+export type ChartLook = "bar-vertical" | "bar-horizontal" | "line" | "area" | "pie" | "donut" | "scatter" | "histogram";
+export type ChartStackMode = "none" | "stack" | "normalize";
+export interface ChartDataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface ChartScatterPoint {
+    x: number;
+    y: number;
+    label?: string;
+    size?: number;
+    color?: string;
+}
+export interface ChartSeries {
+    name: string;
+    data: readonly ChartDataPoint[];
+    color?: string;
+    dashed?: boolean;
+}
+export interface ChartAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+export interface ChartProps {
+    /** Chart title */
+    title?: string;
+    /** Chart subtitle / description */
+    subtitle?: string;
+    /**
+     * Chart type (legacy alias for `look`).
+     * @synonyms chart style, graph type, bar chart, line chart, pie chart, area chart, donut chart, scatter plot, histogram
+     * @tier domain
+     */
+    chartType?: ChartType;
+    /**
+     * Layer 2 visual treatment — drives the chart sub-renderer (bar / line / pie / etc.).
+     * @synonyms chart style, render style, visual treatment
+     * @tier presentation
+     */
+    look?: ChartLook;
+    /** Multi-series data */
+    series?: readonly ChartSeries[];
+    /** Simple single-series shorthand (bar/line/pie/area/donut/histogram) */
+    data?: readonly ChartDataPoint[];
+    /** Raw {x,y} points for scatter */
+    scatterData?: readonly ChartScatterPoint[];
+    /** Chart height in px */
+    height?: number;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Show values on chart */
+    showValues?: boolean;
+    /** Stack mode for bar / area */
+    stack?: ChartStackMode;
+    /** Format X-axis labels as time (ISO date in → "Mar 2026"-style label out) */
+    timeAxis?: boolean;
+    /** Event name emitted as `UI:{drillEvent}` with `{ label, value, seriesLabel? }` on data-point click */
+    drillEvent?: string;
+    /** Top-level chart actions (export, refresh, etc.) */
+    actions?: readonly ChartAction[];
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: UiError | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare const Chart: React.FC<ChartProps>;

package/dist/components/core/molecules/ChartLegend.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ChartLegend Molecule Component
+ *
+ * Color-coded legend for chart data series.
+ * Pure UI molecule with no entity binding.
+ */
+import React from 'react';
+export interface ChartLegendItem {
+    label: string;
+    color: string;
+}
+export interface ChartLegendProps {
+    /** Legend items with label and color */
+    items: ChartLegendItem[];
+    /** Additional CSS classes */
+    className?: string;
+    /** Layout direction */
+    direction?: 'horizontal' | 'vertical';
+}
+export declare const ChartLegend: React.FC<ChartLegendProps>;

package/dist/components/core/molecules/Coachmark.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Coachmark Molecule
+ *
+ * A controlled, externally-anchored popover for onboarding hints. Unlike
+ * Popover (uncontrolled, wraps its own trigger), a Coachmark is driven by
+ * `open` and points at an element it does not own — a tab button, the persona
+ * menu, a canvas node — resolved from a ref, a CSS selector, or a DOMRect.
+ * Portals to document.body so it escapes the canvas/preview transform contexts.
+ */
+import React from "react";
+export type CoachmarkPlacement = "top" | "bottom" | "left" | "right";
+export type CoachmarkAnchor = React.RefObject<HTMLElement | null> | string | DOMRect;
+export interface CoachmarkProps {
+    /** Controlled visibility. */
+    open: boolean;
+    /** The element to point at: a ref, a CSS selector, or a DOMRect. */
+    anchor: CoachmarkAnchor;
+    /** Side of the anchor to render on. @default 'bottom' */
+    placement?: CoachmarkPlacement;
+    title?: string;
+    children: React.ReactNode;
+    /** Close (X) handler — always rendered. */
+    onDismiss: () => void;
+    /** Optional filled primary action (e.g. Next / Got it). */
+    onPrimary?: () => void;
+    primaryLabel?: string;
+    /** Optional ghost secondary action (e.g. Skip). */
+    onSecondary?: () => void;
+    secondaryLabel?: string;
+    /** Render a pulsing beacon dot over the anchor (keystone hints). */
+    showBeacon?: boolean;
+    /**
+     * If the anchor can't be resolved, render the card centered in the viewport
+     * instead of hiding it. Guarantees the card (and its dismiss/skip) is always
+     * reachable — used by OnboardingSpotlight so a missing anchor never traps the
+     * user behind a dimmed backdrop. Default false: a missing anchor hides the card.
+     */
+    fallbackCentered?: boolean;
+    className?: string;
+}
+/**
+ * Tracks the live bounding rect of an anchor while `active`. Re-reads on
+ * scroll/resize, and polls a few frames so a selector that mounts just after
+ * activation (a freshly-revealed tab) still resolves.
+ */
+export declare function useAnchorRect(anchor: CoachmarkAnchor, active: boolean): DOMRect | null;
+export declare const Coachmark: React.FC<CoachmarkProps>;

package/dist/components/core/molecules/ConfirmDialog.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ConfirmDialog Component
+ *
+ * Confirmation dialog for destructive or important actions.
+ * Composes Modal molecule with Button atoms.
+ *
+ * Uses wireframe theme styling (high contrast, sharp edges).
+ */
+import React from "react";
+import { type ModalSize } from "./Modal";
+import type { UiError } from '../atoms/types';
+export type ConfirmDialogVariant = "danger" | "warning" | "info" | "default";
+export interface ConfirmDialogProps {
+    /** Whether the dialog is open (defaults to true when rendered by slot wrapper) */
+    isOpen?: boolean;
+    /** Callback when dialog is closed (injected by slot wrapper) */
+    onClose?: () => void;
+    /** Callback when action is confirmed (injected by slot wrapper) */
+    onConfirm?: () => void;
+    /** Dialog title */
+    title: string;
+    /** Dialog message/description */
+    message?: string | React.ReactNode;
+    /** Alias for message (schema compatibility) */
+    description?: string | React.ReactNode;
+    /** Confirm button text */
+    confirmText?: string;
+    /** Alias for confirmText (schema compatibility) */
+    confirmLabel?: string;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Alias for cancelText (schema compatibility) */
+    cancelLabel?: string;
+    /** Dialog variant */
+    variant?: ConfirmDialogVariant;
+    /** Dialog size */
+    size?: ModalSize;
+    /** Loading state for confirm button */
+    isLoading?: boolean;
+    /** Error state */
+    error?: UiError | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * ConfirmDialog - Confirmation dialog for important actions
+ */
+export declare const ConfirmDialog: React.FC<ConfirmDialogProps>;
+export default ConfirmDialog;