mainbase-ui 1.2.5 → 3.36.0

package/dist/types/components/radio-group/index.d.ts

@@ -0,0 +1,5 @@
+export { RadioGroupItem, RadioGroupItemControl, RadioGroupItemText, RadioGroupLabel, RadioGroupRoot, RadioGroupRootProvider, RadioGroupPropsProvider, RadioGroupItemIndicator, RadioGroupItemHiddenInput, RadioGroupContext, useRadioGroupStyles, } from "./radio-group";
+export type { RadioGroupItemControlProps, RadioGroupItemProps, RadioGroupItemTextProps, RadioGroupLabelProps, RadioGroupRootProps, RadioGroupRootProviderProps, RadioGroupValueChangeDetails, } from "./radio-group";
+export { useRadioGroup, useRadioGroupItemContext, useRadioGroupContext, } from "@ark-ui/react/radio-group";
+export type { UseRadioGroupProps, UseRadioGroupReturn, } from "@ark-ui/react/radio-group";
+export * as RadioGroup from "./namespace";

package/dist/types/components/radio-group/namespace.d.ts

@@ -0,0 +1,2 @@
+export { RadioGroupItem as Item, RadioGroupItemControl as ItemControl, RadioGroupItemText as ItemText, RadioGroupLabel as Label, RadioGroupRoot as Root, RadioGroupRootProvider as RootProvider, RadioGroupPropsProvider as PropsProvider, RadioGroupItemIndicator as ItemIndicator, RadioGroupContext as Context, RadioGroupItemContext as ItemContext, RadioGroupItemHiddenInput as ItemHiddenInput, } from "./radio-group";
+export type { RadioGroupItemControlProps as ItemControlProps, RadioGroupItemProps as ItemProps, RadioGroupItemTextProps as ItemTextProps, RadioGroupLabelProps as LabelProps, RadioGroupRootProps as RootProps, RadioGroupRootProviderProps as RootProviderProps, RadioGroupValueChangeDetails as ValueChangeDetails, } from "./radio-group";

package/dist/types/components/radio-group/radio-group.d.ts

@@ -0,0 +1,43 @@
+import type { Assign } from "@ark-ui/react";
+import { RadioGroup as ArkRadioGroup, type UseRadioGroupContext, type UseRadioGroupItemContext } from "@ark-ui/react/radio-group";
+import type { JSX } from "react";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useRadioGroupStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useRadioGroupStyles };
+export interface RadioGroupRootProviderBaseProps extends Assign<ArkRadioGroup.RootProviderBaseProps, SlotRecipeProps<"radioGroup">>, UnstyledProp {
+}
+export interface RadioGroupRootProviderProps extends HTMLMainbaseProps<"div", RadioGroupRootProviderBaseProps> {
+}
+export declare const RadioGroupRootProvider: import("react").ForwardRefExoticComponent<RadioGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RadioGroupRootBaseProps extends Assign<ArkRadioGroup.RootBaseProps, SlotRecipeProps<"radioGroup">>, UnstyledProp {
+}
+export interface RadioGroupRootProps extends HTMLMainbaseProps<"div", RadioGroupRootBaseProps> {
+}
+export declare const RadioGroupRoot: import("react").ForwardRefExoticComponent<RadioGroupRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const RadioGroupPropsProvider: React.Provider<RadioGroupRootBaseProps>;
+export interface RadioGroupLabelProps extends HTMLMainbaseProps<"div", ArkRadioGroup.LabelBaseProps>, UnstyledProp {
+}
+export declare const RadioGroupLabel: import("react").ForwardRefExoticComponent<RadioGroupLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RadioGroupItemProps extends HTMLMainbaseProps<"div", ArkRadioGroup.ItemBaseProps>, UnstyledProp {
+}
+export declare const RadioGroupItem: import("react").ForwardRefExoticComponent<RadioGroupItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RadioGroupItemTextProps extends HTMLMainbaseProps<"span", ArkRadioGroup.ItemTextBaseProps>, UnstyledProp {
+}
+export declare const RadioGroupItemText: import("react").ForwardRefExoticComponent<RadioGroupItemTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface RadioGroupItemControlProps extends HTMLMainbaseProps<"div", ArkRadioGroup.ItemControlBaseProps>, UnstyledProp {
+}
+export declare const RadioGroupItemControl: import("react").ForwardRefExoticComponent<RadioGroupItemControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RadioGroupItemIndicatorProps extends HTMLMainbaseProps<"span"> {
+}
+export declare const RadioGroupItemIndicator: import("react").ForwardRefExoticComponent<RadioGroupItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface RadioGroupContextProps {
+    children: (context: UseRadioGroupContext) => JSX.Element;
+}
+export declare const RadioGroupContext: React.FC<RadioGroupContextProps>;
+export interface RadioGroupItemContextProps {
+    children: (context: UseRadioGroupItemContext) => JSX.Element;
+}
+export declare const RadioGroupItemContext: React.FC<RadioGroupItemContextProps>;
+export declare const RadioGroupItemHiddenInput: import("react").ForwardRefExoticComponent<ArkRadioGroup.ItemHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface RadioGroupValueChangeDetails extends ArkRadioGroup.ValueChangeDetails {
+}

package/dist/types/components/radiomark/index.d.ts

@@ -0,0 +1,2 @@
+export { Radiomark } from "./radiomark";
+export type { RadiomarkProps } from "./radiomark";

package/dist/types/components/radiomark/radiomark.d.ts

@@ -0,0 +1,12 @@
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+export interface RadiomarkProps extends HTMLMainbaseProps<"span", RecipeProps<"radiomark">>, UnstyledProp {
+    /**
+     * Whether the checkmark is checked
+     */
+    checked?: boolean | undefined;
+    /**
+     * Whether the checkmark is disabled
+     */
+    disabled?: boolean | undefined;
+}
+export declare const Radiomark: import("react").ForwardRefExoticComponent<RadiomarkProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/types/components/rating-group/index.d.ts

