mainbase-ui 1.2.5 → 3.37.0

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

@@ -0,0 +1,3 @@
+export { DrawerBackdrop as Backdrop, DrawerBody as Body, DrawerCloseTrigger as CloseTrigger, DrawerFooter as Footer, DrawerHeader as Header, DrawerPositioner as Positioner, DrawerRoot as Root, DrawerRootProvider as RootProvider, DrawerRootPropsProvider as RootPropsProvider, DrawerTrigger as Trigger, DrawerContent as Content, DrawerTitle as Title, DrawerDescription as Description, DrawerContext as Context, DrawerActionTrigger as ActionTrigger, } from "./drawer";
+export type { DrawerBackdropProps as BackdropProps, DrawerBodyProps as BodyProps, DrawerCloseTriggerProps as CloseTriggerProps, DrawerContentProps as ContentProps, DrawerDescriptionProps as DescriptionProps, DrawerFooterProps as FooterProps, DrawerHeaderProps as HeaderProps, DrawerPositionerProps as PositionerProps, DrawerRootProps as RootProps, DrawerRootProviderProps as RootProviderProps, DrawerTriggerProps as TriggerProps, DrawerTitleProps as TitleProps, DrawerOpenChangeDetails as OpenChangeDetails, DrawerActionTriggerProps as ActionTriggerProps, } from "./drawer";
+export type { DialogInteractOutsideEvent as InteractOutsideEvent, DialogFocusOutsideEvent as FocusOutsideEvent, DialogPointerDownOutsideEvent as PointerDownOutsideEvent, } from "@ark-ui/react/dialog";

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

@@ -0,0 +1,44 @@
+import type { Assign } from "@ark-ui/react";
+import { Editable as ArkEditable } from "@ark-ui/react/editable";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useEditableStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useEditableStyles };
+export interface EditableRootProviderBaseProps extends Assign<ArkEditable.RootProviderBaseProps, SlotRecipeProps<"editable">>, UnstyledProp {
+}
+export interface EditableRootProviderProps extends HTMLMainbaseProps<"div", EditableRootProviderBaseProps> {
+}
+export declare const EditableRootProvider: import("react").ForwardRefExoticComponent<EditableRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface EditableRootBaseProps extends Assign<ArkEditable.RootBaseProps, SlotRecipeProps<"editable">>, UnstyledProp {
+}
+export interface EditableRootProps extends HTMLMainbaseProps<"div", EditableRootBaseProps> {
+}
+export declare const EditableRoot: import("react").ForwardRefExoticComponent<EditableRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const EditablePropsProvider: React.Provider<EditableRootBaseProps>;
+export interface EditablePreviewProps extends HTMLMainbaseProps<"span", ArkEditable.PreviewBaseProps>, UnstyledProp {
+}
+export declare const EditablePreview: import("react").ForwardRefExoticComponent<EditablePreviewProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface EditableLabelProps extends HTMLMainbaseProps<"label", ArkEditable.LabelProps>, UnstyledProp {
+}
+export declare const EditableLabel: import("react").ForwardRefExoticComponent<EditableLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+export interface EditableInputProps extends HTMLMainbaseProps<"input", ArkEditable.InputBaseProps>, UnstyledProp {
+}
+export declare const EditableInput: import("react").ForwardRefExoticComponent<EditableInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface EditableTextareaProps extends HTMLMainbaseProps<"textarea", ArkEditable.InputBaseProps>, UnstyledProp {
+}
+export declare const EditableTextarea: import("react").ForwardRefExoticComponent<EditableTextareaProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface EditableControlProps extends HTMLMainbaseProps<"div", ArkEditable.ControlBaseProps>, UnstyledProp {
+}
+export declare const EditableControl: import("react").ForwardRefExoticComponent<EditableControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface EditableAreaProps extends HTMLMainbaseProps<"div", ArkEditable.AreaBaseProps>, UnstyledProp {
+}
+export declare const EditableArea: import("react").ForwardRefExoticComponent<EditableAreaProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface EditableEditTriggerProps extends HTMLMainbaseProps<"button", ArkEditable.EditTriggerBaseProps>, UnstyledProp {
+}
+export declare const EditableEditTrigger: import("react").ForwardRefExoticComponent<EditableEditTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface EditableSubmitTriggerProps extends HTMLMainbaseProps<"button", ArkEditable.SubmitTriggerBaseProps>, UnstyledProp {
+}
+export declare const EditableSubmitTrigger: import("react").ForwardRefExoticComponent<EditableSubmitTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface EditableCancelTriggerProps extends HTMLMainbaseProps<"button", ArkEditable.CancelTriggerBaseProps>, UnstyledProp {
+}
+export declare const EditableCancelTrigger: import("react").ForwardRefExoticComponent<EditableCancelTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const EditableContext: (props: ArkEditable.ContextProps) => import("react").ReactNode;

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

@@ -0,0 +1,5 @@
+export { EditableInput, EditablePreview, EditableRoot, EditableRootProvider, EditablePropsProvider, EditableContext, EditableTextarea, EditableControl, EditableArea, EditableEditTrigger, EditableCancelTrigger, EditableSubmitTrigger, useEditableStyles, } from "./editable";
+export type { EditableInputProps, EditablePreviewProps, EditableRootProps, EditableRootProviderProps, EditableTextareaProps, EditableControlProps, EditableAreaProps, EditableEditTriggerProps, EditableCancelTriggerProps, EditableSubmitTriggerProps, } from "./editable";
+export { useEditable, useEditableContext } from "@ark-ui/react/editable";
+export type { UseEditableProps, UseEditableReturn, EditableEditChangeDetails, EditableValueChangeDetails, EditableInteractOutsideEvent, EditableFocusOutsideEvent, EditablePointerDownOutsideEvent, } from "@ark-ui/react/editable";
+export * as Editable from "./namespace";

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

