@mechane-ai/elements 0.0.0-stage → 0.4.1

package/dist/packages/foundations/src/style-composition.d.ts

@@ -0,0 +1,22 @@
+import type { StyleXStyles } from '@stylexjs/stylex';
+import type { CSSProperties } from 'react';
+type PlacementProperties = Pick<CSSProperties, 'alignSelf' | 'flex' | 'flexGrow' | 'flexShrink' | 'gridArea' | 'gridColumn' | 'gridRow' | 'margin' | 'marginBlock' | 'marginInline' | 'marginBlockStart' | 'marginBlockEnd' | 'marginInlineStart' | 'marginInlineEnd' | 'marginTop' | 'marginRight' | 'marginBottom' | 'marginLeft' | 'width' | 'maxWidth' | 'minWidth'>;
+type ControlGeometry = Pick<CSSProperties, 'height' | 'minHeight' | 'maxHeight' | 'padding' | 'paddingBlock' | 'paddingInline' | 'paddingTop' | 'paddingRight' | 'paddingBottom' | 'paddingLeft' | 'borderRadius' | 'justifyContent' | 'alignItems' | 'gap'>;
+type DefinedProperties<Properties> = {
+    readonly [Key in keyof Properties]?: Exclude<Properties[Key], undefined>;
+};
+export type PlacementStyle = StyleXStyles<DefinedProperties<PlacementProperties>>;
+export type ControlStyle = StyleXStyles<DefinedProperties<PlacementProperties & ControlGeometry>>;
+type StyleProperties<State> = {
+    readonly className?: string | ((state: State) => string | undefined) | undefined;
+    readonly style?: CSSProperties | ((state: State) => CSSProperties | undefined) | undefined;
+};
+type CompiledStyles = {
+    readonly className?: string | undefined;
+    readonly style?: CSSProperties | undefined;
+};
+type MergeStylesInput<State> = StyleProperties<State> & {
+    readonly styles: CompiledStyles;
+};
+export declare function mergeStyles<State>({ className, style, styles }: MergeStylesInput<State>): StyleProperties<State>;
+export {};

package/dist/packages/foundations/src/theme.d.ts

@@ -0,0 +1,16 @@
+export declare const themeProps: {
+    readonly light: Readonly<{
+        className?: string;
+        'data-style-src'?: string;
+        style?: Readonly<{
+            [$$Key$$: string]: string | number;
+        }>;
+    }>;
+    readonly dark: Readonly<{
+        className?: string;
+        'data-style-src'?: string;
+        style?: Readonly<{
+            [$$Key$$: string]: string | number;
+        }>;
+    }>;
+};

package/dist/packages/foundations/src/tokens.stylex.d.ts