@@ -0,0 +1,5 @@
+export { RatingGroupContext, RatingGroupControl, RatingGroupHiddenInput, RatingGroupItem, RatingGroupItemContext, RatingGroupItemIndicator, RatingGroupLabel, RatingGroupPropsProvider, RatingGroupRoot, RatingGroupRootProvider, RatingGroupItems, useRatingGroupStyles, } from "./rating-group";
+export type { RatingGroupControlProps, RatingGroupItemIndicatorProps, RatingGroupItemProps, RatingGroupItemsProps, RatingGroupLabelProps, RatingGroupRootProps, RatingGroupRootProviderProps, RatingGroupValueChangeDetails, RatingGroupHoverChangeDetails, } from "./rating-group";
+export { useRatingGroup, useRatingGroupContext, useRatingGroupItemContext, } from "@ark-ui/react/rating-group";
+export type { UseRatingGroupProps, UseRatingGroupReturn, } from "@ark-ui/react/rating-group";
+export * as RatingGroup from "./namespace";

package/dist/types/components/rating-group/namespace.d.ts

@@ -0,0 +1,2 @@
+export { RatingGroupControl as Control, RatingGroupItem as Item, RatingGroupItemIndicator as ItemIndicator, RatingGroupLabel as Label, RatingGroupRoot as Root, RatingGroupRootProvider as RootProvider, RatingGroupPropsProvider as PropsProvider, RatingGroupHiddenInput as HiddenInput, RatingGroupContext as Context, RatingGroupItemContext as ItemContext, RatingGroupItems as Items, useRatingGroupStyles, } from "./rating-group";
+export type { RatingGroupControlProps as ControlProps, RatingGroupItemProps as ItemProps, RatingGroupItemIndicatorProps as ItemIndicatorProps, RatingGroupLabelProps as LabelProps, RatingGroupItemsProps as ItemsProps, RatingGroupRootProps as RootProps, RatingGroupRootProviderProps as RootProviderProps, RatingGroupValueChangeDetails as ValueChangeDetails, RatingGroupHoverChangeDetails as HoverChangeDetails, } from "./rating-group";

package/dist/types/components/rating-group/rating-group.d.ts

@@ -0,0 +1,39 @@
+import type { Assign } from "@ark-ui/react";
+import { RatingGroup as ArkRatingGroup } from "@ark-ui/react/rating-group";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useRatingGroupStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useRatingGroupStyles };
+export interface RatingGroupRootProviderBaseProps extends Assign<ArkRatingGroup.RootProviderBaseProps, SlotRecipeProps<"ratingGroup">>, UnstyledProp {
+}
+export interface RatingGroupRootProviderProps extends HTMLMainbaseProps<"div", RatingGroupRootProviderBaseProps> {
+}
+export declare const RatingGroupRootProvider: import("react").ForwardRefExoticComponent<RatingGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RatingGroupRootBaseProps extends Assign<ArkRatingGroup.RootBaseProps, SlotRecipeProps<"ratingGroup">>, UnstyledProp {
+}
+export interface RatingGroupRootProps extends HTMLMainbaseProps<"div", RatingGroupRootBaseProps> {
+}
+export declare const RatingGroupRoot: import("react").ForwardRefExoticComponent<RatingGroupRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const RatingGroupPropsProvider: React.Provider<RatingGroupRootBaseProps>;
+export interface RatingGroupLabelProps extends HTMLMainbaseProps<"div", ArkRatingGroup.LabelBaseProps>, UnstyledProp {
+}
+export declare const RatingGroupLabel: import("react").ForwardRefExoticComponent<RatingGroupLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RatingGroupItemProps extends HTMLMainbaseProps<"div", ArkRatingGroup.ItemBaseProps>, UnstyledProp {
+}
+export declare const RatingGroupItem: import("react").ForwardRefExoticComponent<RatingGroupItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface RatingGroupItemIndicatorProps extends HTMLMainbaseProps<"span"> {
+    icon?: React.ReactElement | undefined;
+}
+export declare const RatingGroupItemIndicator: import("react").ForwardRefExoticComponent<RatingGroupItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface RatingGroupItemsProps extends Omit<RatingGroupItemProps, "index"> {
+}
+export declare const RatingGroupItems: (props: RatingGroupItemsProps) => import("react").JSX.Element;
+export interface RatingGroupControlProps extends HTMLMainbaseProps<"div", ArkRatingGroup.ControlBaseProps>, UnstyledProp {
+}
+export declare const RatingGroupControl: import("react").ForwardRefExoticComponent<RatingGroupControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const RatingGroupContext: (props: ArkRatingGroup.ContextProps) => import("react").ReactNode;
+export declare const RatingGroupItemContext: (props: ArkRatingGroup.ItemContextProps) => import("react").ReactNode;
+export declare const RatingGroupHiddenInput: import("react").ForwardRefExoticComponent<ArkRatingGroup.HiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface RatingGroupValueChangeDetails extends ArkRatingGroup.ValueChangeDetails {
+}
+export interface RatingGroupHoverChangeDetails extends ArkRatingGroup.HoverChangeDetails {
+}

package/dist/types/components/scroll-area/index.d.ts