@@ -0,0 +1,3 @@
+export { EditableArea as Area, EditableCancelTrigger as CancelTrigger, EditableContext as Context, EditableControl as Control, EditableEditTrigger as EditTrigger, EditableInput as Input, EditableLabel as Label, EditablePreview as Preview, EditablePropsProvider as PropsProvider, EditableRoot as Root, EditableRootProvider as RootProvider, EditableSubmitTrigger as SubmitTrigger, EditableTextarea as Textarea, } from "./editable";
+export type { EditableAreaProps as AreaProps, EditableCancelTriggerProps as CancelTriggerProps, EditableControlProps as ControlProps, EditableEditTriggerProps as EditTriggerProps, EditableInputProps as InputProps, EditableLabelProps as LabelProps, EditablePreviewProps as PreviewProps, EditableRootProps as RootProps, EditableRootProviderProps as RootProviderProps, EditableSubmitTriggerProps as SubmitTriggerProps, EditableTextareaProps as TextareaProps, } from "./editable";
+export type { EditableEditChangeDetails as EditChangeDetails, EditableValueChangeDetails as ValueChangeDetails, EditableInteractOutsideEvent as InteractOutsideEvent, EditableFocusOutsideEvent as FocusOutsideEvent, EditablePointerDownOutsideEvent as PointerDownOutsideEvent, } from "@ark-ui/react/editable";

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

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

package/dist/types/components/empty-state/empty-state.d.ts

@@ -0,0 +1,21 @@
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useEmptyStateStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useEmptyStateStyles };
+export interface EmptyStateRootBaseProps extends SlotRecipeProps<"emptyState">, UnstyledProp {
+}
+export interface EmptyStateRootProps extends HTMLMainbaseProps<"div", EmptyStateRootBaseProps> {
+}
+export declare const EmptyStateRoot: import("react").ForwardRefExoticComponent<EmptyStateRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const EmptyStatePropsProvider: React.Provider<EmptyStateRootBaseProps>;
+export interface EmptyStateContentProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const EmptyStateContent: import("react").ForwardRefExoticComponent<EmptyStateContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface EmptyStateIndicatorProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const EmptyStateIndicator: import("react").ForwardRefExoticComponent<EmptyStateIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface EmptyStateTitleProps extends HTMLMainbaseProps<"h3"> {
+}
+export declare const EmptyStateTitle: import("react").ForwardRefExoticComponent<EmptyStateTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
+export interface EmptyStateDescriptionProps extends HTMLMainbaseProps<"p"> {
+}
+export declare const EmptyStateDescription: import("react").ForwardRefExoticComponent<EmptyStateDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;

package/dist/types/components/empty-state/index.d.ts

@@ -0,0 +1,3 @@
+export { EmptyStateRoot, EmptyStatePropsProvider, EmptyStateContent, EmptyStateIndicator, EmptyStateTitle, EmptyStateDescription, useEmptyStateStyles, } from "./empty-state";
+export type { EmptyStateRootProps, EmptyStateContentProps, EmptyStateIndicatorProps, EmptyStateTitleProps, EmptyStateDescriptionProps, } from "./empty-state";
+export * as EmptyState from "./namespace";

package/dist/types/components/empty-state/namespace.d.ts

@@ -0,0 +1,2 @@
+export { EmptyStateRoot as Root, EmptyStatePropsProvider as PropsProvider, EmptyStateContent as Content, EmptyStateIndicator as Indicator, EmptyStateTitle as Title, EmptyStateDescription as Description, } from "./empty-state";
+export type { EmptyStateRootProps as RootProps, EmptyStateContentProps as ContentProps, EmptyStateIndicatorProps as IndicatorProps, EmptyStateTitleProps as TitleProps, EmptyStateDescriptionProps as DescriptionProps, } from "./empty-state";

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

@@ -0,0 +1,2 @@
+export type { EnvironmentContext, EnvironmentProviderProps, RootNode, } from "@ark-ui/react/environment";
+export { EnvironmentProvider, useEnvironmentContext, } from "@ark-ui/react/environment";

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

@@ -0,0 +1,27 @@
+import type { Assign } from "@ark-ui/react";
+import { Field as ArkField } from "@ark-ui/react/field";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useFieldStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useFieldStyles };
+export interface FieldRootBaseProps extends Assign<ArkField.RootBaseProps, SlotRecipeProps<"field">>, UnstyledProp {
+}
+export interface FieldRootProps extends HTMLMainbaseProps<"div", FieldRootBaseProps> {
+}
+export declare const FieldRoot: import("react").ForwardRefExoticComponent<FieldRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const FieldPropsProvider: React.Provider<FieldRootBaseProps>;
+export interface FieldLabelProps extends HTMLMainbaseProps<"label", ArkField.LabelBaseProps>, UnstyledProp {
+}
+export declare const FieldLabel: import("react").ForwardRefExoticComponent<FieldLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+export interface FieldHelperTextProps extends HTMLMainbaseProps<"div", ArkField.HelperTextBaseProps>, UnstyledProp {
+}
+export declare const FieldHelperText: import("react").ForwardRefExoticComponent<FieldHelperTextProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FieldErrorTextProps extends HTMLMainbaseProps<"div", ArkField.ErrorTextBaseProps>, UnstyledProp {
+}
+export declare const FieldErrorText: import("react").ForwardRefExoticComponent<FieldErrorTextProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FieldErrorIconProps extends HTMLMainbaseProps<"svg"> {
+}
+export declare const FieldErrorIcon: import("react").ForwardRefExoticComponent<import("..").IconProps & import("react").RefAttributes<SVGSVGElement>>;
+export interface FieldRequiredIndicatorProps extends HTMLMainbaseProps<"span"> {
+    fallback?: React.ReactNode | undefined;
+}
+export declare const FieldRequiredIndicator: import("react").ForwardRefExoticComponent<FieldRequiredIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;

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

