@kismet-ux/constellation 1.9.0 → 1.11.0

package/dist/index-Cknm9FUU.d.ts

@@ -0,0 +1,299 @@
+import * as React from 'react';
+import React__default from 'react';
+import { d as SidebarSection, S as SidebarNavItem, B as BreadcrumbItemData, c as NavUserProps } from './nav-user-CJIcWKyY.js';
+import { R as RowProps } from './row-CuhTBQhK.js';
+import { I as Input } from './input-Cp5LET5i.js';
+import { b as TooltipContent, B as Button } from './tooltip-91Nq_Hl8.js';
+import { VariantProps } from 'class-variance-authority';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+
+interface ColumnProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children?: React__default.ReactNode;
+    el?: React__default.ElementType<React__default.HTMLAttributes<HTMLDivElement>>;
+    gap?: number;
+    full?: boolean;
+    fullHeight?: boolean;
+    align?: 'start' | 'center' | 'end';
+    flex?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+}
+
+interface ContainerProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children?: React__default.ReactNode;
+    el?: React__default.ElementType<React__default.HTMLAttributes<HTMLDivElement>>;
+    styled?: boolean;
+    direction?: 'column' | 'row';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly';
+    full?: boolean;
+    rounded?: boolean | 'extra';
+    outlined?: boolean;
+    /** A border colour outside the theme scale; pairs with `outlined`. */
+    color?: string;
+    theme?: 'primary' | 'secondary' | 'success' | 'destructive' | 'warning' | 'info' | 'slate' | 'light-slate';
+    elevation?: number;
+    padding?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 'xl' | 'lg' | 'md' | 'sm' | 'none';
+    darkMode?: boolean;
+    gap?: number;
+    /**
+     * Draw one edge in `color` as a thick rule.
+     *
+     * A card that belongs to a category — an aisle, a shelf, a queue — reads
+     * faster with a coloured edge than with a full outline in the same hue,
+     * because the edge is a mark and the outline is a box. Pairs with `color`.
+     */
+    accent?: 'left' | 'right' | 'top' | 'bottom';
+    /** Colour for the `accent` edge. Falls back to `color`, then the divider. */
+    accentColor?: string;
+    /**
+     * Cap the content width and centre it.
+     *
+     * `text` for a column of prose, `content` for ordinary forms and lists,
+     * `wide` for dense work that earns the room. A CSS length is accepted for
+     * the case the scale does not cover. Without it a container simply fills its
+     * parent, which is right until the parent is a very large screen.
+     */
+    measure?: 'text' | 'content' | 'wide' | 'full' | (string & {});
+    /**
+     * Fade the container in shortly after mount.
+     *
+     * Off by default. Only sensible for something that appears once — a hero
+     * panel, an empty state. Anything that repeats or is toggled should not use
+     * it: the container renders invisible until the timer fires.
+     */
+    appear?: boolean;
+}
+
+type GridColumns = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+interface GridProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children?: React__default.ReactNode;
+    /** Number of columns (1–12). Default: 1. */
+    columns?: GridColumns;
+    /** Responsive column overrides. Each breakpoint sets the column count at that width and above. */
+    sm?: GridColumns;
+    md?: GridColumns;
+    lg?: GridColumns;
+    xl?: GridColumns;
+    /** Gap between items (0–12, maps to --size-N tokens). Default: 2. */
+    gap?: number;
+    /**
+     * A minimum track width — `repeat(auto-fit, minmax(<min>, 1fr))`.
+     *
+     * For a grid whose column COUNT is not the interesting question: "these
+     * boxes hold one word each, fit as many as will read" is a statement about
+     * the content, and it reflows without naming a breakpoint. Takes precedence
+     * over `columns` and the responsive overrides, which it replaces.
+     */
+    min?: string;
+    /**
+     * With `min`, keep empty tracks instead of collapsing them (`auto-fill`
+     * rather than `auto-fit`).
+     *
+     * The difference only shows when the items do not fill the row. A grid of
+     * CARDS wants this: one card in an aisle should stay card-sized, not stretch
+     * to the full width. A grid of form FIELDS wants the default, where two
+     * fields share the row rather than leaving a hole.
+     */
+    fill?: boolean;
+    /**
+     * Pack items by height instead of by row, so a short item does not leave a
+     * hole under a tall neighbour.
+     *
+     * Implemented with CSS multi-column, which is the only masonry that works
+     * everywhere today — `grid-template-rows: masonry` is still behind a flag.
+     * The trade is reading order: items flow DOWN each column and then across,
+     * rather than left to right. For a list already grouped and sorted that is
+     * fine; for anything where "the next one" must sit to the right, it is not.
+     *
+     * Pairs with `min`, which sets the column width.
+     */
+    masonry?: boolean;
+    /**
+     * Animate children to their new positions instead of letting them jump.
+     *
+     * Wires up FLIP (see `useFlip`). Worth it wherever the layout reflows on its
+     * own — a masonry that restacks when the window narrows, or a card that
+     * pushes its neighbours down as it expands. Respects
+     * the app's motion preference (`useMotion`), which defaults to
+     * `prefers-reduced-motion`.
+     */
+    animate?: boolean;
+    /** Horizontal alignment of items within cells. */
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    /** Vertical alignment of items within cells. */
+    justify?: 'start' | 'center' | 'end' | 'stretch';
+    /** Whether the grid fills its parent width. */
+    full?: boolean;
+    /** Semantic HTML element to render. Default: div. */
+    el?: React__default.ElementType<React__default.HTMLAttributes<HTMLDivElement>>;
+}
+
+type SidebarVariant = 'sidebar' | 'floating' | 'inset';
+type SidebarContextValue = {
+    state: 'expanded' | 'collapsed';
+    open: boolean;
+    setOpen: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    isMobile: boolean;
+    openMobile: boolean;
+    setOpenMobile: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    toggleSidebar: () => void;
+    variant: SidebarVariant;
+    setVariant: React__default.Dispatch<React__default.SetStateAction<SidebarVariant>>;
+};
+
+declare function AppContent({ children, className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+
+interface AppContentBandProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The element to render. Defaults to `header` / `footer` respectively. */
+    el?: React.ElementType<React.HTMLAttributes<HTMLDivElement>>;
+}
+/**
+ * The band at the top of a content area, pinned while the page scrolls.
+ *
+ * Opaque on purpose: it paints over the content passing beneath it, and a
+ * translucent one shows the list sliding through the title.
+ */
+declare function AppContentHeader({ children, className, el, sticky, ...props }: AppContentBandProps & {
+    sticky?: boolean;
+}): React.JSX.Element;
+/**
+ * The band at the foot of a content area — a search field, a toolbar, the
+ * action that commits the page.
+ *
+ * Sticky, not fixed: fixed is measured against the viewport, so in an app with
+ * a sidebar the band runs underneath it and has to be inset by hand for every
+ * layout the sidebar can be in. Sticky is measured against this content area,
+ * which is where it belongs, and it costs real space at the end of the scroll
+ * instead of needing the page padded to clear it.
+ */
+declare function AppContentFooter({ children, className, el, ...props }: AppContentBandProps): React.JSX.Element;
+
+interface AppFooterProps {
+    brand: string;
+    links: {
+        label: string;
+        href: string;
+    }[];
+}
+declare function AppFooter({ brand, links }: AppFooterProps): React.JSX.Element;
+
+interface AppShellProps {
+    children: React.ReactNode;
+    /**
+     * Initial sidebar state. Persist this server-side (cookie, session) or in
+     * localStorage and pass it in, so the sidebar doesn't flash open on load.
+     */
+    defaultSidebarOpen?: boolean;
+}
+declare function AppShell({ children, defaultSidebarOpen }: AppShellProps): React.JSX.Element;
+
+interface AppSidebarProps {
+    logo: React.ReactNode;
+    homeHref?: string;
+    currentPath?: string;
+    linkComponent?: React.ElementType;
+    sections: SidebarSection[];
+    footerItems?: SidebarNavItem[];
+    footerSeparator?: boolean;
+    children?: React.ReactNode;
+}
+declare function AppSidebar({ logo, homeHref, currentPath, linkComponent, sections, footerItems, footerSeparator, children, }: AppSidebarProps): React.JSX.Element;
+
+interface AppSidebarHeaderProps {
+    breadcrumbs?: BreadcrumbItemData[];
+    /** Omit to hide the account menu (e.g. on signed-out chrome). */
+    user?: NavUserProps['user'];
+    userMenu?: Omit<NavUserProps, 'user'>;
+    /** Extra controls between the appearance toggle and the account menu. */
+    actions?: React.ReactNode;
+    sticky?: boolean;
+}
+declare function AppSidebarHeader({ breadcrumbs, user, userMenu, actions, sticky }: AppSidebarHeaderProps): React.JSX.Element;
+
+interface CollapseProps extends React.HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    /** Transition length in ms. Also how long the unmount is deferred. */
+    duration?: number;
+    /**
+     * Unmount children once the close animation finishes. Keeps focus traps,
+     * `autoFocus` and dismiss handlers out of the tree while the panel is shut.
+     * Set `false` to keep children mounted — cheaper for a panel toggled often,
+     * and required if they hold state you need to survive a close.
+     */
+    unmountOnClose?: boolean;
+}
+/**
+ * A panel that animates its own height, so content below slides rather than
+ * jumping.
+ *
+ * Uses `grid-template-rows: 0fr → 1fr` rather than animating `max-height`: it
+ * interpolates to the panel's real height, so there is no magic number to
+ * guess and no pause at the end when the guess was too generous.
+ */
+declare const Collapse: React.ForwardRefExoticComponent<CollapseProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Column: React.FC<ColumnProps>;
+
+declare const Container: React.ForwardRefExoticComponent<ContainerProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Grid: React.ForwardRefExoticComponent<GridProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Row: React.FC<RowProps>;
+
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React.ComponentProps<'div'> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: React.Dispatch<React.SetStateAction<boolean>>;
+}): React.JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React.ComponentProps<'div'> & {
+    side?: 'left' | 'right';
+    variant?: SidebarVariant;
+    collapsible?: 'offcanvas' | 'icon' | 'none';
+}): React.JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+declare function SidebarRail({ className, ...props }: React.ComponentProps<'button'>): React.JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarInput({ className, ...props }: React.ComponentProps<typeof Input>): React.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarGroupLabel({ className, asChild, ...props }: React.ComponentProps<'div'> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React.ComponentProps<'button'> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<'ul'>): React.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<'li'>): React.JSX.Element;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React.ComponentProps<'button'> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): React.JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React.ComponentProps<'button'> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): React.JSX.Element;
+declare function SidebarMenuBadge({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React.ComponentProps<'div'> & {
+    showIcon?: boolean;
+}): React.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React.ComponentProps<'ul'>): React.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React.ComponentProps<'li'>): React.JSX.Element;
+declare function SidebarMenuSubButton({ asChild, size, isActive, tooltip, className, ...props }: React.ComponentProps<'a'> & {
+    asChild?: boolean;
+    size?: 'sm' | 'md';
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+}): React.JSX.Element;
+
+declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+
+export { AppContent as A, SidebarInput as B, Collapse as C, SidebarInset as D, SidebarMenu as E, SidebarMenuAction as F, Grid as G, SidebarMenuBadge as H, SidebarMenuButton as I, SidebarMenuItem as J, SidebarMenuSkeleton as K, SidebarMenuSub as L, SidebarMenuSubButton as M, SidebarMenuSubItem as N, SidebarProvider as O, SidebarRail as P, SidebarTrigger as Q, Row as R, Skeleton as U, AppContentFooter as b, AppContentHeader as c, AppFooter as d, AppShell as f, AppSidebar as h, AppSidebarHeader as i, Column as m, Container as o, Sidebar as s, SidebarContent as t, SidebarFooter as u, SidebarGroup as v, SidebarGroupAction as w, SidebarGroupContent as x, SidebarGroupLabel as y, SidebarHeader as z };
+export type { SidebarContextValue as S, SidebarVariant as T, AppContentBandProps as a, AppFooterProps as e, AppShellProps as g, AppSidebarHeaderProps as j, AppSidebarProps as k, CollapseProps as l, ColumnProps as n, ContainerProps as p, GridColumns as q, GridProps as r };