@@ -0,0 +1,5 @@
+export { ScrollAreaRoot, ScrollAreaRootProvider, ScrollAreaPropsProvider, ScrollAreaViewport, ScrollAreaContent, ScrollAreaScrollbar, ScrollAreaThumb, ScrollAreaCorner, ScrollAreaContext, useScrollAreaStyles, } from "./scroll-area";
+export type { ScrollAreaRootProps, ScrollAreaRootProviderProps, ScrollAreaViewportProps, ScrollAreaContentProps, ScrollAreaScrollbarProps, ScrollAreaThumbProps, ScrollAreaCornerProps, } from "./scroll-area";
+export { useScrollArea, useScrollAreaContext } from "@ark-ui/react/scroll-area";
+export type { UseScrollAreaProps, UseScrollAreaReturn, } from "@ark-ui/react/scroll-area";
+export * as ScrollArea from "./namespace";

package/dist/types/components/scroll-area/namespace.d.ts

@@ -0,0 +1,2 @@
+export { ScrollAreaContext as Context, ScrollAreaContent as Content, ScrollAreaCorner as Corner, ScrollAreaPropsProvider as PropsProvider, ScrollAreaRoot as Root, ScrollAreaRootProvider as RootProvider, ScrollAreaScrollbar as Scrollbar, ScrollAreaThumb as Thumb, ScrollAreaViewport as Viewport, } from "./scroll-area";
+export type { ScrollAreaContentProps as ContentProps, ScrollAreaCornerProps as CornerProps, ScrollAreaRootProps as RootProps, ScrollAreaRootProviderProps as RootProviderProps, ScrollAreaScrollbarProps as ScrollbarProps, ScrollAreaThumbProps as ThumbProps, ScrollAreaViewportProps as ViewportProps, } from "./scroll-area";

package/dist/types/components/scroll-area/scroll-area.d.ts

@@ -0,0 +1,32 @@
+import type { Assign } from "@ark-ui/react";
+import { ScrollArea as ArkScrollArea } from "@ark-ui/react/scroll-area";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useScrollAreaStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useScrollAreaStyles };
+export interface ScrollAreaRootProviderBaseProps extends Assign<ArkScrollArea.RootProviderBaseProps, SlotRecipeProps<"scrollArea">>, UnstyledProp {
+}
+export interface ScrollAreaRootProviderProps extends HTMLMainbaseProps<"div", ScrollAreaRootProviderBaseProps> {
+}
+export declare const ScrollAreaRootProvider: import("react").ForwardRefExoticComponent<ScrollAreaRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ScrollAreaRootBaseProps extends Assign<ArkScrollArea.RootBaseProps, SlotRecipeProps<"scrollArea">>, UnstyledProp {
+}
+export interface ScrollAreaRootProps extends HTMLMainbaseProps<"div", ScrollAreaRootBaseProps> {
+}
+export declare const ScrollAreaRoot: import("react").ForwardRefExoticComponent<ScrollAreaRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ScrollAreaPropsProvider: React.Provider<ScrollAreaRootBaseProps>;
+export interface ScrollAreaViewportProps extends HTMLMainbaseProps<"div", ArkScrollArea.ViewportBaseProps>, UnstyledProp {
+}
+export declare const ScrollAreaViewport: import("react").ForwardRefExoticComponent<ScrollAreaViewportProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ScrollAreaContentProps extends HTMLMainbaseProps<"div", ArkScrollArea.ContentBaseProps>, UnstyledProp {
+}
+export declare const ScrollAreaContent: import("react").ForwardRefExoticComponent<ScrollAreaContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ScrollAreaThumbProps extends HTMLMainbaseProps<"div", ArkScrollArea.ThumbBaseProps>, UnstyledProp {
+}
+export declare const ScrollAreaThumb: import("react").ForwardRefExoticComponent<ScrollAreaThumbProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ScrollAreaScrollbarProps extends HTMLMainbaseProps<"div", ArkScrollArea.ScrollbarBaseProps>, UnstyledProp {
+}
+export declare const ScrollAreaScrollbar: import("react").ForwardRefExoticComponent<ScrollAreaScrollbarProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ScrollAreaCornerProps extends HTMLMainbaseProps<"div", ArkScrollArea.CornerBaseProps>, UnstyledProp {
+}
+export declare const ScrollAreaCorner: import("react").ForwardRefExoticComponent<ScrollAreaCornerProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ScrollAreaContext: (props: ArkScrollArea.ContextProps) => import("react").ReactNode;

package/dist/types/components/segment-group/index.d.ts

@@ -0,0 +1,5 @@
+export { SegmentGroupRoot, SegmentGroupRootProvider, SegmentGroupPropsProvider, SegmentGroupItem, SegmentGroupItemText, SegmentGroupIndicator, SegmentGroupItemHiddenInput, SegmentGroupItemContext, SegmentGroupContext, useSegmentGroupStyles, SegmentGroupItems, } from "./segment-group";
+export type { SegmentGroupRootProps, SegmentGroupRootProviderProps, SegmentGroupItemProps, SegmentGroupItemTextProps, SegmentGroupIndicatorProps, SegmentGroupValueChangeDetails, SegmentGroupItemsProps, } from "./segment-group";
+export { useSegmentGroup, useSegmentGroupContext, useSegmentGroupItemContext, } from "@ark-ui/react/segment-group";
+export type { UseSegmentGroupProps, UseSegmentGroupReturn, } from "@ark-ui/react/segment-group";
+export * as SegmentGroup from "./namespace";

package/dist/types/components/segment-group/namespace.d.ts

@@ -0,0 +1,2 @@
+export { SegmentGroupContext as Context, SegmentGroupIndicator as Indicator, SegmentGroupItem as Item, SegmentGroupItemContext as ItemContext, SegmentGroupItemHiddenInput as ItemHiddenInput, SegmentGroupItemText as ItemText, SegmentGroupPropsProvider as PropsProvider, SegmentGroupRoot as Root, SegmentGroupRootProvider as RootProvider, SegmentGroupItems as Items, } from "./segment-group";
+export type { SegmentGroupIndicatorProps as IndicatorProps, SegmentGroupItemProps as ItemProps, SegmentGroupItemTextProps as ItemTextProps, SegmentGroupRootProps as RootProps, SegmentGroupRootProviderProps as RootProviderProps, SegmentGroupValueChangeDetails as ValueChangeDetails, SegmentGroupItemsProps as ItemsProps, } from "./segment-group";