@@ -0,0 +1,5 @@
+export { FieldRoot, FieldPropsProvider, FieldLabel, FieldHelperText, FieldErrorText, FieldErrorIcon, FieldRequiredIndicator, useFieldStyles, } from "./field";
+export type { FieldRootProps, FieldLabelProps, FieldHelperTextProps, FieldErrorTextProps, FieldErrorIconProps, FieldRequiredIndicatorProps, } from "./field";
+export { useFieldContext, FieldContext, FieldItem } from "@ark-ui/react/field";
+export type { FieldItemProps } from "@ark-ui/react/field";
+export * as Field from "./namespace";

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

@@ -0,0 +1,4 @@
+export { FieldRoot as Root, FieldPropsProvider as PropsProvider, FieldLabel as Label, FieldHelperText as HelperText, FieldErrorText as ErrorText, FieldErrorIcon as ErrorIcon, FieldRequiredIndicator as RequiredIndicator, } from "./field";
+export type { FieldRootProps as RootProps, FieldLabelProps as LabelProps, FieldHelperTextProps as HelperTextProps, FieldErrorTextProps as ErrorTextProps, FieldErrorIconProps as ErrorIconProps, FieldRequiredIndicatorProps as RequiredIndicatorProps, } from "./field";
+export { FieldContext as Context, FieldItem as Item } from "@ark-ui/react/field";
+export type { FieldItemProps as ItemProps } from "@ark-ui/react/field";

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

@@ -0,0 +1,22 @@
+import type { Assign } from "@ark-ui/react";
+import { Fieldset } from "@ark-ui/react/fieldset";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+interface FieldsetRootBaseProps extends Assign<Fieldset.RootBaseProps, SlotRecipeProps<"fieldset">>, UnstyledProp {
+}
+export interface FieldsetRootProps extends HTMLMainbaseProps<"fieldset", FieldsetRootBaseProps> {
+}
+export declare const FieldsetRoot: import("react").ForwardRefExoticComponent<FieldsetRootProps & import("react").RefAttributes<HTMLFieldSetElement>>;
+export interface FieldsetErrorTextProps extends HTMLMainbaseProps<"span", Fieldset.ErrorTextBaseProps>, UnstyledProp {
+}
+export declare const FieldsetErrorText: import("react").ForwardRefExoticComponent<FieldsetErrorTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface FieldsetHelperTextProps extends HTMLMainbaseProps<"span", Fieldset.HelperTextBaseProps>, UnstyledProp {
+}
+export declare const FieldsetHelperText: import("react").ForwardRefExoticComponent<FieldsetHelperTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface FieldsetLegendProps extends HTMLMainbaseProps<"legend", Fieldset.LegendBaseProps>, UnstyledProp {
+}
+export declare const FieldsetLegend: import("react").ForwardRefExoticComponent<FieldsetLegendProps & import("react").RefAttributes<HTMLLegendElement>>;
+export interface FieldsetContentProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const FieldsetContent: import("react").ForwardRefExoticComponent<FieldsetContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const FieldsetContext: (props: Fieldset.ContextProps) => import("react").ReactNode;
+export {};

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

@@ -0,0 +1,4 @@
+export { FieldsetRoot, FieldsetErrorText, FieldsetHelperText, FieldsetLegend, FieldsetContent, FieldsetContext, } from "./fieldset";
+export type { FieldsetRootProps, FieldsetErrorTextProps, FieldsetHelperTextProps, FieldsetLegendProps, FieldsetContentProps, } from "./fieldset";
+export { useFieldsetContext } from "@ark-ui/react/fieldset";
+export * as Fieldset from "./namespace";

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

@@ -0,0 +1,2 @@
+export { FieldsetRoot as Root, FieldsetErrorText as ErrorText, FieldsetHelperText as HelperText, FieldsetLegend as Legend, FieldsetContent as Content, FieldsetContext as Context, } from "./fieldset";
+export type { FieldsetRootProps as RootProps, FieldsetErrorTextProps as ErrorTextProps, FieldsetHelperTextProps as HelperTextProps, FieldsetLegendProps as LegendProps, FieldsetContentProps as ContentProps, } from "./fieldset";

package/dist/types/components/file-upload/file-upload.d.ts

