@arkcit/react-ui 0.3.0

package/dist/ComponentGuidelines-h1MjGBuJ.d.ts

@@ -0,0 +1,1293 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { PropsWithChildren, Dispatch, SetStateAction, ReactNode } from 'react';
+import { FieldConfig, FormState, Field } from '@arkcit/engine/form';
+import { LucideIcon } from 'lucide-react';
+
+type AlertIntent = "danger" | "warning" | "info" | "success";
+/**
+ * @deprecated Use `intent` instead.
+ */
+type AlertType = "error" | "warning" | "info" | "success";
+interface AlertBannerProps {
+    intent?: AlertIntent;
+    /**
+     * @deprecated Use `intent`.
+     */
+    type?: AlertType;
+    message: React__default.ReactNode | Record<string, unknown>;
+    onClose?: () => void;
+}
+declare const AlertBanner: ({ intent, type, message, onClose }: AlertBannerProps) => react_jsx_runtime.JSX.Element;
+
+declare enum Currency {
+    EURO = "EUR",
+    DOLLAR = "USD"
+}
+declare enum CurrencySymbol {
+    EUR = "\u20AC",
+    USD = "$"
+}
+
+interface SubscriptionType {
+    id: string | null;
+    name: string;
+    image: string;
+    description?: string | null;
+    price?: number | null;
+    currency: Currency | null;
+}
+type Entity = SubscriptionType;
+
+type CommonDictionary = Record<string, string>;
+interface CarouselProps {
+    entities: Entity[];
+    autoPlay?: boolean;
+    interval?: number;
+    overlayText?: (entity: Entity) => React__default.ReactNode;
+    onAction?: (entity: Entity) => string | undefined;
+    dict: CommonDictionary;
+}
+declare const Carousel: ({ entities, autoPlay, interval, overlayText, onAction, dict, }: CarouselProps) => react_jsx_runtime.JSX.Element;
+
+type EmbeddedVideoProvider = "youtube" | "vimeo" | "html5" | "iframe";
+type EmbeddedVideoPlayback = {
+    autoPlay?: boolean;
+    muted?: boolean;
+    controls?: boolean;
+    loop?: boolean;
+    start?: number;
+    end?: number;
+    allowFullScreen?: boolean;
+};
+type EmbeddedVideoYouTube = {
+    videoId?: string;
+};
+type EmbeddedVideoVimeo = {
+    videoId?: string;
+};
+type EmbeddedVideoHtml5 = {
+    src?: string;
+    sources?: Array<{
+        src: string;
+        type?: string;
+    }>;
+    poster?: string;
+};
+type EmbeddedVideoIframe = {
+    src?: string;
+};
+interface EmbeddedVideoProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    provider: EmbeddedVideoProvider;
+    title: string;
+    aspect?: "16/9" | "4/3" | "1/1" | "9/16";
+    playback?: EmbeddedVideoPlayback;
+    youtube?: EmbeddedVideoYouTube;
+    vimeo?: EmbeddedVideoVimeo;
+    html5?: EmbeddedVideoHtml5;
+    iframe?: EmbeddedVideoIframe;
+}
+declare const EmbeddedVideo: ({ provider, title, aspect, playback, youtube, vimeo, html5, iframe, className, ...props }: EmbeddedVideoProps) => react_jsx_runtime.JSX.Element;
+
+interface GameAPI {
+    keysDown: Set<string>;
+    pointer: {
+        x: number;
+        y: number;
+        down: boolean;
+    };
+    size: {
+        width: number;
+        height: number;
+        pixelRatio: number;
+    };
+    requestStop: () => void;
+    requestStart: () => void;
+    clear: (color?: string) => void;
+}
+interface GameCanvas2DProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    width?: number;
+    height?: number;
+    pixelRatio?: number;
+    running?: boolean;
+    onInit?: (ctx: CanvasRenderingContext2D, api: GameAPI) => void;
+    onFrame?: (ctx: CanvasRenderingContext2D, dt: number, api: GameAPI) => void;
+    onResize?: (ctx: CanvasRenderingContext2D, api: GameAPI) => void;
+    onDispose?: (api: GameAPI) => void;
+    captureKeyboard?: boolean;
+    capturePointer?: boolean;
+    className?: string;
+    canvasClassName?: string;
+}
+declare const GameCanvas2D: ({ width, height, pixelRatio, running, onInit, onFrame, onResize, onDispose, captureKeyboard, capturePointer, className, canvasClassName, ...props }: GameCanvas2DProps) => react_jsx_runtime.JSX.Element;
+
+type GraphBaseProps = Omit<React__default.HTMLAttributes<HTMLDivElement>, "title">;
+interface GraphProps extends GraphBaseProps {
+    title?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    ariaLabel?: string;
+    hasData?: boolean;
+    noDataText?: string;
+}
+declare const Graph: ({ title, description, ariaLabel, hasData, noDataText, className, children, ...props }: GraphProps) => react_jsx_runtime.JSX.Element;
+
+type GraphXValue = number | string | Date;
+type GraphIntent = "primary" | "success" | "warning" | "danger" | "info" | "secondary";
+interface GraphDatum {
+    x: GraphXValue;
+    y: number;
+}
+interface GraphSeries {
+    id: string;
+    label?: string;
+    data: GraphDatum[];
+    intent?: GraphIntent;
+}
+interface GraphAxisConfig {
+    format?: (value: GraphXValue | number) => string;
+    ticks?: number;
+}
+
+interface LineGraphProps extends Omit<GraphProps, "children" | "hasData" | "noDataText"> {
+    series: GraphSeries[];
+    width?: number;
+    height?: number;
+    xAxis?: GraphAxisConfig;
+    yAxis?: GraphAxisConfig;
+    grid?: boolean;
+    legend?: boolean;
+    tooltip?: "none" | "hover";
+    noDataText?: string;
+}
+declare const LineGraph: ({ series, width, height, xAxis, yAxis, grid, legend, tooltip, title, description, ariaLabel, className, noDataText, ...props }: LineGraphProps) => react_jsx_runtime.JSX.Element;
+
+interface BarGraphProps extends Omit<GraphProps, "children" | "hasData" | "noDataText"> {
+    series: GraphSeries[];
+    width?: number;
+    height?: number;
+    xAxis?: GraphAxisConfig;
+    yAxis?: GraphAxisConfig;
+    grid?: boolean;
+    legend?: boolean;
+    noDataText?: string;
+}
+declare const BarGraph: ({ series, width, height, xAxis, yAxis, grid, legend, title, description, ariaLabel, className, noDataText, ...props }: BarGraphProps) => react_jsx_runtime.JSX.Element;
+
+type LatLng = {
+    lat: number;
+    lng: number;
+};
+type MapCardProvider = "openstreetmap" | "googlemaps" | "iframe";
+interface Poi {
+    id: string;
+    title: string;
+    description?: string;
+    position: LatLng;
+    avatar?: {
+        src?: string;
+        fallback?: string;
+    };
+    tags?: string[];
+    href?: string;
+}
+interface MapCardProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    provider?: MapCardProvider;
+    initialCenter: LatLng;
+    initialZoom?: number;
+    height?: number;
+    iframeSrc?: string;
+    iframeTitle?: string;
+    googleMapsQuery?: string;
+    enableGeolocation?: boolean;
+    geolocationLabel?: string;
+    pois?: Poi[];
+    loadPois?: (center: LatLng, radiusMeters: number) => Promise<Poi[]>;
+    radiusMeters?: number;
+    title?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    onCenterChange?: (center: LatLng) => void;
+}
+declare const MapCard: ({ provider, initialCenter, initialZoom, height, iframeSrc, iframeTitle, googleMapsQuery, enableGeolocation, geolocationLabel, pois: staticPois, loadPois, radiusMeters, title, emptyTitle, emptyDescription, onCenterChange, className, ...props }: MapCardProps) => react_jsx_runtime.JSX.Element;
+
+interface DrawerProps {
+    open: boolean;
+    onClose: () => void;
+    side?: "left" | "right";
+    closeOnOutsideClick?: boolean;
+    title?: React__default.ReactNode;
+    children: React__default.ReactNode;
+    className?: string;
+    overlayClassName?: string;
+}
+declare const Drawer: ({ open, onClose, side, closeOnOutsideClick, title, children, className, overlayClassName, }: DrawerProps) => react_jsx_runtime.JSX.Element | null;
+
+type MenuIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type ContextMenuItem = {
+    type?: "item";
+    id: string;
+    label: string;
+    icon?: React__default.ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    intent?: MenuIntent;
+    onSelect: () => void;
+} | {
+    type: "separator";
+    id?: string;
+} | {
+    type: "submenu";
+    id: string;
+    label: string;
+    items: ContextMenuItem[];
+};
+interface ContextMenuProps {
+    items: ContextMenuItem[];
+    children: React__default.ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+declare const ContextMenu: ({ items, children, disabled, className }: ContextMenuProps) => react_jsx_runtime.JSX.Element;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    keywords?: string[];
+    hint?: string;
+    icon?: React__default.ReactNode;
+    onSelect: () => void;
+    disabled?: boolean;
+    group?: string;
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    items: CommandItem[];
+    placeholder?: string;
+    emptyMessage?: string;
+    className?: string;
+}
+declare const CommandPalette: ({ open, onOpenChange, items, placeholder, emptyMessage, className, }: CommandPaletteProps) => react_jsx_runtime.JSX.Element | null;
+
+interface DecodeTranslationProps {
+    translation: string;
+    htmlTag?: React.ElementType;
+    className?: string;
+    href?: string;
+    tagContent?: React.ReactNode;
+}
+declare const DecodeTranslation: ({ translation, htmlTag: Tag, className, href, tagContent, }: DecodeTranslationProps) => react_jsx_runtime.JSX.Element;
+
+type BindableTextValue$1 = string | number | {
+    $t?: string;
+    $ref?: string;
+    values?: Record<string, unknown>;
+};
+interface BreadcrumbItem {
+    id?: string | BindableTextValue$1;
+    label: React__default.ReactNode | BindableTextValue$1;
+    href?: string | BindableTextValue$1;
+    onClick?: () => void;
+    current?: boolean;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    separator?: React__default.ReactNode;
+    maxItems?: number;
+    className?: string;
+}
+declare const Breadcrumb: ({ items, separator, maxItems, className }: BreadcrumbProps) => react_jsx_runtime.JSX.Element;
+
+type ComboboxOption<T> = {
+    value: T;
+    label: string;
+    disabled?: boolean;
+};
+type FieldIntent$1 = "primary" | "secondary" | "success" | "warning" | "danger" | "info";
+type FieldVariant = "solid" | "outline" | "ghost" | "soft" | "glass";
+type FieldSize$1 = "sm" | "md" | "lg";
+type ComboboxProps<T> = {
+    options: ComboboxOption<T>[];
+    value?: T | null;
+    onChange?: (value: T | null) => void;
+    values?: T[];
+    onChangeMany?: (values: T[]) => void;
+    multiple?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    search?: boolean;
+    query?: string;
+    onQueryChange?: (q: string) => void;
+    filterFn?: (opt: ComboboxOption<T>, query: string) => boolean;
+    closeOnSelect?: boolean;
+    maxSelected?: number;
+    size?: FieldSize$1;
+    intent?: FieldIntent$1;
+    variant?: FieldVariant;
+    label?: string;
+    hint?: string;
+    error?: string;
+    className?: string;
+    inputClassName?: string;
+    menuClassName?: string;
+    renderOption?: (opt: ComboboxOption<T>, state: {
+        selected: boolean;
+        active: boolean;
+    }) => React__default.ReactNode;
+    renderValue?: (value: T) => string;
+    "aria-label"?: string;
+    id?: string;
+    name?: string;
+};
+declare const Combobox: <T>({ options, value, onChange, values, onChangeMany, multiple, placeholder, disabled, loading, search, query, onQueryChange, filterFn, closeOnSelect, maxSelected, size, intent, variant, label, hint, error, className, inputClassName, menuClassName, renderOption, renderValue, "aria-label": ariaLabel, id, name, }: ComboboxProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface ExpandablePanelProps {
+    title: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onDelete?: () => void;
+    disableAnimation?: boolean;
+}
+/**
+ * Expandable panel:
+ * - solid primary header
+ * - optional delete button
+ * - animated height transition
+ */
+declare const ExpandablePanel: ({ title, children, defaultOpen, open, onOpenChange, onDelete, disableAnimation, }: ExpandablePanelProps) => react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    title: string;
+    description?: string;
+    icon?: React__default.ReactNode;
+    action?: React__default.ReactNode;
+}
+declare const EmptyState: ({ title, description, icon, action, className, ...props }: EmptyStateProps) => react_jsx_runtime.JSX.Element;
+
+type SortDirection = "asc" | "desc";
+type SortState = {
+    key: string;
+    direction: SortDirection;
+} | null;
+type DataGridColumn<T> = {
+    key: string;
+    header: React__default.ReactNode;
+    accessor?: (row: T) => unknown;
+    render?: (value: unknown, row: T) => React__default.ReactNode;
+    sortable?: boolean;
+    width?: string | number;
+    align?: "left" | "center" | "right";
+};
+type DataGridProps<T> = {
+    rows: T[];
+    columns: DataGridColumn<T>[];
+    getRowId?: (row: T, index: number) => string;
+    onRowClick?: (row: T) => void;
+    selectable?: boolean;
+    selectedRowIds?: string[];
+    defaultSelectedRowIds?: string[];
+    onSelectionChange?: (ids: string[]) => void;
+    sortable?: boolean;
+    sort?: SortState;
+    defaultSort?: SortState;
+    onSortChange?: (sort: SortState) => void;
+    loading?: boolean;
+    emptyState?: React__default.ReactNode;
+    pagination?: {
+        page: number;
+        pageSize: number;
+        total?: number;
+        onPageChange: (page: number) => void;
+    };
+    infiniteList?: {
+        hasNextPage: boolean;
+        isFetching: boolean;
+        onLoadMore: () => void;
+        loadMoreLabel?: string;
+        loadingLabel?: string;
+        endMessage?: React__default.ReactNode;
+        showLoadMoreButton?: boolean;
+    };
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    className?: string;
+};
+declare const DataGrid: <T>({ rows, columns, getRowId, onRowClick, selectable, selectedRowIds, defaultSelectedRowIds, onSelectionChange, sortable, sort, defaultSort, onSortChange, loading, emptyState, pagination, infiniteList, searchable, searchPlaceholder, className, }: DataGridProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface FilterBarProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    description?: string;
+    left?: React__default.ReactNode;
+    filters?: React__default.ReactNode;
+    actions?: React__default.ReactNode;
+    sticky?: boolean;
+}
+declare const FilterBar: ({ title, description, left, filters, actions, sticky, className, ...props }: FilterBarProps) => react_jsx_runtime.JSX.Element;
+
+type AccordionVariant = "primary" | "secondary" | "ghost";
+interface AccordionItem {
+    id: string;
+    title: React__default.ReactNode;
+    content: React__default.ReactNode;
+    disabled?: boolean;
+}
+interface AccordionProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    items: AccordionItem[];
+    variant?: AccordionVariant;
+    allowMultiple?: boolean;
+    defaultOpenIds?: string[];
+    openIds?: string[];
+    onOpenIdsChange?: (openIds: string[]) => void;
+    children?: React__default.ReactNode;
+}
+declare const Accordion: ({ items, variant, allowMultiple, defaultOpenIds, openIds: controlledOpenIds, onOpenIdsChange, className, children, ...props }: AccordionProps) => react_jsx_runtime.JSX.Element;
+
+type ScrollFrom = "bottom" | "top" | "left" | "right";
+interface ScrollRevealProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    from?: ScrollFrom;
+    distance?: number;
+    durationMs?: number;
+    delayMs?: number;
+    once?: boolean;
+    threshold?: number;
+    rootMargin?: string;
+    asChild?: boolean;
+    glassy?: boolean;
+    children: React__default.ReactNode;
+}
+declare const ScrollReveal: React__default.ForwardRefExoticComponent<ScrollRevealProps & React__default.RefAttributes<HTMLDivElement>>;
+
+type CoverVariant = "default" | "split" | "centered" | "stacked";
+type CoverSize = "full" | "sm" | "md" | "lg";
+type CoverSurface = "plain" | "card" | "glass";
+type CoverAlign = "left" | "center";
+type CoverAs = "section" | "header" | "div";
+type CoverTextVariant = "primary" | "secondary" | "light" | "default";
+type CoverBaseProps = Omit<React__default.HTMLAttributes<HTMLElement>, "title">;
+interface CoverProps extends CoverBaseProps {
+    title?: React__default.ReactNode;
+    subtitle?: React__default.ReactNode;
+    eyebrow?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    actions?: React__default.ReactNode;
+    media?: React__default.ReactNode;
+    variant?: CoverVariant;
+    size?: CoverSize;
+    surface?: CoverSurface;
+    align?: CoverAlign;
+    as?: CoverAs;
+    textVariant?: CoverTextVariant;
+    reveal?: boolean;
+    revealProps?: Omit<ScrollRevealProps, "children" | "className">;
+    children?: React__default.ReactNode;
+}
+declare const Cover: React__default.ForwardRefExoticComponent<CoverProps & React__default.RefAttributes<HTMLElement>>;
+
+declare enum LoaderType {
+    SPINNER = "spinner",
+    DOTS = "dots",
+    RING = "ring"
+}
+
+interface FormProps<T extends object = Record<string, unknown>> {
+    title: string;
+    fields: FieldConfig[];
+    values: T;
+    errors?: Partial<Record<keyof T, string>>;
+    loading?: boolean;
+    success?: string | null;
+    error?: string | null;
+    columns?: 1 | 2;
+    size?: "sm" | "md" | "lg" | "full";
+    onChange: (e: React__default.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    onSubmit?: (e: React__default.FormEvent) => void;
+    onReset?: () => void;
+    loaderType?: LoaderType;
+    dict: Record<string, string>;
+    t?: (key: string, values?: Record<string, unknown>) => string;
+    onFormStateChange?: (state: FormState) => void;
+    studio?: {
+        onSubmitLabelDoubleClick?: () => void;
+        onResetLabelDoubleClick?: () => void;
+    };
+}
+declare const Form: <T extends object>({ title, fields, values, errors, loading, success, error, onChange, onSubmit, onReset, columns, size, loaderType, dict, t, onFormStateChange, studio, }: FormProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface FormFieldProps {
+    field: FieldConfig;
+    value: Field;
+    error?: string;
+    onChange: (e: React__default.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    /** Optionnel si un formulaire veut overrider le loader */
+    loaderType?: LoaderType;
+    dict: Record<string, string>;
+}
+declare const FormField: ({ field, value, error, onChange, loaderType, dict, }: FormFieldProps) => react_jsx_runtime.JSX.Element;
+
+type DateRange = {
+    start?: Date;
+    end?: Date;
+};
+type DateRangePickerConstraints = {
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[];
+    isDateDisabled?: (date: Date) => boolean;
+    minNights?: number;
+};
+type DateRangePickerCalendar = {
+    monthsToShow?: 1 | 2;
+    firstDayOfWeek?: 0 | 1;
+    locale?: string;
+    showWeekNumbers?: boolean;
+};
+type DateRangePickerOverlay = {
+    responsiveMode?: "auto" | "desktop" | "mobile";
+    mobileOverlay?: "drawer" | "popin";
+    mobileTitle?: React__default.ReactNode;
+    withTrigger?: boolean;
+    placeholder?: string;
+    formatValue?: (range: DateRange, locale: string, placeholder: string) => string;
+};
+type DateRangePickerProps = {
+    value?: DateRange;
+    defaultValue?: DateRange;
+    onChange?: (range: DateRange) => void;
+    constraints?: DateRangePickerConstraints;
+    calendar?: DateRangePickerCalendar;
+    overlay?: DateRangePickerOverlay;
+    className?: string;
+};
+declare const DateRangePicker: ({ value, defaultValue, onChange, constraints, calendar, overlay, className, }: DateRangePickerProps) => react_jsx_runtime.JSX.Element;
+
+type DateRangeFieldUi = {
+    description?: React__default.ReactNode;
+    placeholder?: string;
+    format?: (range: DateRange) => string;
+    hideLabel?: boolean;
+};
+type DateRangeFieldProps = {
+    name: string;
+    label: React__default.ReactNode;
+    required?: boolean;
+    className?: string;
+    value?: DateRange;
+    defaultValue?: DateRange;
+    onChange?: (range: DateRange) => void;
+    ui?: DateRangeFieldUi;
+    picker?: Omit<DateRangePickerProps, "value" | "defaultValue" | "onChange" | "className">;
+};
+declare const DateRangeField: ({ name, label, required, className, value, defaultValue, onChange, ui, picker, }: DateRangeFieldProps) => react_jsx_runtime.JSX.Element;
+
+interface InfiniteListProps {
+    children: React__default.ReactNode;
+    hasNextPage: boolean;
+    isFetching: boolean;
+    onLoadMore: () => void;
+    loadMoreLabel?: string;
+    loadingLabel?: string;
+    endMessage?: React__default.ReactNode;
+    ariaLive?: "polite" | "off";
+    roleFeed?: boolean;
+    skeleton?: React__default.ReactNode;
+    skeletonCount?: number;
+    rootMargin?: string;
+    threshold?: number;
+    disabled?: boolean;
+    className?: string;
+    sentinelClassName?: string;
+    showLoadMoreButton?: boolean;
+}
+declare const InfiniteList: ({ children, hasNextPage, isFetching, onLoadMore, loadMoreLabel, loadingLabel, endMessage, ariaLive, roleFeed, skeleton, skeletonCount, rootMargin, threshold, disabled, className, sentinelClassName, showLoadMoreButton, }: InfiniteListProps) => react_jsx_runtime.JSX.Element;
+
+interface PaginationProps extends React__default.HTMLAttributes<HTMLElement> {
+    page: number;
+    pageCount: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    disabled?: boolean;
+    previousLabel?: string;
+    lastLabel?: string;
+}
+declare const Pagination: ({ page, pageCount, onPageChange, siblingCount, disabled, previousLabel, lastLabel, className, ...props }: PaginationProps) => react_jsx_runtime.JSX.Element;
+
+type BindableTextValue = string | number | {
+    $t?: string;
+    $ref?: string;
+    values?: Record<string, unknown>;
+};
+interface Step {
+    id: string | BindableTextValue;
+    title: React__default.ReactNode | BindableTextValue;
+    description?: React__default.ReactNode | BindableTextValue;
+    state?: "complete" | "active" | "upcoming" | "blocked";
+}
+interface StepperProps {
+    steps: Step[];
+    activeStepId: string;
+    onStepChange?: (id: string) => void;
+    onStepTitleDoubleClick?: (id: string) => void;
+    onStepDescriptionDoubleClick?: (id: string) => void;
+    orientation?: "horizontal" | "vertical";
+    className?: string;
+}
+declare const Stepper: ({ steps, activeStepId, onStepChange, onStepTitleDoubleClick, onStepDescriptionDoubleClick, orientation, className, }: StepperProps) => react_jsx_runtime.JSX.Element;
+
+type StepFormVariant = "plain" | "card" | "glass";
+type StepFormAlign = "left" | "center";
+type StepFormSize = "sm" | "md" | "lg";
+type StepFormFormProps<T extends object = Record<string, unknown>> = {
+    fields: FieldConfig[];
+    values: T;
+    errors?: Partial<Record<keyof T, string>>;
+    loading?: boolean;
+    submitDisabled?: boolean;
+    success?: string | null;
+    error?: string | null;
+    columns?: 1 | 2;
+    onChange: (e: React__default.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    onSubmit?: (e: React__default.FormEvent) => void;
+    onReset?: () => void;
+    loaderType?: LoaderType;
+    dict?: Record<string, string>;
+};
+type StepFormStudioProps = {
+    nodeId: string;
+    selected?: boolean;
+    sizing?: {
+        widthPct?: number | null;
+        heightPct?: number | null;
+        heightPx?: number | null;
+    };
+    onSelect?: (nodeId: string) => void;
+    onResize?: (nodeId: string, size: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    }) => void;
+    onSubmitLabelDoubleClick?: () => void;
+    onResetLabelDoubleClick?: () => void;
+};
+type StepFormProps = {
+    title?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    actions?: React__default.ReactNode;
+    variant?: StepFormVariant;
+    align?: StepFormAlign;
+    size?: StepFormSize;
+    headerSlot?: React__default.ReactNode;
+    footerSlot?: React__default.ReactNode;
+    stickyActions?: boolean;
+    className?: string;
+    form?: StepFormFormProps;
+    studio?: StepFormStudioProps;
+};
+declare const StepForm: React__default.ForwardRefExoticComponent<StepFormProps & React__default.RefAttributes<HTMLHeadingElement>>;
+
+type WizardStepId = string;
+type WizardStepBase = {
+    id: WizardStepId;
+    title: string;
+    description?: string;
+    titleNode?: React__default.ReactNode;
+    descriptionNode?: React__default.ReactNode;
+    content: React__default.ReactNode;
+    isValid?: boolean;
+    onNext?: () => boolean | Promise<boolean>;
+};
+type FormWizardLabels = {
+    next?: unknown;
+    back?: unknown;
+    finish?: unknown;
+};
+type FormWizardLayout = {
+    variant?: StepFormVariant;
+    orientation?: "horizontal" | "vertical";
+    size?: StepFormSize;
+    keepMounted?: boolean;
+};
+type FormWizardI18n = {
+    t?: (key: string, values?: Record<string, unknown>) => string;
+    ariaLabel?: string;
+};
+type FormWizardBehavior = {
+    validateOnNext?: "none" | "onNext";
+};
+type FormWizardStateConfig = {
+    isSubmitting?: boolean;
+};
+type FormWizardFormConfig = {
+    onValidateStep?: (stepId: WizardStepId) => boolean | Promise<boolean>;
+    fieldsByStep?: Record<WizardStepId, FieldConfig[]>;
+    values?: Record<string, Field>;
+    errors?: Record<string, string | undefined>;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    dict?: Record<string, string>;
+    loaderType?: LoaderType;
+};
+type FormWizardStudioProps = {
+    onStepTitleDoubleClick?: (id: WizardStepId) => void;
+    onStepDescriptionDoubleClick?: (id: WizardStepId) => void;
+    onBackLabelDoubleClick?: () => void;
+    onNextLabelDoubleClick?: () => void;
+    onFinishLabelDoubleClick?: () => void;
+};
+type FormWizardProps = {
+    steps: WizardStepBase[];
+    initialStepId?: WizardStepId;
+    activeStepId?: WizardStepId;
+    onStepChange?: (id: WizardStepId) => void;
+    className?: string;
+    onFinish?: () => void | Promise<void>;
+    onFormStateChange?: (state: FormWizardState) => void;
+    labels?: FormWizardLabels;
+    layout?: FormWizardLayout;
+    i18n?: FormWizardI18n;
+    behavior?: FormWizardBehavior;
+    state?: FormWizardStateConfig;
+    form?: FormWizardFormConfig;
+    studio?: FormWizardStudioProps;
+};
+type FormWizardState = FormState & {
+    currentStep: WizardStepId;
+    totalSteps: number;
+    canGoNext: boolean;
+    canGoPrevious: boolean;
+};
+declare const FormWizard: ({ steps, initialStepId, activeStepId: controlledActiveStepId, onStepChange, className, onFinish, onFormStateChange, labels, layout, i18n, behavior, state, form, studio, }: FormWizardProps) => react_jsx_runtime.JSX.Element;
+
+type TreeId = string;
+type TreeItem = {
+    id: TreeId;
+    label: React__default.ReactNode;
+    children?: TreeItem[];
+    disabled?: boolean;
+    icon?: React__default.ReactNode;
+    meta?: React__default.ReactNode;
+    defaultExpanded?: boolean;
+};
+type TreeSelectionConfig = {
+    selectedId?: TreeId | null;
+    defaultSelectedId?: TreeId | null;
+    selectedIds?: TreeId[];
+    defaultSelectedIds?: TreeId[];
+    onSelectionChange?: (payload: {
+        selectedId?: TreeId | null;
+        selectedIds?: TreeId[];
+    }) => void;
+};
+type TreeExpandedConfig = {
+    expandedIds?: TreeId[];
+    defaultExpandedIds?: TreeId[];
+    onExpandedChange?: (ids: TreeId[]) => void;
+};
+type TreeCheckedConfig = {
+    checkable?: boolean;
+    checkedIds?: TreeId[];
+    defaultCheckedIds?: TreeId[];
+    onCheckedChange?: (ids: TreeId[]) => void;
+};
+type TreeBehaviorConfig = {
+    collapseOnSelect?: boolean;
+    expandOnSelect?: boolean;
+    toggleOnLabelClick?: boolean;
+};
+type TreeAppearanceConfig = {
+    intent?: "primary" | "secondary";
+    indentPx?: number;
+    showLines?: boolean;
+    itemClassName?: string;
+};
+type TreeProps = {
+    items: TreeItem[];
+    selectionMode?: "none" | "single" | "multiple";
+    selection?: TreeSelectionConfig;
+    expanded?: TreeExpandedConfig;
+    checked?: TreeCheckedConfig;
+    behavior?: TreeBehaviorConfig;
+    appearance?: TreeAppearanceConfig;
+    renderItem?: (item: TreeItem, state: {
+        level: number;
+        expanded: boolean;
+        selected: boolean;
+        disabled: boolean;
+        hasChildren: boolean;
+        checked?: boolean;
+    }) => React__default.ReactNode;
+    className?: string;
+    "aria-label"?: string;
+};
+declare const Tree: ({ items, selectionMode, selection, expanded, checked, behavior, appearance, renderItem, className, "aria-label": ariaLabel, }: TreeProps) => react_jsx_runtime.JSX.Element;
+
+interface TableProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    dense?: boolean;
+    striped?: boolean;
+    hoverable?: boolean;
+}
+type TableHeaderProps = React__default.HTMLAttributes<HTMLTableSectionElement>;
+type TableBodyProps = React__default.HTMLAttributes<HTMLTableSectionElement>;
+type TableFooterProps = React__default.HTMLAttributes<HTMLTableSectionElement>;
+type TableRowProps = React__default.HTMLAttributes<HTMLTableRowElement>;
+type TableHeadProps = React__default.ThHTMLAttributes<HTMLTableCellElement>;
+type TableCellProps = React__default.TdHTMLAttributes<HTMLTableCellElement>;
+type TableCaptionProps = React__default.HTMLAttributes<HTMLTableCaptionElement>;
+declare const Table: (({ dense, striped, hoverable, className, children, ...props }: TableProps) => react_jsx_runtime.JSX.Element) & {
+    Header: ({ className, ...props }: TableHeaderProps) => react_jsx_runtime.JSX.Element;
+    Body: ({ className, ...props }: TableBodyProps) => react_jsx_runtime.JSX.Element;
+    Footer: ({ className, ...props }: TableFooterProps) => react_jsx_runtime.JSX.Element;
+    Row: ({ className, ...props }: TableRowProps) => react_jsx_runtime.JSX.Element;
+    Head: ({ className, ...props }: TableHeadProps) => react_jsx_runtime.JSX.Element;
+    Cell: ({ className, ...props }: TableCellProps) => react_jsx_runtime.JSX.Element;
+    Caption: ({ className, ...props }: TableCaptionProps) => react_jsx_runtime.JSX.Element;
+};
+
+type PopinMaxSize = "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+interface PopinProps {
+    displayedPopin: boolean;
+    setDisplayedPopin: Dispatch<SetStateAction<boolean>>;
+    title: React.ReactNode;
+    closeText: React.ReactNode;
+    hasCloseAvailability?: boolean;
+    closeOnOutsideClick?: boolean;
+    maxSize?: PopinMaxSize;
+    /** optional CTA button */
+    actionText?: React.ReactNode;
+    onAction?: () => void;
+    /** require scroll to enable CTA */
+    requireScrollToEnableAction?: boolean;
+}
+declare const Popin: ({ displayedPopin, children, setDisplayedPopin, title, closeText, hasCloseAvailability, closeOnOutsideClick, maxSize, actionText, onAction, requireScrollToEnableAction, }: PropsWithChildren<PopinProps>) => react_jsx_runtime.JSX.Element | null;
+
+interface ProductProps {
+    name: string;
+    description?: string | null;
+    price?: number | null;
+    currency: Currency | null;
+    image: string;
+    fallbackImage: string;
+    handleCancel: () => void;
+    handleAddToCart: () => void;
+    cancelText: string;
+    addToCartText: string;
+    isDisabled: boolean;
+    isNotCancelable: boolean;
+}
+declare const Product: ({ name, description, price, currency, image, fallbackImage, handleAddToCart, handleCancel, cancelText, addToCartText, isDisabled, isNotCancelable, }: ProductProps) => react_jsx_runtime.JSX.Element;
+
+interface TabItem {
+    label?: ReactNode;
+    title?: ReactNode;
+    content?: ReactNode;
+    id: string | number;
+}
+type TabsNavigation = {
+    /** retourne le search actuel, ex: "?tab=foo&x=1" */
+    getSearch: () => string;
+    /** remplace le search sans recharger (ou navigation client) */
+    replaceSearch: (nextSearch: string) => void;
+};
+interface TabsProps {
+    tabs: TabItem[];
+    defaultActive?: string;
+    className?: string;
+    dict: Record<string, string>;
+    keepMounted?: boolean;
+    /** Active la synchro URL (ex: param tab=xxx). Optionnel. */
+    urlSync?: {
+        param?: string;
+        navigation: TabsNavigation;
+    };
+    /** Callback optionnel */
+    onChange?: (nextTabId: string) => void;
+}
+declare const _default: React__default.MemoExoticComponent<({ tabs, defaultActive, className, dict, keepMounted, urlSync, onChange, }: TabsProps) => react_jsx_runtime.JSX.Element>;
+
+type ToastIntent = "success" | "danger" | "warning" | "info";
+/**
+ * @deprecated Use `intent`.
+ */
+type ToastType = "success" | "error" | "warning" | "info";
+interface ToastProps {
+    intent?: ToastIntent;
+    /**
+     * @deprecated Use `intent`.
+     */
+    type?: ToastType;
+    message: string | React__default.ReactNode;
+    duration?: number;
+    onClose: () => void;
+}
+declare const Toast: ({ intent, type, message, duration, onClose, }: ToastProps) => react_jsx_runtime.JSX.Element;
+
+interface ToastData {
+    id: number;
+    message: string | React__default.ReactNode;
+    intent: ToastIntent;
+}
+interface ToastContainerProps {
+    toasts: ToastData[];
+    setToasts: Dispatch<SetStateAction<ToastData[]>>;
+}
+declare const ToastContainer: ({ toasts, setToasts }: ToastContainerProps) => react_jsx_runtime.JSX.Element;
+
+interface TooltipProps {
+    content: React__default.ReactNode;
+    children: React__default.ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+    delay?: number;
+    disabled?: boolean;
+    className?: string;
+    portal?: boolean;
+    triggerMode?: "hover" | "click" | "both";
+    containerClassName?: string;
+}
+declare const Tooltip: ({ content, children, side, align, delay, disabled, className, portal, triggerMode, containerClassName, }: TooltipProps) => react_jsx_runtime.JSX.Element;
+
+type RadioOption = {
+    label: React__default.ReactNode;
+    value: string;
+    description?: React__default.ReactNode;
+    disabled?: boolean;
+};
+type RadioGroupProps = {
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    options?: RadioOption[];
+    children?: React__default.ReactNode;
+    orientation?: "vertical" | "horizontal";
+    disabled?: boolean;
+    intent?: "primary" | "secondary" | "ghost";
+    size?: "sm" | "md" | "lg";
+    className?: string;
+};
+declare const RadioGroup: ({ name, value, defaultValue, onValueChange, options, children, orientation, disabled, intent, size, className, }: RadioGroupProps) => react_jsx_runtime.JSX.Element;
+
+type RadioFieldProps = {
+    name: string;
+    label: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    required?: boolean;
+    options: RadioOption[];
+    orientation?: "vertical" | "horizontal";
+    intent?: "primary" | "secondary" | "ghost";
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    className?: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    error?: string;
+    errorId?: string;
+};
+declare const RadioField: ({ name, label, description, required, options, orientation, intent, size, disabled, className, value, defaultValue, onValueChange, error, errorId, }: RadioFieldProps) => react_jsx_runtime.JSX.Element;
+
+type ButtonIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type ButtonVariant = "solid" | "outline" | "ghost" | "soft" | "glass" | "reverse-primary" | "reverse-secondary";
+type ButtonSize = "xs" | "sm" | "md" | "lg";
+interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    intent?: ButtonIntent;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    loading?: boolean;
+}
+declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+type BadgeIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type BadgeVariant = "solid" | "outline" | "ghost" | "soft" | "glass";
+type BadgeSize = "xs" | "sm" | "md" | "lg";
+/**
+ * @deprecated Use `intent` + `variant` instead.
+ */
+type LegacyBadgeVariant = "default" | "primary" | "secondary" | "success" | "warning" | "danger" | "outline";
+interface BadgeProps extends React__default.HTMLAttributes<HTMLSpanElement> {
+    children: React__default.ReactNode;
+    intent?: BadgeIntent;
+    variant?: BadgeVariant | LegacyBadgeVariant;
+    size?: BadgeSize;
+}
+declare const Badge: ({ children, intent, variant, size, className, ...props }: BadgeProps) => react_jsx_runtime.JSX.Element;
+
+interface AvatarProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const Avatar: ({ src, alt, fallback, size, className, ...props }: AvatarProps) => react_jsx_runtime.JSX.Element;
+
+type CheckboxProps = React__default.InputHTMLAttributes<HTMLInputElement>;
+declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLInputElement>>;
+
+type RadioProps = Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "type" | "onChange" | "size"> & {
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    intent?: "primary" | "secondary" | "ghost";
+    size?: "sm" | "md" | "lg";
+    label?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+};
+declare const Radio: React__default.ForwardRefExoticComponent<Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "onChange"> & {
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    intent?: "primary" | "secondary" | "ghost";
+    size?: "sm" | "md" | "lg";
+    label?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+} & React__default.RefAttributes<HTMLInputElement>>;
+
+interface ContainerProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    size?: "sm" | "md" | "lg" | "xl" | "full" | "desktop-16-9" | "desktop-16-9-wide";
+}
+declare const Container: ({ size, className, children, ...props }: ContainerProps) => react_jsx_runtime.JSX.Element;
+
+interface DividerProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    orientation?: "horizontal" | "vertical";
+}
+declare const Divider: ({ orientation, className, ...props }: DividerProps) => react_jsx_runtime.JSX.Element;
+
+type PortalProps = {
+    children: ReactNode;
+    container?: HTMLElement | null;
+    containerSelector?: string;
+    rootId?: string;
+};
+declare const Portal: ({ children, container, containerSelector, rootId }: PortalProps) => React$1.ReactPortal | null;
+
+type FieldIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type FieldSize = "xs" | "sm" | "md" | "lg";
+interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    intent?: FieldIntent;
+    size?: FieldSize;
+    rightIcon?: LucideIcon;
+    rightIconClassName?: string;
+}
+declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;
+
+type Breakpoint = "base" | "sm" | "md" | "lg" | "xl" | "2xl";
+type Responsive<T> = Partial<Record<Breakpoint, T>>;
+type GridCols = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+type GridGap = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
+type GridAlign = "start" | "center" | "end" | "stretch";
+type GridJustify = "start" | "center" | "end" | "stretch";
+type GridAutoRows = "auto" | "min" | "fr";
+type GridProps = React__default.HTMLAttributes<HTMLDivElement> & {
+    cols?: Responsive<GridCols>;
+    gap?: Responsive<GridGap>;
+    align?: Responsive<GridAlign>;
+    justify?: Responsive<GridJustify>;
+    dense?: boolean;
+    autoRows?: GridAutoRows;
+    debug?: boolean;
+};
+declare const Grid: ({ cols, gap, align, justify, dense, autoRows, debug, className, style, ...props }: GridProps) => react_jsx_runtime.JSX.Element;
+
+type GridItemProps = React__default.HTMLAttributes<HTMLDivElement> & {
+    colSpan?: Responsive<GridCols>;
+    colStart?: Responsive<number>;
+    rowSpan?: Responsive<number>;
+    order?: Responsive<number>;
+    selfAlign?: Responsive<GridAlign>;
+};
+declare const GridItem: ({ colSpan, colStart, rowSpan, order, selfAlign, className, style, ...props }: GridItemProps) => react_jsx_runtime.JSX.Element;
+
+type LinkUnderline = "always" | "hover" | "none";
+type LinkTone = "default" | "muted" | "danger" | "info" | "inherit";
+type LinkSize = "sm" | "base" | "lg";
+type LinkIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type LinkVariant = "text" | "solid" | "outline" | "ghost" | "soft" | "glass" | "reverse-primary" | "reverse-secondary";
+type LinkProps = React__default.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    external?: boolean;
+    underline?: LinkUnderline;
+    tone?: LinkTone;
+    intent?: LinkIntent;
+    variant?: LinkVariant;
+    size?: LinkSize;
+};
+declare const Link: ({ href, external, underline, tone, intent, variant, size, className, rel, target, children, ...props }: LinkProps) => react_jsx_runtime.JSX.Element;
+
+type KbdSize = "sm" | "md" | "lg";
+type KbdVariant = "default" | "subtle" | "solid";
+interface KbdProps extends Omit<React__default.ComponentPropsWithoutRef<"kbd">, "children"> {
+    children: React__default.ReactNode;
+    size?: KbdSize;
+    variant?: KbdVariant;
+    className?: string;
+}
+declare const Kbd: ({ children, size, variant, className, ...props }: KbdProps) => react_jsx_runtime.JSX.Element;
+
+interface ProgressProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    value: number;
+    max?: number;
+}
+declare const Progress: ({ value, max, className, ...props }: ProgressProps) => react_jsx_runtime.JSX.Element;
+
+interface SelectProps extends Omit<React__default.SelectHTMLAttributes<HTMLSelectElement>, "size"> {
+    intent?: FieldIntent;
+    size?: FieldSize;
+}
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLSelectElement>>;
+
+interface SkeletonProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    rounded?: "none" | "sm" | "md" | "lg" | "full";
+}
+declare const Skeleton: ({ rounded, className, ...props }: SkeletonProps) => react_jsx_runtime.JSX.Element;
+
+type SliderIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type SliderSize = "sm" | "md" | "lg";
+interface SliderProps {
+    value: number;
+    onChange: (v: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    showValue?: boolean;
+    formatValue?: (v: number) => string;
+    intent?: SliderIntent;
+    size?: SliderSize;
+    className?: string;
+    id?: string;
+    name?: string;
+    "aria-label"?: string;
+}
+declare const Slider: ({ value, onChange, min, max, step, disabled, showValue, formatValue, intent, size, className, ...props }: SliderProps) => react_jsx_runtime.JSX.Element;
+
+interface SwitchProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    label?: string;
+}
+declare const Switch: ({ checked, onChange, disabled, label, className, onKeyDown, "aria-label": ariaLabel, ...props }: SwitchProps) => react_jsx_runtime.JSX.Element;
+
+type TagIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type TagVariant = "solid" | "soft" | "outline" | "ghost" | "glass";
+type TagSize = "sm" | "md";
+interface TagProps extends React__default.HTMLAttributes<HTMLSpanElement> {
+    children: React__default.ReactNode;
+    onRemove?: () => void;
+    intent?: TagIntent;
+    variant?: TagVariant;
+    size?: TagSize;
+    disabled?: boolean;
+}
+declare const Tag: ({ children, onRemove, intent, variant, size, disabled, className, ...props }: TagProps) => react_jsx_runtime.JSX.Element;
+
+interface TextareaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    intent?: FieldIntent;
+    size?: FieldSize;
+}
+declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+type UploadIntent = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+type UploadVariant = "solid" | "outline" | "ghost" | "soft" | "glass";
+type FileUploadRejectReason = {
+    type: "maxFiles" | "maxSize" | "accept";
+    file?: File;
+};
+interface FileUploadProps {
+    value?: File[];
+    onChange: (files: File[]) => void;
+    multiple?: boolean;
+    accept?: string;
+    maxFiles?: number;
+    maxSizeBytes?: number;
+    disabled?: boolean;
+    renderFile?: (file: File) => React__default.ReactNode;
+    onReject?: (reason: FileUploadRejectReason) => void;
+    intent?: UploadIntent;
+    variant?: UploadVariant;
+    className?: string;
+}
+declare const FileUpload: ({ value, onChange, multiple, accept, maxFiles, maxSizeBytes, disabled, renderFile, onReject, intent, variant, className, }: FileUploadProps) => react_jsx_runtime.JSX.Element;
+
+type TypographyTone = "default" | "muted" | "danger" | "success" | "warning" | "info" | "inherit";
+type TypographySize = "xs" | "sm" | "base" | "lg" | "xl" | "2xl" | "3xl";
+type TypographyWeight = "normal" | "medium" | "semibold" | "bold";
+type TypographyTracking = "tight" | "normal";
+type TypographyLeading = "tight" | "normal" | "relaxed";
+/** @deprecated Use `tone` instead. */
+type TypographyVariant = "primary" | "secondary" | "custom";
+type VariantAliasProps = {
+    /** @deprecated Use `tone` instead. */
+    variant?: TypographyVariant;
+};
+type PolymorphicProps<C extends React__default.ElementType, Props> = Props & Omit<React__default.ComponentPropsWithoutRef<C>, keyof Props | "as"> & {
+    as?: C;
+};
+type TypographyOwnProps = VariantAliasProps & {
+    children: React__default.ReactNode;
+    tone?: TypographyTone;
+    size?: TypographySize;
+    weight?: TypographyWeight;
+    tracking?: TypographyTracking;
+    leading?: TypographyLeading;
+    className?: string;
+};
+type TypographyProps<C extends React__default.ElementType = "p"> = PolymorphicProps<C, TypographyOwnProps>;
+declare const Typography: <C extends React__default.ElementType = "p">({ as, children, tone, variant, size, weight, tracking, leading, className, ...props }: TypographyProps<C>) => react_jsx_runtime.JSX.Element;
+type H1Props = VariantAliasProps & Omit<React__default.HTMLAttributes<HTMLHeadingElement>, "children"> & {
+    children: React__default.ReactNode;
+    tone?: TypographyTone;
+};
+type H2Props = VariantAliasProps & Omit<React__default.HTMLAttributes<HTMLHeadingElement>, "children"> & {
+    children: React__default.ReactNode;
+    tone?: TypographyTone;
+};
+type H3Props = VariantAliasProps & Omit<React__default.HTMLAttributes<HTMLHeadingElement>, "children"> & {
+    children: React__default.ReactNode;
+    tone?: TypographyTone;
+};
+type WrapperSharedProps = VariantAliasProps & {
+    children: React__default.ReactNode;
+    tone?: TypographyTone;
+    className?: string;
+};
+type TextProps = WrapperSharedProps & Omit<React__default.HTMLAttributes<HTMLElement>, "children" | "className"> & {
+    as?: React__default.ElementType;
+};
+type MutedProps = WrapperSharedProps & Omit<React__default.HTMLAttributes<HTMLElement>, "children" | "className"> & {
+    as?: React__default.ElementType;
+};
+type LeadProps = WrapperSharedProps & Omit<React__default.HTMLAttributes<HTMLElement>, "children" | "className"> & {
+    as?: React__default.ElementType;
+};
+type CodeProps = WrapperSharedProps & Omit<React__default.HTMLAttributes<HTMLElement>, "children" | "className"> & {
+    as?: React__default.ElementType;
+};
+declare const H1: ({ children, tone, variant, className, ...props }: H1Props) => react_jsx_runtime.JSX.Element;
+declare const H2: ({ children, tone, variant, className, ...props }: H2Props) => react_jsx_runtime.JSX.Element;
+declare const H3: ({ children, tone, variant, className, ...props }: H3Props) => react_jsx_runtime.JSX.Element;
+declare const Text: ({ as, children, tone, variant, className, ...props }: TextProps) => react_jsx_runtime.JSX.Element;
+declare const Muted: ({ as, children, tone, variant, className, ...props }: MutedProps) => react_jsx_runtime.JSX.Element;
+declare const Lead: ({ as, children, tone, variant, className, ...props }: LeadProps) => react_jsx_runtime.JSX.Element;
+declare const Code: ({ as, children, tone, variant, className, ...props }: CodeProps) => react_jsx_runtime.JSX.Element;
+
+interface CodeExampleProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    code: string;
+}
+declare const CodeExample: ({ code, className, ...props }: CodeExampleProps) => react_jsx_runtime.JSX.Element | null;
+
+interface ComponentGuidelinesProps {
+    whenToUse?: string[];
+    whenNotToUse?: string[];
+    bestPractices?: string[];
+    accessibility?: string[];
+}
+declare const ComponentGuidelines: ({ whenToUse, whenNotToUse, bestPractices, accessibility, }: ComponentGuidelinesProps) => react_jsx_runtime.JSX.Element | null;
+
+export { type DateRangePickerOverlay as $, Accordion as A, Badge as B, Carousel as C, type ContextMenuItem as D, type ContextMenuProps as E, Cover as F, type CoverAlign as G, type CoverAs as H, type CoverProps as I, type CoverSize as J, type CoverSurface as K, type CoverTextVariant as L, type CoverVariant as M, Currency as N, CurrencySymbol as O, DataGrid as P, type DataGridColumn as Q, type DataGridProps as R, type SortDirection as S, type SortState as T, type DateRange as U, DateRangeField as V, type DateRangeFieldProps as W, type DateRangeFieldUi as X, DateRangePicker as Y, type DateRangePickerCalendar as Z, type DateRangePickerConstraints as _, AlertBanner as a, type MapCardProps as a$, type DateRangePickerProps as a0, DecodeTranslation as a1, Divider as a2, Drawer as a3, type DrawerProps as a4, EmbeddedVideo as a5, type EmbeddedVideoProps as a6, EmptyState as a7, ExpandablePanel as a8, FileUpload as a9, type GridGap as aA, GridItem as aB, type GridItemProps as aC, type GridJustify as aD, type GridProps as aE, type Responsive as aF, H1 as aG, H2 as aH, H3 as aI, InfiniteList as aJ, type InfiniteListProps as aK, Input as aL, Kbd as aM, type KbdProps as aN, type KbdSize as aO, type KbdVariant as aP, Lead as aQ, LineGraph as aR, type LineGraphProps as aS, Link as aT, type LinkIntent as aU, type LinkProps as aV, type LinkSize as aW, type LinkTone as aX, type LinkUnderline as aY, type LinkVariant as aZ, MapCard as a_, type FileUploadProps as aa, type FileUploadRejectReason as ab, FilterBar as ac, Form as ad, FormField as ae, FormWizard as af, type FormWizardBehavior as ag, type FormWizardFormConfig as ah, type FormWizardI18n as ai, type FormWizardLabels as aj, type FormWizardLayout as ak, type FormWizardProps as al, type FormWizardState as am, type FormWizardStateConfig as an, type FormWizardStudioProps as ao, GameCanvas2D as ap, Graph as aq, type GraphAxisConfig as ar, type GraphDatum as as, type GraphIntent as at, type GraphProps as au, type GraphSeries as av, Grid as aw, type GridAlign as ax, type GridAutoRows as ay, type GridCols as az, Avatar as b, type TypographyVariant as b$, Muted as b0, Pagination as b1, Popin as b2, type PopinMaxSize as b3, type PopinProps as b4, Portal as b5, type PortalProps as b6, Product as b7, Progress as b8, Radio as b9, _default as bA, Tag as bB, type TagIntent as bC, type TagProps as bD, type TagSize as bE, type TagVariant as bF, Text as bG, Textarea as bH, Toast as bI, ToastContainer as bJ, Tooltip as bK, type TooltipProps as bL, Tree as bM, type TreeAppearanceConfig as bN, type TreeBehaviorConfig as bO, type TreeCheckedConfig as bP, type TreeExpandedConfig as bQ, type TreeId as bR, type TreeItem as bS, type TreeProps as bT, type TreeSelectionConfig as bU, Typography as bV, type TypographyLeading as bW, type TypographyProps as bX, type TypographySize as bY, type TypographyTone as bZ, type TypographyTracking as b_, RadioField as ba, type RadioFieldProps as bb, RadioGroup as bc, type RadioGroupProps as bd, type RadioOption as be, type RadioProps as bf, ScrollReveal as bg, type ScrollRevealProps as bh, Select as bi, Skeleton as bj, Slider as bk, type SliderIntent as bl, type SliderProps as bm, type SliderSize as bn, type Step as bo, StepForm as bp, type StepFormAlign as bq, type StepFormFormProps as br, type StepFormProps as bs, type StepFormSize as bt, type StepFormStudioProps as bu, type StepFormVariant as bv, Stepper as bw, type StepperProps as bx, Switch as by, Table as bz, BarGraph as c, type TypographyWeight as c0, type WizardStepBase as c1, type WizardStepId as c2, type GameAPI as c3, type AlertBannerProps as c4, type CarouselProps as c5, type GameCanvas2DProps as c6, type FormFieldProps as c7, type ToastContainerProps as c8, type DecodeTranslationProps as c9, type LeadProps as cA, type CodeProps as cB, type ExpandablePanelProps as ca, type EmptyStateProps as cb, type FilterBarProps as cc, type AccordionProps as cd, type FormProps as ce, type PaginationProps as cf, type ProductProps as cg, type TableProps as ch, type TabsProps as ci, type ToastProps as cj, type BadgeProps as ck, type AvatarProps as cl, type CheckboxProps as cm, type ContainerProps as cn, type DividerProps as co, type InputProps as cp, type ProgressProps as cq, type SelectProps as cr, type SkeletonProps as cs, type SwitchProps as ct, type TextareaProps as cu, type H1Props as cv, type H2Props as cw, type H3Props as cx, type TextProps as cy, type MutedProps as cz, type BarGraphProps as d, Breadcrumb as e, type BreadcrumbItem as f, type BreadcrumbProps as g, Button as h, type ButtonIntent as i, type ButtonProps as j, type ButtonSize as k, type ButtonVariant as l, Checkbox as m, Code as n, CodeExample as o, type CodeExampleProps as p, Combobox as q, type ComboboxOption as r, type ComboboxProps as s, type CommandItem as t, CommandPalette as u, type CommandPaletteProps as v, ComponentGuidelines as w, type ComponentGuidelinesProps as x, Container as y, ContextMenu as z };