import * as react_jsx_runtime from 'react/jsx-runtime';
import * as class_variance_authority_types from 'class-variance-authority/types';
import * as React from 'react';
import { VariantProps } from 'class-variance-authority';
import { Avatar as Avatar$1 } from 'radix-ui';
import { DraggableAttributes } from '@dnd-kit/core';

type UntitledButtonColor = "primary" | "secondary" | "tertiary" | "link" | "primary-destructive" | "secondary-destructive";
type UntitledButtonSize = "sm" | "md" | "lg" | "xl";
declare const untitledButtonVariants: (props?: ({
    color?: "primary" | "secondary" | "link" | "tertiary" | "primary-destructive" | "secondary-destructive" | null | undefined;
    size?: "sm" | "lg" | "xl" | "md" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface UntitledButtonProps extends Omit<React.ComponentProps<"button">, "color">, VariantProps<typeof untitledButtonVariants> {
    /** Icon rendered before the label. Ignored when `asChild` is set. */
    iconLeading?: React.ReactNode;
    /** Icon rendered after the label. Ignored when `asChild` is set. */
    iconTrailing?: React.ReactNode;
    /** Show a spinner and make the button non-interactive. */
    isLoading?: boolean;
    /** Merge props onto the single child element (Radix Slot) — for links. */
    asChild?: boolean;
}
declare function UntitledButton({ className, color, size, iconLeading, iconTrailing, isLoading, asChild, disabled, type, children, ...props }: UntitledButtonProps): react_jsx_runtime.JSX.Element;

type AvatarVariant = "muted" | "secondary" | "primary" | "chart";
/**
 * Action-button chrome for initials — matches `Button variant="secondary"` (elevated
 * gradient, border, shadow, foreground text). `variant="primary"` / `"chart"` use this too.
 */
declare const AVATAR_PRIMARY_FALLBACK_CLASS: string;
/**
 * @deprecated Name retained for API stability — returns Action-button (secondary) surface.
 */
declare function avatarChartVariantClass(_seed?: string): string;
declare const AVATAR_SIZE_CLASS: {
    readonly default: "size-7";
    readonly sm: "size-5";
    readonly lg: "size-9";
};
declare function Avatar({ className, size, variant: rootVariant, children, ...props }: React.ComponentProps<typeof Avatar$1.Root> & {
    size?: keyof typeof AVATAR_SIZE_CLASS;
    /**
     * `secondary` / `primary` / `chart` — elevated Action-button chrome on the root.
     * Prefer `secondary`; `primary` is an alias for the same look (not dark primary CTA).
     */
    variant?: AvatarVariant;
}): react_jsx_runtime.JSX.Element;
declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof Avatar$1.Image>): react_jsx_runtime.JSX.Element;
declare function AvatarFallback({ className, variant, seed: _seed, children, style, ...props }: React.ComponentProps<typeof Avatar$1.Fallback> & {
    /**
     * `secondary` — Action button look (`Button variant="secondary"`).
     * `primary` / `chart` — same as `secondary` (aliases for prompts).
     */
    variant?: AvatarVariant;
    /** Reserved for API compatibility; color no longer varies by seed. */
    seed?: string;
}): react_jsx_runtime.JSX.Element;

type BannerTone = "default" | "primary" | "success" | "warn" | "danger";
type BannerVariant = "soft" | "solid" | "outline";
type BannerSize = "sm" | "default";
interface BannerProps extends Omit<React.ComponentProps<"div">, "title"> {
    tone?: BannerTone;
    /** Emphasis. Default `"soft"`. */
    variant?: BannerVariant;
    /** Size. Default `"default"`. */
    size?: BannerSize;
    icon?: React.ReactNode;
    title?: React.ReactNode;
    /** Right-aligned actions (buttons, links). */
    actions?: React.ReactNode;
    /** Show a dismiss button; fires `onDismiss`. */
    onDismiss?: () => void;
}
/**
 * Page-level announcement bar — a full-width, dismissible notice with a tone, an
 * optional leading icon, message, and trailing actions. For in-flow form/field
 * messages use `Alert` instead.
 */
declare function Banner({ tone, variant, size, icon, title, actions, onDismiss, className, children, ...props }: BannerProps): react_jsx_runtime.JSX.Element;

type TimelineTone = "default" | "primary" | "success" | "warn" | "danger";
interface TimelineItem {
    id: string;
    title: React.ReactNode;
    description?: React.ReactNode;
    /** Right-aligned timestamp / meta. */
    meta?: React.ReactNode;
    tone?: TimelineTone;
    /** Custom node inside the marker (e.g. an icon). */
    icon?: React.ReactNode;
}
type TimelineSize = "sm" | "default";
interface TimelineProps extends Omit<React.ComponentProps<"ol">, "children"> {
    items: TimelineItem[];
    /** Vertical rhythm between entries. Default `"default"`. */
    size?: TimelineSize;
}
/**
 * Vertical event log — a marker rail with a title, optional description, and
 * trailing meta per entry. Presentational; pass already-formatted timestamps.
 */
declare function Timeline({ items, size, className, ...props }: TimelineProps): react_jsx_runtime.JSX.Element;

type KanbanTone = "default" | "primary" | "success" | "warn" | "danger";
type KanbanDensity = "default" | "compact";
type KanbanCardVariant = "default" | "outline" | "muted" | "tonal";
interface KanbanCardData {
    id: string;
}
interface KanbanColumnData<C extends KanbanCardData = KanbanCardData> {
    id: string;
    title?: React.ReactNode;
    description?: React.ReactNode;
    /** Trailing header node (e.g. an add button). */
    action?: React.ReactNode;
    /** Footer rendered under the card list (e.g. "Add card"). */
    footer?: React.ReactNode;
    tone?: KanbanTone;
    cards: C[];
}
interface KanbanLocation {
    columnId: string;
    index: number;
}
interface KanbanMoveEvent<C extends KanbanCardData = KanbanCardData> {
    card: C;
    cardId: string;
    from: KanbanLocation;
    to: KanbanLocation;
    /** The resulting board arrangement. */
    columns: KanbanColumnData<C>[];
}
/**
 * Spread onto any element to make it the card's drag handle (pointer + keyboard).
 * Useful for rich cards that want the handle on a custom control (e.g. a header
 * grip or an avatar) — set `dragHandle="none"` on `Kanban` to drop the default.
 */
type KanbanDragHandleProps = DraggableAttributes & React.DOMAttributes<HTMLElement>;
interface KanbanRenderCardContext<C extends KanbanCardData = KanbanCardData> {
    column: KanbanColumnData<C>;
    isDragging: boolean;
    /** True while rendering inside the floating drag overlay. */
    isOverlay: boolean;
    /** Spread onto a custom drag handle. Undefined when the board is disabled. */
    dragHandleProps?: KanbanDragHandleProps;
}
interface KanbanProps<C extends KanbanCardData = KanbanCardData> {
    /** Controlled columns (with their cards). */
    columns?: KanbanColumnData<C>[];
    /** Uncontrolled initial columns. */
    defaultColumns?: KanbanColumnData<C>[];
    /** Fired with the full next arrangement after any move/reorder. */
    onColumnsChange?: (columns: KanbanColumnData<C>[]) => void;
    /** Fired with move details (card, from, to) after a drag completes. */
    onMove?: (event: KanbanMoveEvent<C>) => void;
    /** Render a card's body. */
    renderCard: (card: C, ctx: KanbanRenderCardContext<C>) => React.ReactNode;
    /** Override the default column header (title + count). */
    renderColumnHeader?: (column: KanbanColumnData<C>) => React.ReactNode;
    /** Resolve a stable id for a card. Default: `card.id`. */
    getCardId?: (card: C) => string;
    /** Shown inside an empty column's drop area. */
    emptyColumnLabel?: React.ReactNode;
    density?: KanbanDensity;
    cardVariant?: KanbanCardVariant;
    /**
     * Drag handle strategy. `"auto"` (default) renders a hover grip in the card's
     * top-right corner. `"none"` removes it so you can place your own handle by
     * spreading `ctx.dragHandleProps` (from `renderCard`) onto any element.
     */
    dragHandle?: "auto" | "none";
    /** Disable all drag interactions (read-only board). */
    disabled?: boolean;
    /** Accessible label for the board region. */
    "aria-label"?: string;
    className?: string;
    columnClassName?: string;
    cardClassName?: string;
}
/**
 * Proprietary Kanban board on `@dnd-kit` — accessible drag-and-drop with
 * pointer + keyboard sensors, cross-column moves, empty-column drop zones, and a
 * floating drag overlay. Controlled (`columns` + `onColumnsChange`) or
 * uncontrolled (`defaultColumns`); `onMove` reports each completed move.
 */
declare function Kanban<C extends KanbanCardData = KanbanCardData>({ columns: columnsProp, defaultColumns, onColumnsChange, onMove, renderCard, renderColumnHeader, getCardId, emptyColumnLabel, density, cardVariant, dragHandle, disabled, className, columnClassName, cardClassName, ...rest }: KanbanProps<C>): react_jsx_runtime.JSX.Element;

export { AVATAR_PRIMARY_FALLBACK_CLASS as A, Banner as B, Kanban as K, Timeline as T, UntitledButton as U, Avatar as a, AvatarFallback as b, AvatarImage as c, type AvatarVariant as d, type BannerProps as e, type BannerSize as f, type BannerTone as g, type BannerVariant as h, type KanbanCardData as i, type KanbanCardVariant as j, type KanbanColumnData as k, type KanbanDensity as l, type KanbanDragHandleProps as m, type KanbanLocation as n, type KanbanMoveEvent as o, type KanbanProps as p, type KanbanRenderCardContext as q, type KanbanTone as r, type TimelineItem as s, type TimelineProps as t, type TimelineSize as u, type UntitledButtonColor as v, type UntitledButtonProps as w, type UntitledButtonSize as x, avatarChartVariantClass as y, untitledButtonVariants as z };