@@ -0,0 +1,78 @@
+import type { Assign } from "@ark-ui/react";
+import { FileUpload as ArkFileUpload } from "@ark-ui/react/file-upload";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useFileUploadStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useFileUploadStyles };
+export interface FileUploadRootProviderBaseProps extends Assign<ArkFileUpload.RootProviderBaseProps, SlotRecipeProps<"fileUpload">>, UnstyledProp {
+}
+export interface FileUploadRootProviderProps extends HTMLMainbaseProps<"div", FileUploadRootProviderBaseProps> {
+}
+export declare const FileUploadRootProvider: import("react").ForwardRefExoticComponent<FileUploadRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FileUploadRootBaseProps extends Assign<ArkFileUpload.RootBaseProps, SlotRecipeProps<"fileUpload">>, UnstyledProp {
+}
+export interface FileUploadRootProps extends HTMLMainbaseProps<"div", FileUploadRootBaseProps> {
+}
+export declare const FileUploadRoot: import("react").ForwardRefExoticComponent<FileUploadRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const FileUploadPropsProvider: React.Provider<FileUploadRootBaseProps>;
+export interface FileUploadClearTriggerProps extends HTMLMainbaseProps<"button">, UnstyledProp {
+}
+export declare const FileUploadClearTrigger: import("react").ForwardRefExoticComponent<FileUploadClearTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface FileUploadDropzoneProps extends HTMLMainbaseProps<"li", ArkFileUpload.DropzoneBaseProps>, UnstyledProp {
+}
+export declare const FileUploadDropzone: import("react").ForwardRefExoticComponent<FileUploadDropzoneProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FileUploadDropzoneContentProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const FileUploadDropzoneContent: import("react").ForwardRefExoticComponent<FileUploadDropzoneContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemProps extends HTMLMainbaseProps<"li", ArkFileUpload.ItemBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItem: import("react").ForwardRefExoticComponent<FileUploadItemProps & import("react").RefAttributes<HTMLLIElement>>;
+export interface FileUploadItemContentProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const FileUploadItemContent: import("react").ForwardRefExoticComponent<FileUploadItemContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemDeleteTriggerProps extends HTMLMainbaseProps<"button", ArkFileUpload.ItemDeleteTriggerBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItemDeleteTrigger: import("react").ForwardRefExoticComponent<FileUploadItemDeleteTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface FileUploadItemGroupProps extends HTMLMainbaseProps<"ul", ArkFileUpload.ItemGroupBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItemGroup: import("react").ForwardRefExoticComponent<FileUploadItemGroupProps & import("react").RefAttributes<HTMLUListElement>>;
+export interface FileUploadItemNameProps extends HTMLMainbaseProps<"span", ArkFileUpload.ItemNameBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItemName: import("react").ForwardRefExoticComponent<FileUploadItemNameProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface FileUploadItemPreviewProps extends HTMLMainbaseProps<"div", ArkFileUpload.ItemPreviewBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItemPreview: import("react").ForwardRefExoticComponent<FileUploadItemPreviewProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemPreviewImageProps extends HTMLMainbaseProps<"img", ArkFileUpload.ItemPreviewImageBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItemPreviewImage: import("react").ForwardRefExoticComponent<FileUploadItemPreviewImageProps & import("react").RefAttributes<HTMLImageElement>>;
+export interface FileUploadItemSizeTextProps extends HTMLMainbaseProps<"span", ArkFileUpload.ItemSizeTextBaseProps>, UnstyledProp {
+}
+export declare const FileUploadItemSizeText: import("react").ForwardRefExoticComponent<FileUploadItemSizeTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export interface FileUploadLabelProps extends HTMLMainbaseProps<"label", ArkFileUpload.LabelBaseProps>, UnstyledProp {
+}
+export declare const FileUploadLabel: import("react").ForwardRefExoticComponent<FileUploadLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+export interface FileUploadTriggerProps extends HTMLMainbaseProps<"button", ArkFileUpload.TriggerBaseProps>, UnstyledProp {
+}
+export declare const FileUploadTrigger: import("react").ForwardRefExoticComponent<FileUploadTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface FileUploadItemsBaseProps {
+    showSize?: boolean | undefined;
+    clearable?: boolean | undefined;
+    files?: File[] | undefined;
+}
+export interface FileUploadItemsProps extends Omit<FileUploadItemProps, "file">, FileUploadItemsBaseProps {
+}
+export declare const FileUploadItems: (props: FileUploadItemsProps) => import("react").JSX.Element;
+export interface FileUploadListProps extends FileUploadItemsBaseProps {
+}
+export declare const FileUploadList: import("react").ForwardRefExoticComponent<FileUploadListProps & import("react").RefAttributes<HTMLUListElement>>;
+export interface FileUploadFileTextProps extends HTMLMainbaseProps<"span"> {
+    fallback?: string | undefined;
+}
+export declare const FileUploadFileText: import("react").ForwardRefExoticComponent<FileUploadFileTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const FileUploadContext: (props: ArkFileUpload.ContextProps) => import("react").ReactNode;
+export declare const FileUploadHiddenInput: import("react").ForwardRefExoticComponent<ArkFileUpload.HiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface FileUploadFileAcceptDetails extends ArkFileUpload.FileAcceptDetails {
+}
+export interface FileUploadFileRejectDetails extends ArkFileUpload.FileRejectDetails {
+}
+export interface FileUploadFileChangeDetails extends ArkFileUpload.FileChangeDetails {
+}

package/dist/types/components/file-upload/index.d.ts