package/dist/types/components/segment-group/segment-group.d.ts

@@ -0,0 +1,39 @@
+import type { Assign } from "@ark-ui/react";
+import { SegmentGroup as ArkSegmentGroup } from "@ark-ui/react/segment-group";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useSegmentGroupStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useSegmentGroupStyles };
+export interface SegmentGroupRootProviderBaseProps extends Assign<ArkSegmentGroup.RootProviderBaseProps, SlotRecipeProps<"segmentGroup">>, UnstyledProp {
+}
+export interface SegmentGroupRootProviderProps extends HTMLMainbaseProps<"div", SegmentGroupRootProviderBaseProps> {
+}
+export declare const SegmentGroupRootProvider: import("react").ForwardRefExoticComponent<SegmentGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SegmentGroupRootBaseProps extends Assign<ArkSegmentGroup.RootBaseProps, SlotRecipeProps<"segmentGroup">>, UnstyledProp {
+}
+export interface SegmentGroupRootProps extends HTMLMainbaseProps<"div", SegmentGroupRootBaseProps> {
+}
+export declare const SegmentGroupRoot: import("react").ForwardRefExoticComponent<SegmentGroupRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const SegmentGroupPropsProvider: React.Provider<SegmentGroupRootBaseProps>;
+export interface SegmentGroupItemProps extends HTMLMainbaseProps<"label", ArkSegmentGroup.ItemBaseProps>, UnstyledProp {
+}
+export declare const SegmentGroupItem: import("react").ForwardRefExoticComponent<SegmentGroupItemProps & import("react").RefAttributes<HTMLLabelElement>>;
+export interface SegmentGroupItemTextProps extends HTMLMainbaseProps<"span", ArkSegmentGroup.ItemTextBaseProps>, UnstyledProp {
+}
+export declare const SegmentGroupItemText: import("react").ForwardRefExoticComponent<SegmentGroupItemTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface SegmentGroupIndicatorProps extends HTMLMainbaseProps<"div", ArkSegmentGroup.IndicatorBaseProps>, UnstyledProp {
+}
+export declare const SegmentGroupIndicator: import("react").ForwardRefExoticComponent<SegmentGroupIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+interface Item {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean | undefined;
+}
+export interface SegmentGroupItemsProps extends Omit<SegmentGroupItemProps, "value"> {
+    items: Array<string | Item>;
+}
+export declare const SegmentGroupItems: (props: SegmentGroupItemsProps) => import("react").JSX.Element;
+export declare const SegmentGroupItemHiddenInput: import("react").ForwardRefExoticComponent<ArkSegmentGroup.ItemHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export declare const SegmentGroupContext: (props: ArkSegmentGroup.ContextProps) => import("react").ReactNode;
+export declare const SegmentGroupItemContext: (props: ArkSegmentGroup.ItemContextProps) => import("react").ReactNode;
+export interface SegmentGroupValueChangeDetails extends ArkSegmentGroup.ValueChangeDetails {
+}

package/dist/types/components/select/index.d.ts

@@ -0,0 +1,5 @@
+export { SelectClearTrigger, SelectContent, SelectContext, SelectControl, SelectHiddenSelect, SelectIndicator, SelectIndicatorGroup, SelectItem, SelectList, SelectItemContext, SelectItemGroup, SelectItemGroupLabel, SelectItemIndicator, SelectItemText, SelectLabel, SelectPositioner, SelectPropsProvider, SelectRoot, SelectRootProvider, SelectTrigger, SelectValueText, useSelectStyles, } from "./select";
+export type { SelectClearTriggerProps, SelectContentProps, SelectControlProps, SelectHighlightChangeDetails, SelectListProps, SelectIndicatorGroupProps, SelectIndicatorProps, SelectItemGroupLabelProps, SelectItemGroupProps, SelectItemIndicatorProps, SelectItemProps, SelectItemTextProps, SelectLabelProps, SelectOpenChangeDetails, SelectPositionerProps, SelectRootProps, SelectRootComponent, SelectRootProviderProps, SelectTriggerProps, SelectValueChangeDetails, SelectValueTextProps, } from "./select";
+export { useSelect, useSelectContext, useSelectItemContext, } from "@ark-ui/react/select";
+export type { UseSelectProps, UseSelectReturn, SelectInteractOutsideEvent, SelectFocusOutsideEvent, SelectPointerDownOutsideEvent, } from "@ark-ui/react/select";
+export * as Select from "./namespace";

package/dist/types/components/select/namespace.d.ts