@@ -0,0 +1,143 @@
+import * as stylex from '@stylexjs/stylex';
+export declare const colors: stylex.VarGroup<Readonly<{
+    canvas: string;
+    surface: string;
+    ink: string;
+    inkHover: string;
+    inverse: string;
+    muted: string;
+    faint: string;
+    line: string;
+    focus: string;
+    accent: string;
+    accentSoft: string;
+    warning: string;
+    warningSoft: string;
+    danger: string;
+    dangerHover: string;
+    dangerSoft: string;
+    overlay: string;
+}>, symbol>;
+export declare const darkColors: {
+    canvas: string;
+    surface: string;
+    ink: string;
+    inkHover: string;
+    inverse: string;
+    muted: string;
+    faint: string;
+    line: string;
+    focus: string;
+    accent: string;
+    accentSoft: string;
+    warning: string;
+    warningSoft: string;
+    danger: string;
+    dangerHover: string;
+    dangerSoft: string;
+    overlay: string;
+};
+export declare const chartColors: stylex.VarGroup<Readonly<{
+    series1: string;
+    series2: string;
+    series3: string;
+    series4: string;
+    series5: string;
+    series6: string;
+    negative: string;
+    positive: string;
+    missing: string;
+}>, symbol>;
+export declare const darkChartColors: {
+    series1: string;
+    series2: string;
+    series3: string;
+    series4: string;
+    series5: string;
+    series6: string;
+    negative: string;
+    positive: string;
+    missing: string;
+};
+export declare const syntaxColors: stylex.VarGroup<Readonly<{
+    keyword: string;
+    string: string;
+    comment: string;
+    number: string;
+    type: string;
+}>, symbol>;
+export declare const darkSyntaxColors: {
+    keyword: string;
+    string: string;
+    comment: string;
+    number: string;
+    type: string;
+};
+export declare const spacing: stylex.VarGroup<Readonly<{
+    xxs: string;
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    xxl: string;
+}>, symbol>;
+export declare const typography: stylex.VarGroup<Readonly<{
+    fontFamily: string;
+    monoFamily: string;
+    bodySize: string;
+    bodyLineHeight: string;
+    multilineLineHeight: string;
+    captionSize: string;
+    captionLineHeight: string;
+    inputSize: string;
+    touchInputSize: string;
+    sectionSize: string;
+    sectionLineHeight: string;
+    headingSize: string;
+    headingLineHeight: string;
+    compactHeadingSize: string;
+    compactHeadingLineHeight: string;
+    headingTracking: string;
+}>, symbol>;
+export declare const controls: stylex.VarGroup<Readonly<{
+    smHeight: string;
+    mdHeight: string;
+    coarseTarget: string;
+    iconSize: string;
+    paddingInline: string;
+    paddingBlock: string;
+    gap: string;
+    focusWidth: string;
+    disabledOpacity: string;
+}>, symbol>;
+export declare const radii: stylex.VarGroup<Readonly<{
+    sm: string;
+    md: string;
+}>, symbol>;
+export declare const motion: stylex.VarGroup<Readonly<{
+    duration: string;
+    easing: string;
+    drawerDuration: string;
+    drawerEasing: string;
+}>, symbol>;
+export declare const shadows: stylex.VarGroup<Readonly<{
+    popup: string;
+}>, symbol>;
+export declare const darkShadows: {
+    popup: string;
+};
+export declare const layers: {
+    backdrop: string;
+    dialog: string;
+    popup: string;
+    tooltip: string;
+    skipLink: string;
+};
+export declare const conditions: {
+    coarsePointer: string;
+    hoverPointer: string;
+    compactText: string;
+    compactTable: string;
+    reducedMotion: string;
+};

package/dist/packages/layout/src/app-shell.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+type AppShellProps = {
+    readonly sidebarHeader?: ReactNode;
+    readonly sidebar: ReactNode;
+    readonly footer?: ReactNode;
+    readonly children: ReactNode;
+};
+export declare function AppShell({ sidebarHeader, sidebar, footer, children }: AppShellProps): ReactNode;
+export {};

package/dist/packages/layout/src/detail-page.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+type DetailPageProps = {
+    readonly children: ReactNode;
+};
+export declare function DetailPage({ children }: DetailPageProps): ReactNode;
+export {};

package/dist/packages/layout/src/frame.stylex.d.ts

@@ -0,0 +1,23 @@
+import * as stylex from '@stylexjs/stylex';
+export declare const frame: stylex.VarGroup<Readonly<{
+    sidebarWidth: string;
+    toolbarHeight: string;
+    navigationHeight: string;
+    navigationInset: string;
+    navigationPadding: string;
+    footerHeight: string;
+    footerPadding: string;
+    detailWidth: string;
+    detailMaxWidth: string;
+    detailTop: string;
+    detailBottom: string;
+    detailMobileTop: string;
+    detailMobileBottom: string;
+}>, symbol>;
+export declare const frameConditions: {
+    sidebarMobile: string;
+    sidebarDesktopQuery: string;
+    sidebarCoarse: string;
+    detailMobile: string;
+    toolbarCompact: string;
+};

package/dist/packages/layout/src/index.d.ts