@@ -0,0 +1,5 @@
+export { FileUploadDropzone, FileUploadItem, FileUploadTrigger, FileUploadRoot, FileUploadRootProvider, FileUploadPropsProvider, FileUploadLabel, FileUploadItemPreview, FileUploadItemPreviewImage, FileUploadItemSizeText, FileUploadItemName, FileUploadHiddenInput, FileUploadFileText, FileUploadItemGroup, FileUploadItemContent, FileUploadDropzoneContent, FileUploadItemDeleteTrigger, FileUploadClearTrigger, FileUploadItems, useFileUploadStyles, FileUploadContext, FileUploadList, } from "./file-upload";
+export type { FileUploadDropzoneProps, FileUploadItemProps, FileUploadTriggerProps, FileUploadRootProps, FileUploadRootProviderProps, FileUploadLabelProps, FileUploadItemPreviewProps, FileUploadItemPreviewImageProps, FileUploadItemSizeTextProps, FileUploadItemNameProps, FileUploadFileTextProps, FileUploadItemGroupProps, FileUploadItemContentProps, FileUploadDropzoneContentProps, FileUploadItemDeleteTriggerProps, FileUploadFileAcceptDetails, FileUploadFileRejectDetails, FileUploadFileChangeDetails, FileUploadItemsProps, FileUploadClearTriggerProps, FileUploadListProps, } from "./file-upload";
+export { useFileUpload, useFileUploadContext } from "@ark-ui/react/file-upload";
+export type { UseFileUploadProps, UseFileUploadReturn, FileUploadFileError, FileUploadFileMimeType, FileUploadFileRejection, } from "@ark-ui/react/file-upload";
+export * as FileUpload from "./namespace";

package/dist/types/components/file-upload/namespace.d.ts

@@ -0,0 +1,3 @@
+export { FileUploadDropzone as Dropzone, FileUploadItem as Item, FileUploadTrigger as Trigger, FileUploadRoot as Root, FileUploadRootProvider as RootProvider, FileUploadPropsProvider as PropsProvider, FileUploadLabel as Label, FileUploadItemPreview as ItemPreview, FileUploadItemPreviewImage as ItemPreviewImage, FileUploadItemContent as ItemContent, FileUploadDropzoneContent as DropzoneContent, FileUploadItemSizeText as ItemSizeText, FileUploadItemName as ItemName, FileUploadFileText as FileText, FileUploadItemGroup as ItemGroup, FileUploadItemDeleteTrigger as ItemDeleteTrigger, FileUploadContext as Context, FileUploadHiddenInput as HiddenInput, FileUploadClearTrigger as ClearTrigger, FileUploadItems as Items, FileUploadList as List, } from "./file-upload";
+export type { FileUploadDropzoneProps as DropzoneProps, FileUploadItemProps as ItemProps, FileUploadTriggerProps as TriggerProps, FileUploadRootProps as RootProps, FileUploadRootProviderProps as RootProviderProps, FileUploadLabelProps as LabelProps, FileUploadItemPreviewProps as ItemPreviewProps, FileUploadItemPreviewImageProps as ItemPreviewImageProps, FileUploadItemSizeTextProps as ItemSizeTextProps, FileUploadItemNameProps as ItemNameProps, FileUploadFileTextProps as FileTextProps, FileUploadItemContentProps as ItemContentProps, FileUploadDropzoneContentProps as DropzoneContentProps, FileUploadItemGroupProps as ItemGroupProps, FileUploadItemDeleteTriggerProps as ItemDeleteTriggerProps, FileUploadFileAcceptDetails as FileAcceptDetails, FileUploadFileChangeDetails as FileChangeDetails, FileUploadFileRejectDetails as FileRejectDetails, FileUploadItemsProps as ItemsProps, FileUploadListProps as ListProps, } from "./file-upload";
+export type { FileUploadFileError as FileError, FileUploadFileMimeType as FileMimeType, FileUploadFileRejection as FileRejection, } from "@ark-ui/react/file-upload";

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

@@ -0,0 +1,14 @@
+import { type HTMLMainbaseProps, type SystemStyleObject } from "../../styled-system";
+export interface FlexOptions {
+    align?: SystemStyleObject["alignItems"] | undefined;
+    justify?: SystemStyleObject["justifyContent"] | undefined;
+    wrap?: SystemStyleObject["flexWrap"] | undefined;
+    direction?: SystemStyleObject["flexDirection"] | undefined;
+    basis?: SystemStyleObject["flexBasis"] | undefined;
+    grow?: SystemStyleObject["flexGrow"] | undefined;
+    shrink?: SystemStyleObject["flexShrink"] | undefined;
+    inline?: boolean | undefined;
+}
+export interface FlexProps extends HTMLMainbaseProps<"div", FlexOptions> {
+}
+export declare const Flex: import("react").ForwardRefExoticComponent<FlexProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,2 @@
+export { Flex } from "./flex";
+export type { FlexProps } from "./flex";

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

@@ -0,0 +1,23 @@
+import { type ConditionalValue, type HTMLMainbaseProps, type SystemStyleObject } from "../../styled-system";
+export interface FloatOptions {
+    /**
+     * The x offset of the indicator
+     */
+    offsetX?: SystemStyleObject["left"] | undefined;
+    /**
+     * The y offset of the indicator
+     */
+    offsetY?: SystemStyleObject["top"] | undefined;
+    /**
+     * The x and y offset of the indicator
+     */
+    offset?: SystemStyleObject["top"] | undefined;
+    /**
+     * The placement of the indicator
+     * @default "top-end"
+     */
+    placement?: ConditionalValue<"bottom-end" | "bottom-start" | "top-end" | "top-start" | "bottom-center" | "top-center" | "middle-center" | "middle-end" | "middle-start"> | undefined;
+}
+export interface FloatProps extends Omit<HTMLMainbaseProps<"div">, keyof FloatOptions>, FloatOptions {
+}
+export declare const Float: import("react").ForwardRefExoticComponent<FloatProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,2 @@
+export { Float } from "./float";
+export type { FloatProps } from "./float";

package/dist/types/components/floating-panel/floating-panel.d.ts

