@devalok/shilp-sutra 0.1.0 → 0.2.0

package/dist/primitives/react-menubar.d.ts

@@ -0,0 +1,115 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _radix_ui_react_context from './_internal/react-context';
+import { Scope } from './_internal/react-context';
+import * as React from 'react';
+import * as MenuPrimitive from './react-menu';
+import * as RovingFocusGroup from './react-roving-focus';
+import { Primitive } from './_internal/react-primitive';
+
+type ScopedProps<P> = P & {
+    __scopeMenubar?: Scope;
+};
+declare const createMenubarScope: _radix_ui_react_context.CreateScope;
+type RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof RovingFocusGroup.Root>;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface MenubarProps extends PrimitiveDivProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    loop?: RovingFocusGroupProps['loop'];
+    dir?: RovingFocusGroupProps['dir'];
+}
+declare const Menubar: React.ForwardRefExoticComponent<MenubarProps & React.RefAttributes<HTMLDivElement>>;
+interface MenubarMenuProps {
+    value?: string;
+    children?: React.ReactNode;
+}
+declare const MenubarMenu: {
+    (props: ScopedProps<MenubarMenuProps>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface MenubarTriggerProps extends PrimitiveButtonProps {
+}
+declare const MenubarTrigger: React.ForwardRefExoticComponent<MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type MenuPortalProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Portal>;
+interface MenubarPortalProps extends MenuPortalProps {
+}
+declare const MenubarPortal: React.FC<MenubarPortalProps>;
+type MenuContentProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Content>;
+interface MenubarContentProps extends Omit<MenuContentProps, 'onEntryFocus'> {
+}
+declare const MenubarContent: React.ForwardRefExoticComponent<MenubarContentProps & React.RefAttributes<HTMLDivElement>>;
+type MenuGroupProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Group>;
+interface MenubarGroupProps extends MenuGroupProps {
+}
+declare const MenubarGroup: React.ForwardRefExoticComponent<MenubarGroupProps & React.RefAttributes<HTMLDivElement>>;
+type MenuLabelProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Label>;
+interface MenubarLabelProps extends MenuLabelProps {
+}
+declare const MenubarLabel: React.ForwardRefExoticComponent<MenubarLabelProps & React.RefAttributes<HTMLDivElement>>;
+type MenuItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Item>;
+interface MenubarItemProps extends MenuItemProps {
+}
+declare const MenubarItem: React.ForwardRefExoticComponent<MenubarItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuCheckboxItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.CheckboxItem>;
+interface MenubarCheckboxItemProps extends MenuCheckboxItemProps {
+}
+declare const MenubarCheckboxItem: React.ForwardRefExoticComponent<MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuRadioGroupProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.RadioGroup>;
+interface MenubarRadioGroupProps extends MenuRadioGroupProps {
+}
+declare const MenubarRadioGroup: React.ForwardRefExoticComponent<MenubarRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+type MenuRadioItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.RadioItem>;
+interface MenubarRadioItemProps extends MenuRadioItemProps {
+}
+declare const MenubarRadioItem: React.ForwardRefExoticComponent<MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuItemIndicatorProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.ItemIndicator>;
+interface MenubarItemIndicatorProps extends MenuItemIndicatorProps {
+}
+declare const MenubarItemIndicator: React.ForwardRefExoticComponent<MenubarItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+type MenuSeparatorProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Separator>;
+interface MenubarSeparatorProps extends MenuSeparatorProps {
+}
+declare const MenubarSeparator: React.ForwardRefExoticComponent<MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+type MenuArrowProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Arrow>;
+interface MenubarArrowProps extends MenuArrowProps {
+}
+declare const MenubarArrow: React.ForwardRefExoticComponent<MenubarArrowProps & React.RefAttributes<SVGSVGElement>>;
+interface MenubarSubProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+}
+declare const MenubarSub: React.FC<MenubarSubProps>;
+type MenuSubTriggerProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.SubTrigger>;
+interface MenubarSubTriggerProps extends MenuSubTriggerProps {
+}
+declare const MenubarSubTrigger: React.ForwardRefExoticComponent<MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+type MenuSubContentProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.SubContent>;
+interface MenubarSubContentProps extends MenuSubContentProps {
+}
+declare const MenubarSubContent: React.ForwardRefExoticComponent<MenubarSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.ForwardRefExoticComponent<MenubarProps & React.RefAttributes<HTMLDivElement>>;
+declare const Menu: {
+    (props: ScopedProps<MenubarMenuProps>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const Trigger: React.ForwardRefExoticComponent<MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal: React.FC<MenubarPortalProps>;
+declare const Content: React.ForwardRefExoticComponent<MenubarContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group: React.ForwardRefExoticComponent<MenubarGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label: React.ForwardRefExoticComponent<MenubarLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<MenubarItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem: React.ForwardRefExoticComponent<MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: React.ForwardRefExoticComponent<MenubarRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem: React.ForwardRefExoticComponent<MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<MenubarItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator: React.ForwardRefExoticComponent<MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<MenubarArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const Sub: React.FC<MenubarSubProps>;
+declare const SubTrigger: React.ForwardRefExoticComponent<MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent: React.ForwardRefExoticComponent<MenubarSubContentProps & React.RefAttributes<HTMLDivElement>>;
+
+export { Arrow, CheckboxItem, Content, Group, Item, ItemIndicator, Label, Menu, Menubar, MenubarArrow, type MenubarArrowProps, MenubarCheckboxItem, type MenubarCheckboxItemProps, MenubarContent, type MenubarContentProps, MenubarGroup, type MenubarGroupProps, MenubarItem, MenubarItemIndicator, type MenubarItemIndicatorProps, type MenubarItemProps, MenubarLabel, type MenubarLabelProps, MenubarMenu, type MenubarMenuProps, MenubarPortal, type MenubarPortalProps, type MenubarProps, MenubarRadioGroup, type MenubarRadioGroupProps, MenubarRadioItem, type MenubarRadioItemProps, MenubarSeparator, type MenubarSeparatorProps, MenubarSub, MenubarSubContent, type MenubarSubContentProps, type MenubarSubProps, MenubarSubTrigger, type MenubarSubTriggerProps, MenubarTrigger, type MenubarTriggerProps, Portal, RadioGroup, RadioItem, Root, Separator, Sub, SubContent, SubTrigger, Trigger, createMenubarScope };

package/dist/primitives/react-navigation-menu.d.ts

@@ -0,0 +1,126 @@
+import * as _radix_ui_react_context from './_internal/react-context';
+import { Scope } from './_internal/react-context';
+import * as React from 'react';
+import { Primitive } from './_internal/react-primitive';
+import { DismissableLayer } from './_internal/react-dismissable-layer';
+import * as VisuallyHiddenPrimitive from './react-visually-hidden';
+
+type Orientation = 'vertical' | 'horizontal';
+type Direction = 'ltr' | 'rtl';
+declare const createNavigationMenuScope: _radix_ui_react_context.CreateScope;
+type NavigationMenuElement = React.ComponentRef<typeof Primitive.nav>;
+type PrimitiveNavProps = React.ComponentPropsWithoutRef<typeof Primitive.nav>;
+interface NavigationMenuProps extends Omit<NavigationMenuProviderProps, keyof NavigationMenuProviderPrivateProps>, PrimitiveNavProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    dir?: Direction;
+    orientation?: Orientation;
+    /**
+     * The duration from when the pointer enters the trigger until the tooltip gets opened.
+     * @defaultValue 200
+     */
+    delayDuration?: number;
+    /**
+     * How much time a user has to enter another trigger without incurring a delay again.
+     * @defaultValue 300
+     */
+    skipDelayDuration?: number;
+}
+declare const NavigationMenu: React.ForwardRefExoticComponent<NavigationMenuProps & React.RefAttributes<HTMLElement>>;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface NavigationMenuSubProps extends Omit<NavigationMenuProviderProps, keyof NavigationMenuProviderPrivateProps>, PrimitiveDivProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: Orientation;
+}
+declare const NavigationMenuSub: React.ForwardRefExoticComponent<NavigationMenuSubProps & React.RefAttributes<HTMLDivElement>>;
+interface NavigationMenuProviderPrivateProps {
+    isRootMenu: boolean;
+    scope: Scope;
+    children: React.ReactNode;
+    orientation: Orientation;
+    dir: Direction;
+    rootNavigationMenu: NavigationMenuElement | null;
+    value: string;
+    onTriggerEnter(itemValue: string): void;
+    onTriggerLeave?(): void;
+    onContentEnter?(): void;
+    onContentLeave?(): void;
+    onItemSelect(itemValue: string): void;
+    onItemDismiss(): void;
+}
+interface NavigationMenuProviderProps extends NavigationMenuProviderPrivateProps {
+}
+type PrimitiveUnorderedListProps = React.ComponentPropsWithoutRef<typeof Primitive.ul>;
+interface NavigationMenuListProps extends PrimitiveUnorderedListProps {
+}
+declare const NavigationMenuList: React.ForwardRefExoticComponent<NavigationMenuListProps & React.RefAttributes<HTMLUListElement>>;
+type FocusProxyElement = React.ComponentRef<typeof VisuallyHiddenPrimitive.Root>;
+type PrimitiveListItemProps = React.ComponentPropsWithoutRef<typeof Primitive.li>;
+interface NavigationMenuItemProps extends PrimitiveListItemProps {
+    value?: string;
+}
+declare const NavigationMenuItem: React.ForwardRefExoticComponent<NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+type NavigationMenuTriggerElement = React.ComponentRef<typeof Primitive.button>;
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface NavigationMenuTriggerProps extends PrimitiveButtonProps {
+}
+declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type PrimitiveLinkProps = React.ComponentPropsWithoutRef<typeof Primitive.a>;
+interface NavigationMenuLinkProps extends Omit<PrimitiveLinkProps, 'onSelect'> {
+    active?: boolean;
+    onSelect?: (event: Event) => void;
+}
+declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+interface NavigationMenuIndicatorProps extends NavigationMenuIndicatorImplProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+interface NavigationMenuIndicatorImplProps extends PrimitiveDivProps {
+}
+interface NavigationMenuContentProps extends Omit<NavigationMenuContentImplProps, keyof NavigationMenuContentImplPrivateProps> {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const NavigationMenuContent: React.ForwardRefExoticComponent<NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+type DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
+interface NavigationMenuContentImplPrivateProps {
+    value: string;
+    triggerRef: React.RefObject<NavigationMenuTriggerElement | null>;
+    focusProxyRef: React.RefObject<FocusProxyElement | null>;
+    wasEscapeCloseRef: React.MutableRefObject<boolean>;
+    onContentFocusOutside(): void;
+    onRootContentClose(): void;
+}
+interface NavigationMenuContentImplProps extends Omit<DismissableLayerProps, 'onDismiss' | 'disableOutsidePointerEvents'>, NavigationMenuContentImplPrivateProps {
+}
+interface NavigationMenuViewportProps extends Omit<NavigationMenuViewportImplProps, 'activeContentValue'> {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const NavigationMenuViewport: React.ForwardRefExoticComponent<NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>>;
+interface NavigationMenuViewportImplProps extends PrimitiveDivProps {
+}
+declare const Root: React.ForwardRefExoticComponent<NavigationMenuProps & React.RefAttributes<HTMLElement>>;
+declare const Sub: React.ForwardRefExoticComponent<NavigationMenuSubProps & React.RefAttributes<HTMLDivElement>>;
+declare const List: React.ForwardRefExoticComponent<NavigationMenuListProps & React.RefAttributes<HTMLUListElement>>;
+declare const Item: React.ForwardRefExoticComponent<NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+declare const Trigger: React.ForwardRefExoticComponent<NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Link: React.ForwardRefExoticComponent<NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const Indicator: React.ForwardRefExoticComponent<NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content: React.ForwardRefExoticComponent<NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport: React.ForwardRefExoticComponent<NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>>;
+
+export { Content, Indicator, Item, Link, List, NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuIndicator, type NavigationMenuIndicatorProps, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, NavigationMenuList, type NavigationMenuListProps, type NavigationMenuProps, NavigationMenuSub, type NavigationMenuSubProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, NavigationMenuViewport, type NavigationMenuViewportProps, Root, Sub, Trigger, Viewport, createNavigationMenuScope };

package/dist/primitives/react-popover.d.ts

@@ -0,0 +1,85 @@
+import * as _radix_ui_react_context from './_internal/react-context';
+import * as React from 'react';
+import { DismissableLayer } from './_internal/react-dismissable-layer';
+import { FocusScope } from './_internal/react-focus-scope';
+import * as PopperPrimitive from './_internal/react-popper';
+import { Portal as Portal$1 } from './_internal/react-portal';
+import { Primitive } from './_internal/react-primitive';
+
+declare const createPopoverScope: _radix_ui_react_context.CreateScope;
+interface PopoverProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+}
+declare const Popover: React.FC<PopoverProps>;
+type PopperAnchorProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Anchor>;
+interface PopoverAnchorProps extends PopperAnchorProps {
+}
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface PopoverTriggerProps extends PrimitiveButtonProps {
+}
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type PortalProps = React.ComponentPropsWithoutRef<typeof Portal$1>;
+interface PopoverPortalProps {
+    children?: React.ReactNode;
+    /**
+     * Specify a container element to portal the content into.
+     */
+    container?: PortalProps['container'];
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const PopoverPortal: React.FC<PopoverPortalProps>;
+interface PopoverContentProps extends PopoverContentTypeProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+interface PopoverContentTypeProps extends Omit<PopoverContentImplProps, 'trapFocus' | 'disableOutsidePointerEvents'> {
+}
+type FocusScopeProps = React.ComponentPropsWithoutRef<typeof FocusScope>;
+type DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
+type PopperContentProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Content>;
+interface PopoverContentImplProps extends Omit<PopperContentProps, 'onPlaced'>, Omit<DismissableLayerProps, 'onDismiss'> {
+    /**
+     * Whether focus should be trapped within the `Popover`
+     * (default: false)
+     */
+    trapFocus?: FocusScopeProps['trapped'];
+    /**
+     * Event handler called when auto-focusing on open.
+     * Can be prevented.
+     */
+    onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
+}
+interface PopoverCloseProps extends PrimitiveButtonProps {
+}
+declare const PopoverClose: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+type PopperArrowProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Arrow>;
+interface PopoverArrowProps extends PopperArrowProps {
+}
+declare const PopoverArrow: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const Root: React.FC<PopoverProps>;
+declare const Anchor: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Trigger: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal: React.FC<PopoverPortalProps>;
+declare const Content: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Close: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<SVGSVGElement>>;
+
+export { Anchor, Arrow, Close, Content, Popover, PopoverAnchor, type PopoverAnchorProps, PopoverArrow, type PopoverArrowProps, PopoverClose, type PopoverCloseProps, PopoverContent, type PopoverContentProps, PopoverPortal, type PopoverPortalProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Portal, Root, Trigger, createPopoverScope };

package/dist/primitives/react-progress.d.ts

@@ -0,0 +1,19 @@
+import * as _radix_ui_react_context from './_internal/react-context';
+import * as React from 'react';
+import { Primitive } from './_internal/react-primitive';
+
+declare const createProgressScope: _radix_ui_react_context.CreateScope;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface ProgressProps extends PrimitiveDivProps {
+    value?: number | null | undefined;
+    max?: number;
+    getValueLabel?(value: number, max: number): string;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+interface ProgressIndicatorProps extends PrimitiveDivProps {
+}
+declare const ProgressIndicator: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+declare const Indicator: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+
+export { Indicator, Progress, ProgressIndicator, type ProgressIndicatorProps, type ProgressProps, Root, createProgressScope };

package/dist/primitives/react-radio-group.d.ts

@@ -0,0 +1,58 @@
+import * as _radix_ui_react_context from './_internal/react-context';
+import * as React from 'react';
+import { Primitive } from './_internal/react-primitive';
+import * as RovingFocusGroup from './react-roving-focus';
+
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface RadioProps$1 extends PrimitiveButtonProps {
+    checked?: boolean;
+    required?: boolean;
+    onCheck?(): void;
+}
+declare const Radio: React.ForwardRefExoticComponent<RadioProps$1 & React.RefAttributes<HTMLButtonElement>>;
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+interface RadioIndicatorProps$1 extends PrimitiveSpanProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const RadioIndicator: React.ForwardRefExoticComponent<RadioIndicatorProps$1 & React.RefAttributes<HTMLSpanElement>>;
+
+declare const createRadioGroupScope: _radix_ui_react_context.CreateScope;
+type RadioGroupContextValue = {
+    name?: string;
+    required: boolean;
+    disabled: boolean;
+    value: string | null;
+    onValueChange(value: string): void;
+};
+type RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof RovingFocusGroup.Root>;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface RadioGroupProps extends PrimitiveDivProps {
+    name?: RadioGroupContextValue['name'];
+    required?: React.ComponentPropsWithoutRef<typeof Radio>['required'];
+    disabled?: React.ComponentPropsWithoutRef<typeof Radio>['disabled'];
+    dir?: RovingFocusGroupProps['dir'];
+    orientation?: RovingFocusGroupProps['orientation'];
+    loop?: RovingFocusGroupProps['loop'];
+    defaultValue?: string;
+    value?: string | null;
+    onValueChange?: RadioGroupContextValue['onValueChange'];
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+type RadioProps = React.ComponentPropsWithoutRef<typeof Radio>;
+interface RadioGroupItemProps extends Omit<RadioProps, 'onCheck' | 'name'> {
+    value: string;
+}
+declare const RadioGroupItem: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+type RadioIndicatorProps = React.ComponentPropsWithoutRef<typeof RadioIndicator>;
+interface RadioGroupIndicatorProps extends RadioIndicatorProps {
+}
+declare const RadioGroupIndicator: React.ForwardRefExoticComponent<RadioGroupIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Root: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Indicator: React.ForwardRefExoticComponent<RadioGroupIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+
+export { Indicator, Item, RadioGroup, RadioGroupIndicator, type RadioGroupIndicatorProps, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, Root, createRadioGroupScope };

package/dist/primitives/react-roving-focus.d.ts

@@ -0,0 +1,49 @@
+import * as _radix_ui_react_context from './_internal/react-context';
+import * as React from 'react';
+import { Primitive } from './_internal/react-primitive';
+
+declare const createRovingFocusGroupScope: _radix_ui_react_context.CreateScope;
+type Orientation = React.AriaAttributes['aria-orientation'];
+type Direction = 'ltr' | 'rtl';
+interface RovingFocusGroupOptions {
+    /**
+     * The orientation of the group.
+     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     */
+    orientation?: Orientation;
+    /**
+     * The direction of navigation between items.
+     */
+    dir?: Direction;
+    /**
+     * Whether keyboard navigation should loop around
+     * @defaultValue false
+     */
+    loop?: boolean;
+}
+interface RovingFocusGroupProps extends RovingFocusGroupImplProps {
+}
+declare const RovingFocusGroup: React.ForwardRefExoticComponent<RovingFocusGroupProps & React.RefAttributes<HTMLDivElement>>;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface RovingFocusGroupImplProps extends Omit<PrimitiveDivProps, 'dir'>, RovingFocusGroupOptions {
+    currentTabStopId?: string | null;
+    defaultCurrentTabStopId?: string;
+    onCurrentTabStopIdChange?: (tabStopId: string | null) => void;
+    onEntryFocus?: (event: Event) => void;
+    preventScrollOnEntryFocus?: boolean;
+}
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+interface RovingFocusItemProps extends Omit<PrimitiveSpanProps, 'children'> {
+    tabStopId?: string;
+    focusable?: boolean;
+    active?: boolean;
+    children?: React.ReactNode | ((props: {
+        hasTabStop: boolean;
+        isCurrentTabStop: boolean;
+    }) => React.ReactNode);
+}
+declare const RovingFocusGroupItem: React.ForwardRefExoticComponent<RovingFocusItemProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Root: React.ForwardRefExoticComponent<RovingFocusGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<RovingFocusItemProps & React.RefAttributes<HTMLSpanElement>>;
+
+export { Item, Root, RovingFocusGroup, RovingFocusGroupItem, type RovingFocusGroupProps, type RovingFocusItemProps, createRovingFocusGroupScope };

package/dist/primitives/react-select.d.ts

@@ -0,0 +1,137 @@
+import * as _radix_ui_react_context from './_internal/react-context';
+import * as React from 'react';
+import { DismissableLayer } from './_internal/react-dismissable-layer';
+import { FocusScope } from './_internal/react-focus-scope';
+import * as PopperPrimitive from './_internal/react-popper';
+import { Portal as Portal$1 } from './_internal/react-portal';
+import { Primitive } from './_internal/react-primitive';
+
+type Direction = 'ltr' | 'rtl';
+declare const createSelectScope: _radix_ui_react_context.CreateScope;
+interface SelectSharedProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+    dir?: Direction;
+    name?: string;
+    autoComplete?: string;
+    disabled?: boolean;
+    required?: boolean;
+    form?: string;
+}
+type SelectProps = SelectSharedProps & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?(value: string): void;
+};
+declare const Select: React.FC<SelectProps>;
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface SelectTriggerProps extends PrimitiveButtonProps {
+}
+declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+interface SelectValueProps extends Omit<PrimitiveSpanProps, 'placeholder'> {
+    placeholder?: React.ReactNode;
+}
+declare const SelectValue: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+interface SelectIconProps extends PrimitiveSpanProps {
+}
+declare const SelectIcon: React.ForwardRefExoticComponent<SelectIconProps & React.RefAttributes<HTMLSpanElement>>;
+type PortalProps = React.ComponentPropsWithoutRef<typeof Portal$1>;
+interface SelectPortalProps {
+    children?: React.ReactNode;
+    /**
+     * Specify a container element to portal the content into.
+     */
+    container?: PortalProps['container'];
+}
+declare const SelectPortal: React.FC<SelectPortalProps>;
+interface SelectContentProps extends SelectContentImplProps {
+}
+declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+type DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
+type FocusScopeProps = React.ComponentPropsWithoutRef<typeof FocusScope>;
+type SelectPopperPrivateProps = {
+    onPlaced?: PopperContentProps['onPlaced'];
+};
+interface SelectContentImplProps extends Omit<SelectPopperPositionProps, keyof SelectPopperPrivateProps>, Omit<SelectItemAlignedPositionProps, keyof SelectPopperPrivateProps> {
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
+    /**
+     * Event handler called when the escape key is down.
+     * Can be prevented.
+     */
+    onEscapeKeyDown?: DismissableLayerProps['onEscapeKeyDown'];
+    /**
+     * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    onPointerDownOutside?: DismissableLayerProps['onPointerDownOutside'];
+    position?: 'item-aligned' | 'popper';
+}
+interface SelectItemAlignedPositionProps extends PrimitiveDivProps, SelectPopperPrivateProps {
+}
+type PopperContentProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Content>;
+interface SelectPopperPositionProps extends PopperContentProps, SelectPopperPrivateProps {
+}
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface SelectViewportProps extends PrimitiveDivProps {
+    nonce?: string;
+}
+declare const SelectViewport: React.ForwardRefExoticComponent<SelectViewportProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectGroupProps extends PrimitiveDivProps {
+}
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectLabelProps extends PrimitiveDivProps {
+}
+declare const SelectLabel: React.ForwardRefExoticComponent<SelectLabelProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectItemProps extends PrimitiveDivProps {
+    value: string;
+    disabled?: boolean;
+    textValue?: string;
+}
+declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectItemTextProps extends PrimitiveSpanProps {
+}
+declare const SelectItemText: React.ForwardRefExoticComponent<SelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
+interface SelectItemIndicatorProps extends PrimitiveSpanProps {
+}
+declare const SelectItemIndicator: React.ForwardRefExoticComponent<SelectItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+interface SelectScrollUpButtonProps extends Omit<SelectScrollButtonImplProps, 'onAutoScroll'> {
+}
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectScrollDownButtonProps extends Omit<SelectScrollButtonImplProps, 'onAutoScroll'> {
+}
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectScrollButtonImplProps extends PrimitiveDivProps {
+    onAutoScroll(): void;
+}
+interface SelectSeparatorProps extends PrimitiveDivProps {
+}
+declare const SelectSeparator: React.ForwardRefExoticComponent<SelectSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+type PopperArrowProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Arrow>;
+interface SelectArrowProps extends PopperArrowProps {
+}
+declare const SelectArrow: React.ForwardRefExoticComponent<SelectArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const Root: React.FC<SelectProps>;
+declare const Trigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Value: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Icon: React.ForwardRefExoticComponent<SelectIconProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Portal: React.FC<SelectPortalProps>;
+declare const Content: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport: React.ForwardRefExoticComponent<SelectViewportProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group: React.ForwardRefExoticComponent<SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label: React.ForwardRefExoticComponent<SelectLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemText: React.ForwardRefExoticComponent<SelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<SelectItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ScrollUpButton: React.ForwardRefExoticComponent<SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollDownButton: React.ForwardRefExoticComponent<SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>>;
+declare const Separator: React.ForwardRefExoticComponent<SelectSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<SelectArrowProps & React.RefAttributes<SVGSVGElement>>;
+
+export { Arrow, Content, Group, Icon, Item, ItemIndicator, ItemText, Label, Portal, Root, ScrollDownButton, ScrollUpButton, Select, SelectArrow, type SelectArrowProps, SelectContent, type SelectContentProps, SelectGroup, type SelectGroupProps, SelectIcon, type SelectIconProps, SelectItem, SelectItemIndicator, type SelectItemIndicatorProps, type SelectItemProps, SelectItemText, type SelectItemTextProps, SelectLabel, type SelectLabelProps, SelectPortal, type SelectPortalProps, type SelectProps, SelectScrollDownButton, type SelectScrollDownButtonProps, SelectScrollUpButton, type SelectScrollUpButtonProps, SelectSeparator, type SelectSeparatorProps, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, SelectViewport, type SelectViewportProps, Separator, Trigger, Value, Viewport, createSelectScope };

package/dist/primitives/react-separator.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { Primitive } from './_internal/react-primitive';
+
+declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
+type Orientation = (typeof ORIENTATIONS)[number];
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface SeparatorProps extends PrimitiveDivProps {
+    /**
+     * Either `vertical` or `horizontal`. Defaults to `horizontal`.
+     */
+    orientation?: Orientation;
+    /**
+     * Whether or not the component is purely decorative. When true, accessibility-related attributes
+     * are updated so that that the rendered element is removed from the accessibility tree.
+     */
+    decorative?: boolean;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+export { Root, Separator, type SeparatorProps };