package/dist/index-Clv3CnXv.d.ts

@@ -0,0 +1,184 @@
+import * as React from 'react';
+import React__default from 'react';
+import { a as InputBaseProps } from './input-Cp5LET5i.js';
+import { VariantProps } from 'class-variance-authority';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+
+type DatePickerProps = {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    label?: React__default.ReactNode;
+    helperText?: React__default.ReactNode;
+    error?: boolean;
+    disabled?: boolean;
+    sizeVariant?: 'sm' | 'md';
+    placeholder?: string;
+    min?: string;
+    max?: string;
+    required?: boolean;
+    id?: string;
+    className?: string;
+    name?: string;
+};
+
+type SelectAlign = 'start' | 'center' | 'end';
+type SelectSide = 'top' | 'bottom' | 'left' | 'right';
+type SelectPosition = 'item-aligned' | 'popper';
+type SelectProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    children?: React__default.ReactNode;
+};
+type SelectContentProps = React__default.HTMLAttributes<HTMLDivElement> & {
+    position?: SelectPosition;
+    align?: SelectAlign;
+    side?: SelectSide;
+    sideOffset?: number;
+    collisionPadding?: number;
+};
+type SelectFieldContentProps = Pick<SelectContentProps, 'align' | 'className' | 'collisionPadding' | 'side' | 'sideOffset'>;
+type SelectFieldBaseProps = Omit<SelectProps, 'value' | 'defaultValue' | 'onValueChange'> & {
+    'aria-required'?: boolean;
+    label?: React__default.ReactNode;
+    helperText?: React__default.ReactNode;
+    error?: boolean;
+    placeholder?: string;
+    fieldClassName?: string;
+    contentProps?: SelectFieldContentProps;
+    id?: string;
+    children?: React__default.ReactNode;
+    sizeVariant?: 'sm' | 'md';
+    searchThreshold?: number;
+};
+type SingleSelectFieldProps = SelectFieldBaseProps & {
+    multiple?: false;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type MultiSelectFieldProps = SelectFieldBaseProps & {
+    multiple: true;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+type SelectFieldProps = SingleSelectFieldProps | MultiSelectFieldProps;
+
+type FormTheme = 'inherit' | 'primary' | 'secondary' | 'destructive' | 'warning' | 'success' | 'info' | 'slate';
+
+type CheckedState = boolean | 'indeterminate';
+interface CheckboxProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'value' | 'defaultValue' | 'defaultChecked'> {
+    theme?: FormTheme;
+    destructive?: boolean;
+    checked?: CheckedState;
+    defaultChecked?: CheckedState;
+    onCheckedChange?: (checked: CheckedState) => void;
+    value?: string;
+    name?: string;
+    required?: boolean;
+    /** Optional inline label rendered to the right of the checkbox and associated via htmlFor. */
+    label?: React.ReactNode;
+    /** Optional helper / validation text rendered beneath the checkbox + label row. */
+    helperText?: React.ReactNode;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface ComboboxOption {
+    /** The value written back on selection. */
+    value: string;
+    /** What the row shows. Falls back to `value`. */
+    label?: string;
+    /** Trailing muted text — a category, a count, a unit. */
+    hint?: string;
+    /** Heading this option files under. Ungrouped options render first. */
+    group?: string;
+}
+interface ComboboxProps extends InputBaseProps, Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'list'> {
+    options: ComboboxOption[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    /**
+     * Whether a value absent from `options` is allowed. Default true — this
+     * replaces a `<datalist>`, whose whole point is that typing a new one is how
+     * the vocabulary grows.
+     */
+    allowCustom?: boolean;
+    /** Shown when the filter matches nothing. */
+    emptyText?: string;
+    /** Cap on rows rendered at once. */
+    maxVisible?: number;
+}
+/**
+ * Free-text field with a suggestion list.
+ *
+ * This exists because `<datalist>` does not hold up: Chrome only reliably opens
+ * it once the user types or presses ArrowDown — a click on the field does
+ * nothing, so it reads as broken — and nothing about the popup can be styled,
+ * so it arrives as OS chrome hanging off an otherwise themed field.
+ *
+ * The panel is Select's `Surface` and Select's stylesheet, deliberately: a
+ * lookalike built from its own rules drifts the moment either is touched.
+ */
+declare function Combobox({ options, value, onValueChange, allowCustom, emptyText, maxVisible, onKeyDown, onFocus, onBlur, className, ...inputProps }: ComboboxProps): React.JSX.Element;
+
+declare function DatePicker({ value: valueProp, defaultValue, onChange, label, helperText, error, disabled, sizeVariant, placeholder, min, max, required, id, className, name, }: DatePickerProps): React.JSX.Element;
+
+declare const labelVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    theme?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
+    theme?: FormTheme;
+}
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+
+type SurfaceProps = {
+    align?: SelectAlign;
+    children: React.ReactNode;
+    className?: string;
+    collisionPadding?: number;
+    contentRef: React.MutableRefObject<HTMLDivElement | null>;
+    displayOpen: boolean;
+    isClosing?: boolean;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    open: boolean;
+    position?: SelectPosition;
+    side?: SelectSide;
+    sideOffset?: number;
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'className' | 'onKeyDown'>;
+declare function Surface({ align, children, className, collisionPadding, contentRef, displayOpen, isClosing, onKeyDown, open, position, side, sideOffset, triggerRef, ...props }: SurfaceProps): React.ReactPortal | null;
+declare function Select({ open: openProp, defaultOpen, onOpenChange, value: valueProp, defaultValue, onValueChange, disabled, children, ...props }: SelectProps): React.JSX.Element;
+/**
+ * A titled run of options — the `<optgroup>` of this select.
+ *
+ * The heading is presentational and never focusable: it names the run, it is
+ * not a thing you can pick. Labelling the group with `aria-label` rather than
+ * pointing at the heading keeps it out of the option list for a screen reader
+ * too.
+ */
+declare function SelectGroup({ label, children, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+}): React.JSX.Element;
+declare function SelectValue({ children, placeholder, ...props }: React.HTMLAttributes<HTMLSpanElement> & {
+    placeholder?: React.ReactNode;
+}): React.JSX.Element;
+declare function SelectTrigger({ className, children, onClick, onKeyDown, type, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement>): React.JSX.Element;
+declare function SelectContent({ align, className, children, collisionPadding, onKeyDown, position, side, sideOffset, ...props }: SelectContentProps): React.JSX.Element;
+declare function SelectItem({ className, children, disabled, onClick, onMouseMove, value, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+}): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare function SelectField(props: SelectFieldProps): React.JSX.Element;
+
+export { Checkbox as C, DatePicker as D, Label as L, Select as S, Combobox as b, SelectContent as h, SelectField as j, SelectGroup as l, SelectItem as m, SelectSeparator as p, SelectTrigger as r, SelectValue as s, Surface as t };
+export type { FormTheme as F, CheckboxProps as a, ComboboxOption as c, ComboboxProps as d, DatePickerProps as e, LabelProps as f, SelectAlign as g, SelectContentProps as i, SelectFieldProps as k, SelectPosition as n, SelectProps as o, SelectSide as q };