@@ -0,0 +1,56 @@
+import type { Assign } from "@ark-ui/react";
+import { FloatingPanel as ArkFloatingPanel } from "@ark-ui/react/floating-panel";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useFloatingPanelStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useFloatingPanelStyles };
+export interface FloatingPanelRootProviderBaseProps extends Assign<ArkFloatingPanel.RootProviderProps, SlotRecipeProps<"floatingPanel">>, UnstyledProp {
+}
+export interface FloatingPanelRootProviderProps extends FloatingPanelRootProviderBaseProps {
+    children?: React.ReactNode;
+}
+export declare const FloatingPanelRootProvider: import("react").FC<FloatingPanelRootProviderProps>;
+export interface FloatingPanelRootBaseProps extends Assign<ArkFloatingPanel.RootProps, SlotRecipeProps<"floatingPanel">>, UnstyledProp {
+}
+export interface FloatingPanelRootProps extends FloatingPanelRootBaseProps {
+    children?: React.ReactNode;
+}
+export declare const FloatingPanelRoot: import("react").FC<FloatingPanelRootProps>;
+export declare const FloatingPanelPropsProvider: React.Provider<FloatingPanelRootBaseProps>;
+export interface FloatingPanelTriggerProps extends HTMLMainbaseProps<"button", ArkFloatingPanel.TriggerBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelTrigger: import("react").ForwardRefExoticComponent<FloatingPanelTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface FloatingPanelPositionerProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.PositionerBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelPositioner: import("react").ForwardRefExoticComponent<FloatingPanelPositionerProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FloatingPanelContentProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.ContentBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelContent: import("react").ForwardRefExoticComponent<FloatingPanelContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FloatingPanelHeaderProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.HeaderBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelHeader: import("react").ForwardRefExoticComponent<FloatingPanelHeaderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FloatingPanelBodyProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.BodyBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelBody: import("react").ForwardRefExoticComponent<FloatingPanelBodyProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FloatingPanelTitleProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.TitleBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelTitle: import("react").ForwardRefExoticComponent<FloatingPanelTitleProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FloatingPanelDragTriggerProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.DragTriggerBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelDragTrigger: import("react").ForwardRefExoticComponent<FloatingPanelDragTriggerProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface FloatingPanelResizeTriggerProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.ResizeTriggerBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelResizeTrigger: import("react").ForwardRefExoticComponent<FloatingPanelResizeTriggerProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const RESIZE_AXES: readonly ["n", "s", "e", "w", "ne", "nw", "se", "sw"];
+export interface FloatingPanelResizeTriggersProps extends Omit<FloatingPanelResizeTriggerProps, "axis"> {
+    axes?: (typeof RESIZE_AXES)[number][];
+}
+export declare const FloatingPanelResizeTriggers: (props: FloatingPanelResizeTriggersProps) => import("react").JSX.Element;
+export interface FloatingPanelStageTriggerProps extends HTMLMainbaseProps<"button", ArkFloatingPanel.StageTriggerBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelStageTrigger: import("react").ForwardRefExoticComponent<FloatingPanelStageTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface FloatingPanelCloseTriggerProps extends HTMLMainbaseProps<"button", ArkFloatingPanel.CloseTriggerBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelCloseTrigger: import("react").ForwardRefExoticComponent<FloatingPanelCloseTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface FloatingPanelControlProps extends HTMLMainbaseProps<"div", ArkFloatingPanel.ControlBaseProps>, UnstyledProp {
+}
+export declare const FloatingPanelControl: import("react").ForwardRefExoticComponent<FloatingPanelControlProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/floating-panel/index.d.ts

@@ -0,0 +1,5 @@
+export { FloatingPanelRoot, FloatingPanelRootProvider, FloatingPanelPropsProvider, FloatingPanelTrigger, FloatingPanelPositioner, FloatingPanelContent, FloatingPanelHeader, FloatingPanelBody, FloatingPanelTitle, FloatingPanelDragTrigger, FloatingPanelResizeTrigger, FloatingPanelResizeTriggers, FloatingPanelStageTrigger, FloatingPanelCloseTrigger, FloatingPanelControl, useFloatingPanelStyles, } from "./floating-panel";
+export type { FloatingPanelRootProps, FloatingPanelRootProviderProps, FloatingPanelRootBaseProps, FloatingPanelRootProviderBaseProps, FloatingPanelTriggerProps, FloatingPanelPositionerProps, FloatingPanelContentProps, FloatingPanelHeaderProps, FloatingPanelBodyProps, FloatingPanelTitleProps, FloatingPanelDragTriggerProps, FloatingPanelResizeTriggerProps, FloatingPanelStageTriggerProps, FloatingPanelCloseTriggerProps, FloatingPanelControlProps, } from "./floating-panel";
+export { useFloatingPanel, useFloatingPanelContext, FloatingPanelContext, } from "@ark-ui/react/floating-panel";
+export type { UseFloatingPanelProps, UseFloatingPanelReturn, FloatingPanelOpenChangeDetails, FloatingPanelPositionChangeDetails, FloatingPanelSizeChangeDetails, FloatingPanelStageChangeDetails, } from "@ark-ui/react/floating-panel";
+export * as FloatingPanel from "./namespace";

package/dist/types/components/floating-panel/namespace.d.ts