@@ -0,0 +1,3 @@
+export { SelectClearTrigger as ClearTrigger, SelectContent as Content, SelectControl as Control, SelectIndicator as Indicator, SelectList as List, SelectIndicatorGroup as IndicatorGroup, SelectItem as Item, SelectItemGroup as ItemGroup, SelectItemGroupLabel as ItemGroupLabel, SelectItemIndicator as ItemIndicator, SelectItemText as ItemText, SelectItemContext as ItemContext, SelectLabel as Label, SelectPositioner as Positioner, SelectRoot as Root, SelectRootProvider as RootProvider, SelectContext as Context, SelectPropsProvider as PropsProvider, SelectTrigger as Trigger, SelectValueText as ValueText, SelectHiddenSelect as HiddenSelect, } from "./select";
+export type { SelectClearTriggerProps as ClearTriggerProps, SelectContentProps as ContentProps, SelectControlProps as ControlProps, SelectIndicatorGroupProps as IndicatorGroupProps, SelectListProps as ListProps, SelectIndicatorProps as IndicatorProps, SelectItemGroupLabelProps as ItemGroupLabelProps, SelectItemGroupProps as ItemGroupProps, SelectItemIndicatorProps as ItemIndicatorProps, SelectItemProps as ItemProps, SelectItemTextProps as ItemTextProps, SelectLabelProps as LabelProps, SelectPositionerProps as PositionerProps, SelectRootProps as RootProps, SelectRootProviderProps as RootProviderProps, SelectTriggerProps as TriggerProps, SelectHighlightChangeDetails as HighlightChangeDetails, SelectOpenChangeDetails as OpenChangeDetails, SelectValueChangeDetails as ValueChangeDetails, SelectValueTextProps as ValueTextProps, SelectRootComponent as RootComponent, } from "./select";
+export type { SelectInteractOutsideEvent as InteractOutsideEvent, SelectFocusOutsideEvent as FocusOutsideEvent, SelectPointerDownOutsideEvent as PointerDownOutsideEvent, } from "@ark-ui/react/select";

package/dist/types/components/select/select.d.ts

@@ -0,0 +1,77 @@
+import type { Assign, CollectionItem } from "@ark-ui/react";
+import { Select as ArkSelect } from "@ark-ui/react/select";
+import type { JSX } from "react";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useSelectStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useSelectStyles };
+export interface SelectRootProviderBaseProps<T extends CollectionItem = any> extends Assign<ArkSelect.RootProviderBaseProps<T>, SlotRecipeProps<"select">>, UnstyledProp {
+}
+export interface SelectRootProviderProps<T extends CollectionItem = any> extends HTMLMainbaseProps<"div", SelectRootProviderBaseProps<T>> {
+}
+interface SelectRootProviderComponent {
+    <T extends CollectionItem>(props: SelectRootProviderProps<T>): JSX.Element;
+}
+export declare const SelectRootProvider: SelectRootProviderComponent;
+export interface SelectRootBaseProps<T extends CollectionItem = any> extends Assign<ArkSelect.RootBaseProps<T>, SlotRecipeProps<"select">>, UnstyledProp {
+}
+export interface SelectRootProps<T extends CollectionItem = any> extends HTMLMainbaseProps<"div", SelectRootBaseProps<T>> {
+}
+export interface SelectRootComponent {
+    <T extends CollectionItem>(props: SelectRootProps<T> & React.RefAttributes<HTMLDivElement>): JSX.Element;
+}
+export declare const SelectRoot: SelectRootComponent;
+export declare const SelectPropsProvider: React.Provider<SelectRootBaseProps>;
+export interface SelectTriggerProps extends HTMLMainbaseProps<"button", ArkSelect.TriggerBaseProps>, UnstyledProp {
+}
+export declare const SelectTrigger: import("react").ForwardRefExoticComponent<SelectTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface SelectPositionerProps extends HTMLMainbaseProps<"div", ArkSelect.PositionerBaseProps>, UnstyledProp {
+}
+export declare const SelectPositioner: import("react").ForwardRefExoticComponent<SelectPositionerProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectContentProps extends HTMLMainbaseProps<"div", ArkSelect.ContentBaseProps>, UnstyledProp {
+}
+export declare const SelectContent: import("react").ForwardRefExoticComponent<SelectContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectListProps extends HTMLMainbaseProps<"div", ArkSelect.ListBaseProps>, UnstyledProp {
+}
+export declare const SelectList: import("react").ForwardRefExoticComponent<SelectListProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectValueTextProps extends HTMLMainbaseProps<"span", ArkSelect.ValueTextBaseProps>, UnstyledProp {
+}
+export declare const SelectValueText: import("react").ForwardRefExoticComponent<SelectValueTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface SelectClearTriggerProps extends HTMLMainbaseProps<"button", ArkSelect.ClearTriggerBaseProps>, UnstyledProp {
+}
+export declare const SelectClearTrigger: import("react").ForwardRefExoticComponent<SelectClearTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface SelectItemGroupProps extends HTMLMainbaseProps<"div", ArkSelect.ItemGroupBaseProps>, UnstyledProp {
+}
+export declare const SelectItemGroup: import("react").ForwardRefExoticComponent<SelectItemGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectItemGroupLabelProps extends HTMLMainbaseProps<"div", ArkSelect.ItemGroupLabelBaseProps>, UnstyledProp {
+}
+export declare const SelectItemGroupLabel: import("react").ForwardRefExoticComponent<SelectItemGroupLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectItemProps extends HTMLMainbaseProps<"div", ArkSelect.ItemBaseProps>, UnstyledProp {
+}
+export declare const SelectItem: import("react").ForwardRefExoticComponent<SelectItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectItemTextProps extends HTMLMainbaseProps<"div", ArkSelect.ItemTextBaseProps>, UnstyledProp {
+}
+export declare const SelectItemText: import("react").ForwardRefExoticComponent<SelectItemTextProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectItemIndicatorProps extends HTMLMainbaseProps<"div", ArkSelect.ItemIndicatorBaseProps>, UnstyledProp {
+}
+export declare const SelectItemIndicator: import("react").ForwardRefExoticComponent<SelectItemIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectIndicatorGroupProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const SelectIndicatorGroup: import("react").ForwardRefExoticComponent<SelectIndicatorGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectIndicatorProps extends HTMLMainbaseProps<"div", ArkSelect.ItemIndicatorBaseProps>, UnstyledProp {
+}
+export declare const SelectIndicator: import("react").ForwardRefExoticComponent<SelectItemIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectControlProps extends HTMLMainbaseProps<"div", ArkSelect.ControlBaseProps>, UnstyledProp {
+}
+export declare const SelectControl: import("react").ForwardRefExoticComponent<SelectControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectLabelProps extends HTMLMainbaseProps<"label", ArkSelect.LabelBaseProps>, UnstyledProp {
+}
+export declare const SelectLabel: import("react").ForwardRefExoticComponent<SelectLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+export declare const SelectContext: <T extends unknown>(props: ArkSelect.ContextProps<T>) => import("react").ReactNode;
+export declare const SelectHiddenSelect: import("react").ForwardRefExoticComponent<ArkSelect.HiddenSelectProps & import("react").RefAttributes<HTMLSelectElement>>;
+export declare const SelectItemContext: (props: ArkSelect.ItemContextProps) => import("react").ReactNode;
+export interface SelectHighlightChangeDetails<T extends CollectionItem = any> extends ArkSelect.HighlightChangeDetails<T> {
+}
+export interface SelectValueChangeDetails<T extends CollectionItem = any> extends ArkSelect.ValueChangeDetails<T> {
+}
+export interface SelectOpenChangeDetails extends ArkSelect.OpenChangeDetails {
+}