@@ -0,0 +1,6 @@
+export { AppShell } from './app-shell.tsx';
+export { DetailPage } from './detail-page.tsx';
+export { PageToolbar, ToolbarAction } from './page-toolbar.tsx';
+export type { ResizableRootProps, ResizablePaneProps, ResizableHandleProps } from './resizable.tsx';
+export { Resizable } from './resizable.tsx';
+export { Navigation, NavigationItem, NavigationLink, SidebarLabel, SidebarFooter } from './sidebar.tsx';

package/dist/packages/layout/src/page-toolbar.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentProps, ReactNode } from 'react';
+import { Button } from '../../core/src/index.ts';
+type PageToolbarProps = {
+    readonly title: ReactNode;
+    readonly actions?: ReactNode;
+    readonly breadcrumb?: boolean;
+    readonly navigation?: boolean;
+};
+type ToolbarActionProps = Omit<ComponentProps<typeof Button>, 'variant' | 'size' | 'xstyle'> & {
+    readonly icon?: ReactNode;
+};
+export declare function PageToolbar({ title, actions, breadcrumb, navigation }: PageToolbarProps): ReactNode;
+export declare function ToolbarAction({ icon, children, ...props }: ToolbarActionProps): ReactNode;
+export {};

package/dist/packages/layout/src/resizable.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentProps, ReactNode } from 'react';
+export type ResizableRootProps = {
+    readonly orientation?: 'horizontal' | 'vertical';
+    readonly initialSizes?: Readonly<Record<string, number>>;
+    readonly onSizesChange?: (sizes: Readonly<Record<string, number>>) => void;
+    readonly disabled?: boolean;
+} & Omit<ComponentProps<'div'>, 'onChange' | 'defaultValue'>;
+export type ResizablePaneProps = {
+    readonly id: string;
+    readonly initialSizePercent?: number;
+    readonly minimumSizePercent?: number;
+    readonly maximumSizePercent?: number;
+    readonly collapsible?: boolean;
+} & Omit<ComponentProps<'div'>, 'id' | 'onResize'>;
+export type ResizableHandleProps = {
+    readonly 'aria-label': string;
+    readonly 'disabled'?: boolean;
+} & Omit<ComponentProps<'div'>, 'children'>;
+declare function ResizableRoot({ orientation, initialSizes, onSizesChange, disabled, ref, ...props }: ResizableRootProps): ReactNode;
+declare function ResizablePane({ id, initialSizePercent, minimumSizePercent, maximumSizePercent, collapsible, ref, ...props }: ResizablePaneProps): ReactNode;
+declare function ResizableHandle({ ref, ...props }: ResizableHandleProps): ReactNode;
+export declare const Resizable: {
+    Root: typeof ResizableRoot;
+    Pane: typeof ResizablePane;
+    Handle: typeof ResizableHandle;
+};
+export {};

package/dist/packages/layout/src/sidebar.d.ts

@@ -0,0 +1,46 @@
+import type { ComponentProps, ReactNode, RefObject } from 'react';
+import { Button } from '../../core/src/index.ts';
+import { Drawer } from '../../overlays/src/index.ts';
+type SidebarState = {
+    readonly isExpanded: boolean;
+    readonly sidebarId: string;
+    readonly drawerHandle: ReturnType<typeof Drawer.createHandle>;
+    readonly navigationToggleRef: RefObject<HTMLButtonElement | null>;
+    readonly onToggle: () => void;
+    readonly onNavigate: () => void;
+};
+export declare const SidebarContext: import("react").Context<SidebarState | null>;
+type SidebarProps = {
+    readonly header?: ReactNode;
+    readonly footer?: ReactNode;
+    readonly close?: ReactNode;
+    readonly children: ReactNode;
+};
+type NavigationProps = {
+    readonly children: ReactNode;
+    readonly label?: string;
+};
+type NavigationItemProps = Omit<ComponentProps<typeof Button>, 'variant' | 'tone' | 'size' | 'xstyle'> & {
+    readonly icon?: ReactNode;
+    readonly selected?: boolean;
+};
+type NavigationLinkProps = ComponentProps<'a'> & {
+    readonly icon?: ReactNode;
+    readonly selected?: boolean;
+};
+type SidebarLabelProps = {
+    readonly children: ReactNode;
+    readonly grow?: boolean;
+};
+type SidebarFooterProps = {
+    readonly children: ReactNode;
+};
+export declare function Sidebar({ header, footer, close, children }: SidebarProps): ReactNode;
+export declare function SidebarClose(): ReactNode;
+export declare function Navigation({ children, label }: NavigationProps): ReactNode;
+export declare function NavigationItem({ children, icon, selected, onClick, ...props }: NavigationItemProps): ReactNode;
+export declare function NavigationLink({ children, icon, selected, onClick, className, style, ...props }: NavigationLinkProps): ReactNode;
+export declare function SidebarLabel({ children, grow }: SidebarLabelProps): ReactNode;
+export declare function SidebarFooter({ children }: SidebarFooterProps): ReactNode;
+export declare function SidebarToggle(): ReactNode;
+export {};