@@ -0,0 +1,4 @@
+export { FloatingPanelBody as Body, FloatingPanelCloseTrigger as CloseTrigger, FloatingPanelContent as Content, FloatingPanelControl as Control, FloatingPanelDragTrigger as DragTrigger, FloatingPanelHeader as Header, FloatingPanelPositioner as Positioner, FloatingPanelPropsProvider as PropsProvider, FloatingPanelResizeTrigger as ResizeTrigger, FloatingPanelResizeTriggers as ResizeTriggers, FloatingPanelRoot as Root, FloatingPanelRootProvider as RootProvider, FloatingPanelStageTrigger as StageTrigger, FloatingPanelTitle as Title, FloatingPanelTrigger as Trigger, } from "./floating-panel";
+export type { FloatingPanelBodyProps as BodyProps, FloatingPanelCloseTriggerProps as CloseTriggerProps, FloatingPanelContentProps as ContentProps, FloatingPanelControlProps as ControlProps, FloatingPanelDragTriggerProps as DragTriggerProps, FloatingPanelHeaderProps as HeaderProps, FloatingPanelPositionerProps as PositionerProps, FloatingPanelResizeTriggerProps as ResizeTriggerProps, FloatingPanelRootProps as RootProps, FloatingPanelRootProviderProps as RootProviderProps, FloatingPanelStageTriggerProps as StageTriggerProps, FloatingPanelTitleProps as TitleProps, FloatingPanelTriggerProps as TriggerProps, } from "./floating-panel";
+export { FloatingPanelContext as Context } from "@ark-ui/react/floating-panel";
+export type { FloatingPanelOpenChangeDetails as OpenChangeDetails, FloatingPanelPositionChangeDetails as PositionChangeDetails, FloatingPanelSizeChangeDetails as SizeChangeDetails, FloatingPanelStageChangeDetails as StageChangeDetails, } from "@ark-ui/react/floating-panel";

package/dist/types/components/focus-trap/focus-trap.d.ts

@@ -0,0 +1,5 @@
+import { type FocusTrapBaseProps } from "@ark-ui/react/focus-trap";
+import { type HTMLMainbaseProps } from "../../styled-system";
+export interface FocusTrapProps extends HTMLMainbaseProps<"div">, FocusTrapBaseProps {
+}
+export declare const FocusTrap: import("../..").MainbaseComponent<import("react").ForwardRefExoticComponent<import("@ark-ui/react").FocusTrapProps & import("react").RefAttributes<HTMLDivElement>>, {}>;

package/dist/types/components/focus-trap/index.d.ts

@@ -0,0 +1,2 @@
+export { FocusTrap } from "./focus-trap";
+export type { FocusTrapProps } from "./focus-trap";

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

@@ -0,0 +1,16 @@
+import type { Dict } from "../../utils";
+export interface ForProps<T> {
+    /**
+     * The array to iterate over
+     */
+    each: T[] | readonly T[] | undefined;
+    /**
+     * The fallback content to render when the array is empty
+     */
+    fallback?: React.ReactNode | undefined;
+    /**
+     * The function to render each item in the array
+     */
+    children: (item: Exclude<T, undefined>, index: number) => React.ReactNode;
+}
+export declare function For<T extends string | number | Dict | undefined>(props: ForProps<T>): React.ReactNode;

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

@@ -0,0 +1,2 @@
+export { For } from "./for";
+export type { ForProps } from "./for";

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

@@ -0,0 +1,13 @@
+import { Format } from "@ark-ui/react/format";
+export declare const FormatNumber: {
+    (props: Format.NumberProps): import("react").JSX.Element;
+    displayName: string;
+};
+export declare const FormatByte: {
+    (props: Format.ByteProps): import("react").JSX.Element;
+    displayName: string;
+};
+export interface FormatNumberProps extends Format.NumberProps {
+}
+export interface FormatByteProps extends Format.ByteProps {
+}

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

@@ -0,0 +1,12 @@
+import { type ConditionalValue, type SystemStyleObject } from "../../styled-system";
+import type { BoxProps } from "../box";
+export interface GridItemProps extends BoxProps {
+    area?: SystemStyleObject["gridArea"] | undefined;
+    colSpan?: ConditionalValue<number | "auto"> | undefined;
+    colStart?: ConditionalValue<number | "auto"> | undefined;
+    colEnd?: ConditionalValue<number | "auto"> | undefined;
+    rowStart?: ConditionalValue<number | "auto"> | undefined;
+    rowEnd?: ConditionalValue<number | "auto"> | undefined;
+    rowSpan?: ConditionalValue<number | "auto"> | undefined;
+}
+export declare const GridItem: import("react").ForwardRefExoticComponent<GridItemProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,15 @@
+import { type HTMLMainbaseProps, type SystemStyleObject } from "../../styled-system";
+export interface GridBaseProps {
+    templateColumns?: SystemStyleObject["gridTemplateColumns"] | undefined;
+    autoFlow?: SystemStyleObject["gridAutoFlow"] | undefined;
+    autoRows?: SystemStyleObject["gridAutoRows"] | undefined;
+    autoColumns?: SystemStyleObject["gridAutoColumns"] | undefined;
+    templateRows?: SystemStyleObject["gridTemplateRows"] | undefined;
+    templateAreas?: SystemStyleObject["gridTemplateAreas"] | undefined;
+    column?: SystemStyleObject["gridColumn"] | undefined;
+    row?: SystemStyleObject["gridRow"] | undefined;
+    inline?: boolean | undefined;
+}
+export interface GridProps extends HTMLMainbaseProps<"div", GridBaseProps> {
+}
+export declare const Grid: import("react").ForwardRefExoticComponent<GridProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,4 @@
+export { Grid } from "./grid";
+export type { GridProps } from "./grid";
+export { GridItem } from "./grid-item";
+export type { GridItemProps } from "./grid-item";

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