package/dist/types/components/separator/index.d.ts

@@ -0,0 +1,2 @@
+export { Separator, SeparatorPropsProvider } from "./separator";
+export type { SeparatorProps } from "./separator";

package/dist/types/components/separator/separator.d.ts

@@ -0,0 +1,7 @@
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+export interface SeparatorBaseProps extends RecipeProps<"separator">, UnstyledProp {
+}
+export interface SeparatorProps extends HTMLMainbaseProps<"span", SeparatorBaseProps> {
+}
+export declare const Separator: import("react").ForwardRefExoticComponent<SeparatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const SeparatorPropsProvider: React.Provider<SeparatorBaseProps>;

package/dist/types/components/show/index.d.ts

@@ -0,0 +1,2 @@
+export { Show } from "./show";
+export type { ShowProps } from "./show";

package/dist/types/components/show/show.d.ts

@@ -0,0 +1,16 @@
+import { type JSX } from "react";
+export interface ShowProps<T> {
+    /**
+     * If `true`, it'll render the `children` prop
+     */
+    when: T | null | undefined;
+    /**
+     * The fallback content to render if `when` is `false`
+     */
+    fallback?: React.ReactNode | undefined;
+    /**
+     * The children to render if `when` is `true`
+     */
+    children: React.ReactNode | ((props: T) => React.ReactNode);
+}
+export declare function Show<T>(props: ShowProps<T>): JSX.Element;

package/dist/types/components/simple-grid/index.d.ts

@@ -0,0 +1,2 @@
+export { SimpleGrid } from "./simple-grid";
+export type { SimpleGridProps } from "./simple-grid";

package/dist/types/components/simple-grid/simple-grid.d.ts

@@ -0,0 +1,26 @@
+import { type ConditionalValue } from "../../styled-system";
+import { type GridProps } from "../grid";
+interface SimpleGridBaseProps {
+    /**
+     * The width at which child elements will break into columns. Pass a number for pixel values or a string for any other valid CSS length.
+     */
+    minChildWidth?: GridProps["minWidth"] | undefined;
+    /**
+     * The number of columns
+     */
+    columns?: ConditionalValue<number> | undefined;
+}
+export interface SimpleGridProps extends Omit<GridProps, "columns">, SimpleGridBaseProps {
+}
+/**
+ * SimpleGrid
+ *
+ * React component that uses the `Grid` component and provides
+ * a simpler interface to create responsive grid layouts.
+ *
+ * Provides props that easily define columns and spacing.
+ *
+ * @see Docs https://mainbase-ui.com/docs/components/simple-grid
+ */
+export declare const SimpleGrid: import("react").ForwardRefExoticComponent<SimpleGridProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton, SkeletonPropsProvider, SkeletonCircle, SkeletonText, } from "./skeleton";
+export type { SkeletonProps, SkeletonCircleProps, SkeletonTextProps, } from "./skeleton";

package/dist/types/components/skeleton/skeleton.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+import type { CircleProps } from "../circle";
+import type { StackProps } from "../stack";
+export interface SkeletonProps extends HTMLMainbaseProps<"div">, RecipeProps<"skeleton">, UnstyledProp {
+}
+export declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SkeletonPropsProvider: React.Provider<SkeletonProps>;
+export interface SkeletonCircleProps extends SkeletonProps {
+    size?: CircleProps["size"] | undefined;
+}
+export declare const SkeletonCircle: React.ForwardRefExoticComponent<SkeletonCircleProps & React.RefAttributes<HTMLDivElement>>;
+export interface SkeletonTextProps extends SkeletonProps {
+    noOfLines?: number | undefined;
+    rootProps?: StackProps | undefined;
+}
+export declare const SkeletonText: React.ForwardRefExoticComponent<SkeletonTextProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/skip-nav/index.d.ts

@@ -0,0 +1,4 @@
+export { SkipNavLink } from "./skip-nav-link";
+export type { SkipNavLinkProps } from "./skip-nav-link";
+export { SkipNavContent } from "./skip-nav-content";
+export type { SkipNavContentProps } from "./skip-nav-content";

package/dist/types/components/skip-nav/skip-nav-content.d.ts

@@ -0,0 +1,9 @@
+import { type HTMLMainbaseProps } from "../../styled-system";
+export interface SkipNavContentProps extends HTMLMainbaseProps<"div"> {
+}
+/**
+ * Renders a div as the target for the `SkipNavLink`.
+ *
+ * @see Docs https://mainbase-ui.com/docs/components/skip-nav
+ */
+export declare const SkipNavContent: import("react").ForwardRefExoticComponent<SkipNavContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/skip-nav/skip-nav-link.d.ts