package/dist/packages/navigation/src/commands/command.d.ts

@@ -0,0 +1,37 @@
+import type { ReactElement, ReactNode, RefObject } from 'react';
+export type CommandShortcut = {
+    readonly key: string;
+    readonly mod?: boolean;
+    readonly ctrl?: boolean;
+    readonly alt?: boolean;
+    readonly shift?: boolean;
+    readonly meta?: boolean;
+};
+export type CommandAction = {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+    readonly shortcut?: CommandShortcut;
+    readonly disabled?: boolean;
+    readonly onSelect: () => void;
+};
+export type CommandShortcutsOptions = {
+    readonly commands: ReadonlyArray<CommandAction>;
+    readonly target: RefObject<HTMLElement | null> | HTMLElement | null;
+    readonly enabled: boolean;
+};
+export declare function useCommandShortcuts({ commands, target, enabled }: CommandShortcutsOptions): void;
+export type ShortcutHintProps = {
+    readonly shortcut: CommandShortcut;
+};
+export declare function ShortcutHint({ shortcut }: ShortcutHintProps): ReactNode;
+export type CommandPaletteProps = {
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    readonly title: string;
+    readonly commands: ReadonlyArray<CommandAction>;
+    readonly trigger?: ReactElement;
+    readonly placeholder?: string;
+    readonly empty?: string;
+};
+export declare function CommandPalette({ open, onOpenChange, title, commands, trigger, placeholder, empty, }: CommandPaletteProps): ReactNode;

package/dist/packages/navigation/src/commands/index.d.ts

@@ -0,0 +1,2 @@
+export type { CommandShortcut, CommandAction, CommandShortcutsOptions, ShortcutHintProps, CommandPaletteProps, } from './command.tsx';
+export { useCommandShortcuts, ShortcutHint, CommandPalette } from './command.tsx';

package/dist/packages/navigation/src/index.d.ts

@@ -0,0 +1,3 @@
+export { Kbd, Breadcrumb } from './navigation.tsx';
+export { SkipLink } from './skip-link.tsx';
+export { Tabs } from './tabs.tsx';

package/dist/packages/navigation/src/navigation.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentProps, ReactNode } from 'react';
+type BreadcrumbRootProps = Omit<ComponentProps<'nav'>, 'aria-label'> & {
+    readonly 'aria-label': string;
+};
+type BreadcrumbListProps = ComponentProps<'ol'>;
+type BreadcrumbItemProps = ComponentProps<'li'>;
+type BreadcrumbCurrentProps = ComponentProps<'span'>;
+type KbdProps = Omit<ComponentProps<'kbd'>, 'children'> & {
+    readonly children: string;
+};
+declare function BreadcrumbRoot(props: BreadcrumbRootProps): ReactNode;
+declare function BreadcrumbList(props: BreadcrumbListProps): ReactNode;
+declare function BreadcrumbItem(props: BreadcrumbItemProps): ReactNode;
+declare function BreadcrumbCurrent(props: BreadcrumbCurrentProps): ReactNode;
+declare function BreadcrumbSeparator(): ReactNode;
+export declare function Kbd(props: KbdProps): ReactNode;
+export declare const Breadcrumb: {
+    Root: typeof BreadcrumbRoot;
+    List: typeof BreadcrumbList;
+    Item: typeof BreadcrumbItem;
+    Current: typeof BreadcrumbCurrent;
+    Separator: typeof BreadcrumbSeparator;
+};
+export {};