@@ -0,0 +1,28 @@
+import { type HTMLMainbaseProps, type InferRecipeProps, type JsxStyleProps } from "../../styled-system";
+declare const StyledGroup: import("../..").MainbaseComponent<"div", {
+    orientation?: import("../..").ConditionalValue<"horizontal" | "vertical" | undefined>;
+    attached?: import("../..").ConditionalValue<boolean | undefined>;
+    grow?: import("../..").ConditionalValue<boolean | undefined>;
+    stacking?: import("../..").ConditionalValue<"first-on-top" | "last-on-top" | undefined>;
+}>;
+type VariantProps = InferRecipeProps<typeof StyledGroup>;
+export interface GroupProps extends HTMLMainbaseProps<"div", VariantProps> {
+    /**
+     * The `alignItems` style property
+     */
+    align?: JsxStyleProps["alignItems"] | undefined;
+    /**
+     * The `justifyContent` style property
+     */
+    justify?: JsxStyleProps["justifyContent"] | undefined;
+    /**
+     * The `flexWrap` style property
+     */
+    wrap?: JsxStyleProps["flexWrap"] | undefined;
+    /**
+     * A function that determines if a child should be skipped
+     */
+    skip?: (child: React.ReactElement) => boolean | undefined;
+}
+export declare const Group: import("react").NamedExoticComponent<GroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1 @@
+export * from "./group";

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

@@ -0,0 +1,6 @@
+import type { Assign } from "@ark-ui/react";
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+export interface HeadingProps extends Assign<HTMLMainbaseProps<"h2">, RecipeProps<"heading">>, UnstyledProp {
+}
+export declare const Heading: import("react").ForwardRefExoticComponent<HeadingProps & import("react").RefAttributes<HTMLHeadingElement>>;
+export declare const HeadingPropsProvider: React.Provider<HeadingProps>;

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

@@ -0,0 +1,16 @@
+import { type HighlightChunk } from "@ark-ui/react/highlight";
+import { type JSX } from "react";
+import { type SystemStyleObject } from "../../styled-system";
+export interface HighlightProps {
+    query: string | string[];
+    children: string | ((props: HighlightChunk[]) => React.ReactNode);
+    styles?: SystemStyleObject | undefined;
+    ignoreCase?: boolean | undefined;
+    matchAll?: boolean | undefined;
+}
+/**
+ * `Highlight` allows you to highlight substrings of a text.
+ *
+ * @see Docs https://mainbase-ui.com/docs/components/highlight
+ */
+export declare function Highlight(props: HighlightProps): JSX.Element;

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

@@ -0,0 +1,4 @@
+export { Highlight } from "./highlight";
+export type { HighlightProps } from "./highlight";
+export { useHighlight } from "@ark-ui/react/highlight";
+export type { HighlightChunk, UseHighlightProps } from "@ark-ui/react/highlight";

package/dist/types/components/hover-card/hover-card.d.ts

@@ -0,0 +1,36 @@
+import type { Assign } from "@ark-ui/react";
+import { HoverCard as ArkHoverCard } from "@ark-ui/react/hover-card";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useHoverCardStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useHoverCardStyles };
+export interface HoverCardRootProviderBaseProps extends Assign<ArkHoverCard.RootProviderBaseProps, SlotRecipeProps<"hoverCard">>, UnstyledProp {
+}
+export interface HoverCardRootProviderProps extends HoverCardRootProviderBaseProps {
+    children: React.ReactNode;
+}
+export declare const HoverCardRootProvider: import("react").FC<HoverCardRootProviderProps>;
+export interface HoverCardRootBaseProps extends Assign<ArkHoverCard.RootBaseProps, SlotRecipeProps<"hoverCard">>, UnstyledProp {
+}
+export interface HoverCardRootProps extends HoverCardRootBaseProps {
+    children: React.ReactNode;
+}
+export declare const HoverCardRoot: import("react").FC<HoverCardRootProps>;
+export declare const HoverCardPropsProvider: React.Provider<HoverCardRootBaseProps>;
+export interface HoverCardTriggerProps extends HTMLMainbaseProps<"button", ArkHoverCard.TriggerBaseProps>, UnstyledProp {
+}
+export declare const HoverCardTrigger: import("react").ForwardRefExoticComponent<HoverCardTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface HoverCardPositionerProps extends HTMLMainbaseProps<"div", ArkHoverCard.PositionerBaseProps>, UnstyledProp {
+}
+export declare const HoverCardPositioner: import("react").ForwardRefExoticComponent<HoverCardPositionerProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface HoverCardContentProps extends HTMLMainbaseProps<"section", ArkHoverCard.ContentBaseProps>, UnstyledProp {
+}
+export declare const HoverCardContent: import("react").ForwardRefExoticComponent<HoverCardContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface HoverCardArrowTipProps extends HTMLMainbaseProps<"div", ArkHoverCard.ArrowTipBaseProps>, UnstyledProp {
+}
+export declare const HoverCardArrowTip: import("react").ForwardRefExoticComponent<HoverCardArrowTipProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface HoverCardArrowProps extends HTMLMainbaseProps<"div", ArkHoverCard.ArrowBaseProps>, UnstyledProp {
+}
+export declare const HoverCardArrow: import("react").ForwardRefExoticComponent<HoverCardArrowProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const HoverCardContext: (props: ArkHoverCard.ContextProps) => import("react").ReactNode;
+export interface HoverCardOpenChangeDetails extends ArkHoverCard.OpenChangeDetails {
+}