@@ -0,0 +1,10 @@
+import { type HTMLMainbaseProps, type RecipeProps } from "../../styled-system";
+export interface SkipNavLinkProps extends HTMLMainbaseProps<"a">, RecipeProps<"skipNavLink"> {
+}
+export declare const fallbackId = "mainbase-skip-nav";
+/**
+ * Renders a link that remains hidden until focused to skip to the main content.
+ *
+ * @see Docs https://mainbase-ui.com/docs/components/skip-nav
+ */
+export declare const SkipNavLink: import("react").ForwardRefExoticComponent<SkipNavLinkProps & import("react").RefAttributes<HTMLAnchorElement>>;

package/dist/types/components/slider/index.d.ts

@@ -0,0 +1,5 @@
+export { SliderControl, SliderLabel, SliderMarker, SliderMarkerGroup, SliderMarkerIndicator, SliderMarkerLabel, SliderRange, SliderRoot, SliderRootProvider, SliderPropsProvider, SliderThumb, SliderTrack, SliderValueText, SliderDraggingIndicator, SliderContext, SliderHiddenInput, useSliderStyles, } from "./slider";
+export type { SliderControlProps, SliderLabelProps, SliderMarkerProps, SliderMarkerIndicatorProps, SliderMarkerLabelProps, SliderRangeProps, SliderRootProps, SliderRootProviderProps, SliderThumbProps, SliderTrackProps, SliderValueTextProps, SliderMarkerGroupProps, SliderDraggingIndicatorProps, SliderValueChangeDetails, } from "./slider";
+export { useSlider, useSliderContext } from "@ark-ui/react/slider";
+export type { UseSliderProps, UseSliderReturn } from "@ark-ui/react/slider";
+export * as Slider from "./namespace";

package/dist/types/components/slider/namespace.d.ts

@@ -0,0 +1,2 @@
+export { SliderRoot as Root, SliderRootProvider as RootProvider, SliderPropsProvider as PropsProvider, SliderMarker as Marker, SliderMarkerIndicator as MarkerIndicator, SliderMarkerLabel as MarkerLabel, SliderThumb as Thumb, SliderValueText as ValueText, SliderRange as Range, SliderControl as Control, SliderLabel as Label, SliderTrack as Track, SliderMarkerGroup as MarkerGroup, SliderMarks as Marks, SliderThumbs as Thumbs, SliderContext as Context, SliderHiddenInput as HiddenInput, SliderDraggingIndicator as DraggingIndicator, } from "./slider";
+export type { SliderRootProps as RootProps, SliderRootProviderProps as RootProviderProps, SliderMarkerProps as MarkerProps, SliderMarkerIndicatorProps as MarkerIndicatorProps, SliderMarkerLabelProps as MarkerLabelProps, SliderThumbProps as ThumbProps, SliderValueTextProps as ValueTextProps, SliderRangeProps as RangeProps, SliderControlProps as ControlProps, SliderLabelProps as LabelProps, SliderTrackProps as TrackProps, SliderMarkerGroupProps as MarkerGroupProps, SliderDraggingIndicatorProps as DraggingIndicatorProps, SliderValueChangeDetails as ValueChangeDetails, SliderMarksProps as MarksProps, } from "./slider";

package/dist/types/components/slider/slider.d.ts

@@ -0,0 +1,61 @@
+import type { Assign } from "@ark-ui/react";
+import { Slider as ArkSlider } from "@ark-ui/react/slider";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useSliderStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useSliderStyles };
+export interface SliderRootProviderBaseProps extends Assign<ArkSlider.RootProviderBaseProps, SlotRecipeProps<"slider">>, UnstyledProp {
+}
+export interface SliderRootProviderProps extends HTMLMainbaseProps<"div", SliderRootProviderBaseProps> {
+}
+export declare const SliderRootProvider: import("react").ForwardRefExoticComponent<SliderRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderRootBaseProps extends Assign<ArkSlider.RootBaseProps, SlotRecipeProps<"slider">>, UnstyledProp {
+}
+export interface SliderRootProps extends HTMLMainbaseProps<"div", SliderRootBaseProps> {
+}
+export declare const SliderRoot: import("react").ForwardRefExoticComponent<SliderRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const SliderPropsProvider: React.Provider<SliderRootBaseProps>;
+export interface SliderTrackProps extends HTMLMainbaseProps<"div", ArkSlider.TrackBaseProps>, UnstyledProp {
+}
+export declare const SliderTrack: import("react").ForwardRefExoticComponent<SliderTrackProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderRangeProps extends HTMLMainbaseProps<"div", ArkSlider.RangeBaseProps>, UnstyledProp {
+}
+export declare const SliderRange: import("react").ForwardRefExoticComponent<SliderRangeProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderThumbProps extends HTMLMainbaseProps<"div", ArkSlider.ThumbBaseProps>, UnstyledProp {
+}
+export declare const SliderThumb: import("react").ForwardRefExoticComponent<SliderThumbProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderValueTextProps extends HTMLMainbaseProps<"div", ArkSlider.ValueTextBaseProps>, UnstyledProp {
+}
+export declare const SliderValueText: import("react").ForwardRefExoticComponent<SliderValueTextProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderLabelProps extends HTMLMainbaseProps<"label", ArkSlider.LabelBaseProps>, UnstyledProp {
+}
+export declare const SliderLabel: import("react").ForwardRefExoticComponent<SliderLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+export interface SliderMarkerGroupProps extends HTMLMainbaseProps<"div", ArkSlider.MarkerGroupBaseProps>, UnstyledProp {
+}
+export declare const SliderMarkerGroup: import("react").ForwardRefExoticComponent<SliderMarkerGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderMarkerProps extends HTMLMainbaseProps<"div", ArkSlider.MarkerBaseProps>, UnstyledProp {
+}
+export declare const SliderMarker: import("react").ForwardRefExoticComponent<SliderMarkerProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderMarkerIndicatorProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const SliderMarkerIndicator: import("react").ForwardRefExoticComponent<SliderMarkerIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderMarkerLabelProps extends HTMLMainbaseProps<"span">, UnstyledProp {
+}
+export declare const SliderMarkerLabel: import("react").ForwardRefExoticComponent<SliderMarkerLabelProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface SliderDraggingIndicatorProps extends HTMLMainbaseProps<"div", ArkSlider.DraggingIndicatorBaseProps>, UnstyledProp {
+}
+export declare const SliderDraggingIndicator: import("react").ForwardRefExoticComponent<SliderDraggingIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const SliderThumbs: (props: Omit<SliderThumbProps, "index">) => import("react").JSX.Element;
+export interface SliderMarksProps extends SliderMarkerGroupProps {
+    marks?: Array<number | {
+        value: number;
+        label: React.ReactNode;
+    }> | undefined;
+}
+export declare const SliderMarks: import("react").ForwardRefExoticComponent<SliderMarksProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SliderControlProps extends HTMLMainbaseProps<"div", ArkSlider.ControlBaseProps>, UnstyledProp {
+}
+export declare const SliderControl: import("react").ForwardRefExoticComponent<SliderControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const SliderContext: (props: ArkSlider.ContextProps) => import("react").ReactNode;
+export declare const SliderHiddenInput: import("react").ForwardRefExoticComponent<ArkSlider.HiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface SliderValueChangeDetails extends ArkSlider.ValueChangeDetails {
+}