package/dist/packages/navigation/src/skip-link.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentProps, ReactNode } from 'react';
+type SkipLinkProps = Omit<ComponentProps<'a'>, 'href'> & {
+    readonly href: string;
+};
+export declare function SkipLink(props: SkipLinkProps): ReactNode;
+export {};

package/dist/packages/navigation/src/tabs.d.ts

@@ -0,0 +1,19 @@
+import { Tabs as BaseTabs } from '@base-ui/react/tabs';
+import type { ComponentProps, ReactNode } from 'react';
+import type { ValueStateProperties } from '../../foundations/src/control-state.ts';
+type BaseTabsRootProps = ComponentProps<typeof BaseTabs.Root>;
+type TabsRootProps = Omit<BaseTabsRootProps, 'value' | 'defaultValue' | 'onValueChange'> & ValueStateProperties<Exclude<BaseTabsRootProps['value'], undefined>, NonNullable<BaseTabsRootProps['onValueChange']>>;
+type TabsListProps = ComponentProps<typeof BaseTabs.List>;
+type TabsTabProps = ComponentProps<typeof BaseTabs.Tab>;
+type TabsPanelProps = ComponentProps<typeof BaseTabs.Panel>;
+declare function TabsRoot({ className, style, ...props }: TabsRootProps): ReactNode;
+declare function TabsList({ className, style, ...props }: TabsListProps): ReactNode;
+declare function TabsTab({ className, style, ...props }: TabsTabProps): ReactNode;
+declare function TabsPanel({ className, style, ...props }: TabsPanelProps): ReactNode;
+export declare const Tabs: {
+    Root: typeof TabsRoot;
+    List: typeof TabsList;
+    Tab: typeof TabsTab;
+    Panel: typeof TabsPanel;
+};
+export {};

package/dist/packages/overlays/src/alert-dialog.d.ts