package/dist/types/components/spacer/index.d.ts

@@ -0,0 +1,2 @@
+export { Spacer } from "./spacer";
+export type { SpacerProps } from "./spacer";

package/dist/types/components/spacer/spacer.d.ts

@@ -0,0 +1,10 @@
+import { type HTMLMainbaseProps } from "../../styled-system";
+export interface SpacerProps extends HTMLMainbaseProps<"div"> {
+}
+/**
+ * A flexible flex spacer that expands along the major axis of its containing flex layout.
+ * It renders a `div` by default, and takes up any available space.
+ *
+ * @see Docs https://mainbase-ui.com/docs/components/flex#using-the-spacer
+ */
+export declare const Spacer: import("../..").MainbaseComponent<"div", {}>;

package/dist/types/components/span/index.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLMainbaseProps } from "../../styled-system";
+export interface SpanProps extends HTMLMainbaseProps<"span"> {
+}
+export declare const Span: import("../..").MainbaseComponent<"span", {}>;

package/dist/types/components/spinner/index.d.ts

@@ -0,0 +1,2 @@
+export { Spinner, SpinnerPropsProvider } from "./spinner";
+export type { SpinnerProps } from "./spinner";

package/dist/types/components/spinner/spinner.d.ts

@@ -0,0 +1,5 @@
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+export interface SpinnerProps extends HTMLMainbaseProps<"span">, UnstyledProp, RecipeProps<"spinner"> {
+}
+export declare const Spinner: import("react").ForwardRefExoticComponent<SpinnerProps & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const SpinnerPropsProvider: React.Provider<SpinnerProps>;

package/dist/types/components/splitter/index.d.ts

@@ -0,0 +1,5 @@
+export { SplitterContext, SplitterPanel, SplitterPropsProvider, SplitterResizeTriggerIndicator, SplitterResizeTriggerSeparator, SplitterResizeTrigger, SplitterRoot, SplitterRootProvider, useSplitterStyles, } from "./splitter";
+export type { SplitterExpandCollapseDetails, SplitterPanelData, SplitterPanelProps, SplitterResizeDetails, SplitterResizeEndDetails, SplitterResizeTriggerIndicatorProps, SplitterResizeTriggerSeparatorProps, SplitterResizeTriggerProps, SplitterRootBaseProps, SplitterRootProps, SplitterRootProviderBaseProps, SplitterRootProviderProps, } from "./splitter";
+export { createSplitterRegistry, getSplitterLayout, useSplitter, useSplitterContext, } from "@ark-ui/react/splitter";
+export type { SplitterRegistryProps, SplitterRegistryReturn, UseSplitterContext, UseSplitterProps, UseSplitterReturn, } from "@ark-ui/react/splitter";
+export * as Splitter from "./namespace";

package/dist/types/components/splitter/namespace.d.ts

@@ -0,0 +1,2 @@
+export { SplitterContext as Context, SplitterPanel as Panel, SplitterPropsProvider as PropsProvider, SplitterResizeTriggerIndicator as ResizeTriggerIndicator, SplitterResizeTriggerSeparator as ResizeTriggerSeparator, SplitterResizeTrigger as ResizeTrigger, SplitterRoot as Root, SplitterRootProvider as RootProvider, } from "./splitter";
+export type { SplitterExpandCollapseDetails as ExpandCollapseDetails, SplitterPanelData as PanelData, SplitterPanelProps as PanelProps, SplitterResizeDetails as ResizeDetails, SplitterResizeEndDetails as ResizeEndDetails, SplitterResizeTriggerIndicatorProps as ResizeTriggerIndicatorProps, SplitterResizeTriggerSeparatorProps as ResizeTriggerSeparatorProps, SplitterResizeTriggerProps as ResizeTriggerProps, SplitterRootBaseProps as RootBaseProps, SplitterRootProps as RootProps, SplitterRootProviderBaseProps as RootProviderBaseProps, SplitterRootProviderProps as RootProviderProps, } from "./splitter";