@@ -0,0 +1,18 @@
+import { AlertDialog as BaseAlertDialog } from '@base-ui/react/alert-dialog';
+import type { ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+type AlertDialogRootProps<Payload> = Omit<BaseAlertDialog.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseAlertDialog.Root.Props<Payload>['onOpenChange']>>;
+declare function AlertDialogRoot<Payload = unknown>(props: AlertDialogRootProps<Payload>): ReactNode;
+export declare const AlertDialog: {
+    Root: typeof AlertDialogRoot;
+    Trigger: BaseAlertDialog.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Backdrop: ({ className, style, ...props }: Omit<import("@base-ui/react").DialogBackdropProps, "ref"> & import("react").RefAttributes<HTMLDivElement>) => ReactNode;
+    Popup: ({ className, style, xstyle, ...props }: Omit<import("@base-ui/react").DialogPopupProps, "ref"> & import("react").RefAttributes<HTMLDivElement> & {
+        readonly xstyle?: import("../../foundations/src/style-composition.ts").PlacementStyle;
+    }) => ReactNode;
+    Title: ({ className, style, ...props }: Omit<import("@base-ui/react").DialogTitleProps, "ref"> & import("react").RefAttributes<HTMLHeadingElement>) => ReactNode;
+    Description: ({ className, style, ...props }: Omit<import("@base-ui/react").DialogDescriptionProps, "ref"> & import("react").RefAttributes<HTMLParagraphElement>) => ReactNode;
+    Close: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/packages/overlays/src/dialog.d.ts

@@ -0,0 +1,27 @@
+import { Dialog as BaseDialog } from '@base-ui/react/dialog';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+import type { PlacementStyle } from '../../foundations/src/style-composition.ts';
+type DialogRootProps<Payload> = Omit<BaseDialog.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseDialog.Root.Props<Payload>['onOpenChange']>>;
+type DialogBackdropProps = ComponentProps<typeof BaseDialog.Backdrop>;
+type DialogPopupProps = ComponentProps<typeof BaseDialog.Popup> & {
+    readonly xstyle?: PlacementStyle;
+};
+type DialogTitleProps = ComponentProps<typeof BaseDialog.Title>;
+type DialogDescriptionProps = ComponentProps<typeof BaseDialog.Description>;
+declare function DialogRoot<Payload = unknown>(props: DialogRootProps<Payload>): ReactNode;
+declare function DialogBackdrop({ className, style, ...props }: DialogBackdropProps): ReactNode;
+declare function DialogPopup({ className, style, xstyle, ...props }: DialogPopupProps): ReactNode;
+declare function DialogTitle({ className, style, ...props }: DialogTitleProps): ReactNode;
+declare function DialogDescription({ className, style, ...props }: DialogDescriptionProps): ReactNode;
+export declare const Dialog: {
+    Root: typeof DialogRoot;
+    Trigger: BaseDialog.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Backdrop: typeof DialogBackdrop;
+    Popup: typeof DialogPopup;
+    Title: typeof DialogTitle;
+    Description: typeof DialogDescription;
+    Close: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/packages/overlays/src/drawer.d.ts

@@ -0,0 +1,33 @@
+import { Drawer as BaseDrawer } from '@base-ui/react/drawer';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+import type { PlacementStyle } from '../../foundations/src/style-composition.ts';
+type DrawerRootProps<Payload> = Omit<BaseDrawer.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange' | 'swipeDirection' | 'snapPoints' | 'snapPoint' | 'defaultSnapPoint' | 'onSnapPointChange' | 'snapToSequentialPoints'> & OpenStateProperties<NonNullable<BaseDrawer.Root.Props<Payload>['onOpenChange']>>;
+type DrawerBackdropProps = ComponentProps<typeof BaseDrawer.Backdrop>;
+type DrawerViewportProps = ComponentProps<typeof BaseDrawer.Viewport>;
+type DrawerPopupProps = ComponentProps<typeof BaseDrawer.Popup> & {
+    readonly xstyle?: PlacementStyle;
+};
+type DrawerTitleProps = ComponentProps<typeof BaseDrawer.Title> & {
+    readonly visuallyHidden?: boolean;
+};
+type DrawerDescriptionProps = ComponentProps<typeof BaseDrawer.Description>;
+declare function DrawerRoot<Payload = unknown>(props: DrawerRootProps<Payload>): ReactNode;
+declare function DrawerBackdrop({ className, style, ...props }: DrawerBackdropProps): ReactNode;
+declare function DrawerViewport({ className, style, ...props }: DrawerViewportProps): ReactNode;
+declare function DrawerPopup({ className, style, xstyle, ...props }: DrawerPopupProps): ReactNode;
+declare function DrawerTitle({ className, style, visuallyHidden, ...props }: DrawerTitleProps): ReactNode;
+declare function DrawerDescription({ className, style, ...props }: DrawerDescriptionProps): ReactNode;
+export declare const Drawer: {
+    createHandle: typeof BaseDrawer.createHandle;
+    Root: typeof DrawerRoot;
+    Trigger: BaseDrawer.Trigger;
+    Portal: BaseDrawer.Portal;
+    Backdrop: typeof DrawerBackdrop;
+    Viewport: typeof DrawerViewport;
+    Popup: typeof DrawerPopup;
+    Title: typeof DrawerTitle;
+    Description: typeof DrawerDescription;
+    Close: BaseDrawer.Close;
+};
+export {};

package/dist/packages/overlays/src/index.d.ts

@@ -0,0 +1,7 @@
+export { AlertDialog } from './alert-dialog.tsx';
+export { Dialog } from './dialog.tsx';
+export { Drawer } from './drawer.tsx';
+export { Menu } from './menu.tsx';
+export { Popover } from './popover.tsx';
+export { Preview } from './preview.tsx';
+export { Tooltip } from './tooltip.tsx';

package/dist/packages/overlays/src/menu.d.ts

@@ -0,0 +1,51 @@
+import { Menu as BaseMenu } from '@base-ui/react/menu';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+type MenuRootProps<Payload> = Omit<BaseMenu.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseMenu.Root.Props<Payload>['onOpenChange']>>;
+type MenuPositionerProps = ComponentProps<typeof BaseMenu.Positioner>;
+type MenuPopupProps = ComponentProps<typeof BaseMenu.Popup>;
+type MenuItemProps = ComponentProps<typeof BaseMenu.Item>;
+type MenuLinkItemProps = ComponentProps<typeof BaseMenu.LinkItem>;
+type MenuGroupLabelProps = ComponentProps<typeof BaseMenu.GroupLabel>;
+type MenuSeparatorProps = ComponentProps<typeof BaseMenu.Separator>;
+type MenuCheckboxItemProps = Omit<ComponentProps<typeof BaseMenu.CheckboxItem>, 'checked' | 'defaultChecked' | 'onCheckedChange'> & {
+    readonly checked: boolean;
+    readonly onCheckedChange: NonNullable<BaseMenu.CheckboxItem.Props['onCheckedChange']>;
+};
+type MenuRadioGroupProps = Omit<ComponentProps<typeof BaseMenu.RadioGroup>, 'value' | 'defaultValue' | 'onValueChange'> & {
+    readonly value: string;
+    readonly onValueChange: NonNullable<BaseMenu.RadioGroup.Props['onValueChange']>;
+};
+type MenuRadioItemProps = ComponentProps<typeof BaseMenu.RadioItem>;
+type MenuSubmenuTriggerProps = ComponentProps<typeof BaseMenu.SubmenuTrigger>;
+type MenuSubmenuRootProps = Omit<BaseMenu.SubmenuRoot.Props, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseMenu.SubmenuRoot.Props['onOpenChange']>>;
+declare function MenuRoot<Payload = unknown>(props: MenuRootProps<Payload>): ReactNode;
+declare function MenuSubmenuRoot(props: MenuSubmenuRootProps): ReactNode;
+declare function MenuPositioner({ className, style, sideOffset, ...props }: MenuPositionerProps): ReactNode;
+declare function MenuPopup({ className, style, ...props }: MenuPopupProps): ReactNode;
+declare function MenuItem({ className, style, ...props }: MenuItemProps): ReactNode;
+declare function MenuLinkItem({ className, style, ...props }: MenuLinkItemProps): ReactNode;
+declare function MenuGroupLabel({ className, style, ...props }: MenuGroupLabelProps): ReactNode;
+declare function MenuSeparator({ className, style, ...props }: MenuSeparatorProps): ReactNode;
+declare function MenuCheckboxItem({ className, style, children, ...props }: MenuCheckboxItemProps): ReactNode;
+declare function MenuRadioGroup(props: MenuRadioGroupProps): ReactNode;
+declare function MenuRadioItem({ className, style, children, ...props }: MenuRadioItemProps): ReactNode;
+declare function MenuSubmenuTrigger({ className, style, ...props }: MenuSubmenuTriggerProps): ReactNode;
+export declare const Menu: {
+    Root: typeof MenuRoot;
+    Trigger: BaseMenu.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").MenuPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof MenuPositioner;
+    Popup: typeof MenuPopup;
+    Item: typeof MenuItem;
+    LinkItem: typeof MenuLinkItem;
+    Group: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").MenuGroupProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof MenuGroupLabel;
+    Separator: typeof MenuSeparator;
+    CheckboxItem: typeof MenuCheckboxItem;
+    RadioGroup: typeof MenuRadioGroup;
+    RadioItem: typeof MenuRadioItem;
+    SubmenuRoot: typeof MenuSubmenuRoot;
+    SubmenuTrigger: typeof MenuSubmenuTrigger;
+};
+export {};

package/dist/packages/overlays/src/popover.d.ts

@@ -0,0 +1,24 @@
+import { Popover as BasePopover } from '@base-ui/react/popover';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+type PopoverRootProps<Payload> = Omit<BasePopover.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BasePopover.Root.Props<Payload>['onOpenChange']>>;
+type PopoverPositionerProps = ComponentProps<typeof BasePopover.Positioner>;
+type PopoverPopupProps = ComponentProps<typeof BasePopover.Popup>;
+type PopoverTitleProps = ComponentProps<typeof BasePopover.Title>;
+type PopoverDescriptionProps = ComponentProps<typeof BasePopover.Description>;
+declare function PopoverRoot<Payload = unknown>(props: PopoverRootProps<Payload>): ReactNode;
+declare function PopoverPositioner({ className, style, sideOffset, ...props }: PopoverPositionerProps): ReactNode;
+declare function PopoverPopup({ className, style, ...props }: PopoverPopupProps): ReactNode;
+declare function PopoverTitle({ className, style, ...props }: PopoverTitleProps): ReactNode;
+declare function PopoverDescription({ className, style, ...props }: PopoverDescriptionProps): ReactNode;
+export declare const Popover: {
+    Root: typeof PopoverRoot;
+    Trigger: BasePopover.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").PopoverPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof PopoverPositioner;
+    Popup: typeof PopoverPopup;
+    Title: typeof PopoverTitle;
+    Description: typeof PopoverDescription;
+    Close: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").PopoverCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/packages/overlays/src/preview.d.ts

@@ -0,0 +1,17 @@
+import { PreviewCard as BasePreview } from '@base-ui/react/preview-card';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+type PreviewRootProps<Payload> = Omit<BasePreview.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BasePreview.Root.Props<Payload>['onOpenChange']>>;
+type PreviewPositionerProps = ComponentProps<typeof BasePreview.Positioner>;
+type PreviewPopupProps = ComponentProps<typeof BasePreview.Popup>;
+declare function PreviewRoot<Payload = unknown>(props: PreviewRootProps<Payload>): ReactNode;
+declare function PreviewPositioner({ className, style, sideOffset, ...props }: PreviewPositionerProps): ReactNode;
+declare function PreviewPopup({ className, style, ...props }: PreviewPopupProps): ReactNode;
+export declare const Preview: {
+    Root: typeof PreviewRoot;
+    Trigger: BasePreview.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").PreviewCardPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof PreviewPositioner;
+    Popup: typeof PreviewPopup;
+};
+export {};

package/dist/packages/overlays/src/tooltip.d.ts

@@ -0,0 +1,18 @@
+import { Tooltip as BaseTooltip } from '@base-ui/react/tooltip';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from '../../foundations/src/control-state.ts';
+type TooltipRootProps<Payload> = Omit<BaseTooltip.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseTooltip.Root.Props<Payload>['onOpenChange']>>;
+type TooltipPositionerProps = ComponentProps<typeof BaseTooltip.Positioner>;
+type TooltipPopupProps = ComponentProps<typeof BaseTooltip.Popup>;
+declare function TooltipRoot<Payload = unknown>(props: TooltipRootProps<Payload>): ReactNode;
+declare function TooltipPositioner({ className, style, sideOffset, ...props }: TooltipPositionerProps): ReactNode;
+declare function TooltipPopup({ className, style, ...props }: TooltipPopupProps): ReactNode;
+export declare const Tooltip: {
+    Provider: import("react").FC<import("@base-ui/react").TooltipProviderProps>;
+    Root: typeof TooltipRoot;
+    Trigger: BaseTooltip.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").TooltipPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof TooltipPositioner;
+    Popup: typeof TooltipPopup;
+};
+export {};