@ark-ui/react 0.0.0-rc-20221106094212

package/dist/index.d.ts

@@ -0,0 +1,612 @@
+import * as _polymorphic_factory_react from '@polymorphic-factory/react';
+import { HTMLPolymorphicProps } from '@polymorphic-factory/react';
+import * as react from 'react';
+import { ElementType, PropsWithChildren, ReactElement, ReactNode } from 'react';
+import * as accordion from '@zag-js/accordion';
+import * as checkbox from '@zag-js/checkbox';
+import * as dialog from '@zag-js/dialog';
+import { PortalProps } from '@reach/portal';
+import * as editable from '@zag-js/editable';
+import * as numberInput from '@zag-js/number-input';
+import * as pagination from '@zag-js/pagination';
+import * as pinInput from '@zag-js/pin-input';
+import * as popover from '@zag-js/popover';
+import * as pressable from '@zag-js/pressable';
+import * as radio from '@zag-js/radio';
+import { connect } from '@zag-js/radio';
+import * as rating from '@zag-js/rating';
+import { connect as connect$1 } from '@zag-js/rating';
+import * as tabs from '@zag-js/tabs';
+import { connect as connect$2 } from '@zag-js/tabs';
+import * as tooltip from '@zag-js/tooltip';
+
+declare type HTMLAtlasProps<T extends ElementType> = HTMLPolymorphicProps<T>;
+
+/**
+ * Assign property types from right to left.
+ * Handy for overriding e.g. `onChange` from an HTMLElement with your own type
+ */
+declare type Assign<Target, Source> = Omit<Target, keyof Source> & Source;
+
+declare type UseAccordionProps = Omit<accordion.Context, 'id'> & {
+    defaultValue?: accordion.Context['value'];
+};
+declare type UseAccordionReturn = ReturnType<typeof useAccordion>;
+declare const useAccordion: (props: UseAccordionProps) => {
+    value: string | string[] | null;
+    setValue(value: string | string[]): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    getItemState(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): {
+        isOpen: boolean;
+        isFocused: boolean;
+        isDisabled: boolean;
+    };
+    getItemProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): react.HTMLAttributes<HTMLElement>;
+    getContentProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): react.HTMLAttributes<HTMLElement>;
+    getTriggerProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};
+
+declare type AccordionProps = Assign<HTMLAtlasProps<'div'>, UseAccordionProps>;
+declare const Accordion: _polymorphic_factory_react.ComponentWithAs<"div", AccordionProps>;
+
+declare type AccordionButtonProps = HTMLAtlasProps<'button'>;
+declare const AccordionButton: _polymorphic_factory_react.ComponentWithAs<"button", AccordionButtonProps>;
+
+declare type AccordionIconProps = HTMLAtlasProps<'div'>;
+declare const AccordionIcon: _polymorphic_factory_react.ComponentWithAs<"div", AccordionIconProps>;
+
+declare type AccordionContext = UseAccordionReturn;
+
+declare type AccordionItemProps = HTMLAtlasProps<'div'> & {
+    value: string;
+    disabled?: boolean;
+    children?: React.ReactNode | ((props: ReturnType<AccordionContext['getItemState']>) => React.ReactNode);
+};
+declare const AccordionItem: _polymorphic_factory_react.ComponentWithAs<"div", AccordionItemProps>;
+
+declare type AccordionItemContext = ReturnType<AccordionContext['getItemState']> & {
+    value: string;
+    disabled?: boolean;
+};
+declare const useAccordionItemContext: () => AccordionItemContext;
+
+declare type AccordionPanelProps = HTMLAtlasProps<'div'>;
+declare const AccordionPanel: _polymorphic_factory_react.ComponentWithAs<"div", AccordionPanelProps>;
+
+declare type UseCheckboxProps = Omit<checkbox.Context, 'id'> & {
+    defaultValue?: checkbox.Context['value'];
+};
+declare type UseCheckboxReturn = ReturnType<typeof useCheckbox>;
+declare const useCheckbox: (props: UseCheckboxProps) => {
+    isChecked: boolean;
+    isDisabled: boolean | undefined;
+    isIndeterminate: boolean | undefined;
+    isFocused: boolean;
+    isReadOnly: boolean | undefined;
+    view: string;
+    setChecked(checked: boolean): void;
+    setIndeterminate(indeterminate: boolean): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    labelProps: react.DetailedHTMLProps<react.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    controlProps: react.HTMLAttributes<HTMLElement>;
+    inputProps: react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+};
+
+declare type CheckboxProps = Assign<HTMLAtlasProps<'label'>, UseCheckboxProps>;
+declare const Checkbox: _polymorphic_factory_react.ComponentWithAs<"label", CheckboxProps>;
+
+declare type CheckboxControlProps = HTMLAtlasProps<'div'>;
+declare const CheckboxControl: _polymorphic_factory_react.ComponentWithAs<"div", CheckboxControlProps>;
+
+declare type CheckboxInputProps = HTMLAtlasProps<'input'>;
+declare const CheckboxInput: _polymorphic_factory_react.ComponentWithAs<"input", CheckboxInputProps>;
+
+declare type CheckboxLabelProps = HTMLAtlasProps<'label'>;
+declare const CheckboxLabel: _polymorphic_factory_react.ComponentWithAs<"label", CheckboxLabelProps>;
+
+declare type UseDialogProps = Omit<dialog.Context, 'id'>;
+
+declare type DialogProps = PropsWithChildren<UseDialogProps>;
+declare const Dialog: (props: DialogProps) => JSX.Element;
+
+declare type DialogBackdropProps = HTMLAtlasProps<'div'>;
+declare const DialogBackdrop: _polymorphic_factory_react.ComponentWithAs<"div", DialogBackdropProps>;
+
+declare type DialogCloseButtonProps = HTMLAtlasProps<'button'>;
+declare const DialogCloseButton: _polymorphic_factory_react.ComponentWithAs<"button", DialogCloseButtonProps>;
+
+declare type DialogContentProps = HTMLAtlasProps<'div'>;
+declare const DialogContent: _polymorphic_factory_react.ComponentWithAs<"div", DialogContentProps>;
+
+declare type DialogDescriptionProps = HTMLAtlasProps<'p'>;
+declare const DialogDescription: _polymorphic_factory_react.ComponentWithAs<"p", DialogDescriptionProps>;
+
+declare type DialogPortalProps = PortalProps;
+declare const DialogPortal: (props: DialogPortalProps) => JSX.Element | null;
+
+declare type DialogTitleProps = HTMLAtlasProps<'h2'>;
+declare const DialogTitle: _polymorphic_factory_react.ComponentWithAs<"h2", DialogTitleProps>;
+
+declare type DialogTriggerProps = {
+    children: ReactElement | string | number;
+};
+declare const DialogTrigger: (props: DialogTriggerProps) => JSX.Element;
+
+declare type DialogUnderlayProps = HTMLAtlasProps<'div'>;
+declare const DialogUnderlay: _polymorphic_factory_react.ComponentWithAs<"div", DialogUnderlayProps>;
+
+declare type UseEditableProps = Omit<editable.Context, 'id'> & {
+    defaultValue?: editable.Context['value'];
+};
+declare type UseEditableReturn = ReturnType<typeof useEditable>;
+declare const useEditable: (props: UseEditableProps) => {
+    isEditing: boolean;
+    isValueEmpty: boolean;
+    value: string;
+    setValue(value: string): void;
+    clearValue(): void;
+    edit(): void;
+    cancel(): void;
+    submit(): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    areaProps: react.HTMLAttributes<HTMLElement>;
+    labelProps: react.DetailedHTMLProps<react.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    inputProps: react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    previewProps: react.HTMLAttributes<HTMLElement>;
+    editButtonProps: react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    controlGroupProps: react.HTMLAttributes<HTMLElement>;
+    submitButtonProps: react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    cancelButtonProps: react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};
+
+declare type EditableProps = Assign<HTMLAtlasProps<'div'>, UseEditableProps>;
+declare const Editable: _polymorphic_factory_react.ComponentWithAs<"div", EditableProps>;
+
+declare type EditableAreaProps = HTMLAtlasProps<'div'>;
+declare const EditableArea: _polymorphic_factory_react.ComponentWithAs<"div", EditableAreaProps>;
+
+declare type EditableCancelButtonProps = HTMLAtlasProps<'button'>;
+declare const EditableCancelButton: _polymorphic_factory_react.ComponentWithAs<"button", EditableCancelButtonProps>;
+
+declare type EditableContext = UseEditableReturn;
+
+declare type EditableControlsProps = Omit<HTMLAtlasProps<'div'>, 'children'> & {
+    children: (context: EditableContext) => ReactNode;
+};
+declare const EditableControls: _polymorphic_factory_react.ComponentWithAs<"div", EditableControlsProps>;
+
+declare type EditableEditButtonProps = HTMLAtlasProps<'button'>;
+declare const EditableEditButton: _polymorphic_factory_react.ComponentWithAs<"button", EditableEditButtonProps>;
+
+declare type EditableInputProps = HTMLAtlasProps<'input'>;
+declare const EditableInput: _polymorphic_factory_react.ComponentWithAs<"input", EditableInputProps>;
+
+declare type EditablePreviewProps = HTMLAtlasProps<'span'>;
+declare const EditablePreview: _polymorphic_factory_react.ComponentWithAs<"span", EditablePreviewProps>;
+
+declare type EditableSubmitButtonProps = HTMLAtlasProps<'button'>;
+declare const EditableSubmitButton: _polymorphic_factory_react.ComponentWithAs<"button", EditableSubmitButtonProps>;
+
+declare type UseNumberInputProps = Omit<numberInput.Context, 'id'> & {
+    defaultValue?: numberInput.Context['value'];
+};
+
+declare type NumberInputProps = Assign<HTMLAtlasProps<'div'>, UseNumberInputProps>;
+declare const NumberInput: _polymorphic_factory_react.ComponentWithAs<"div", NumberInputProps>;
+
+declare type NumberInputDecrementButtonProps = HTMLAtlasProps<'button'>;
+declare const NumberInputDecrementButton: _polymorphic_factory_react.ComponentWithAs<"button", NumberInputDecrementButtonProps>;
+
+declare type NumberInputFieldProps = HTMLAtlasProps<'input'>;
+declare const NumberInputField: _polymorphic_factory_react.ComponentWithAs<"input", NumberInputFieldProps>;
+
+declare type NumberInputIncrementButtonProps = HTMLAtlasProps<'button'>;
+declare const NumberInputIncrementButton: _polymorphic_factory_react.ComponentWithAs<"button", NumberInputIncrementButtonProps>;
+
+declare type UsePaginationProps = Omit<pagination.Context, 'id'>;
+declare const usePagination: (props: UsePaginationProps) => {
+    page: number;
+    totalPages: number;
+    pages: ({
+        type: "ellipsis";
+    } | {
+        type: "page";
+        value: number;
+    })[];
+    previousPage: number | null;
+    nextPage: number | null;
+    pageRange: {
+        start: number;
+        end: number;
+    };
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    setCount(count: number): void;
+    setPageSize(size: number): void;
+    setPage(page: number): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    getEllipsisProps(props: {
+        index: number;
+    }): react.HTMLAttributes<HTMLElement>;
+    getItemProps(page: {
+        type: "page";
+        value: number;
+    }): react.HTMLAttributes<HTMLElement>;
+    prevItemProps: react.HTMLAttributes<HTMLElement>;
+    nextItemProps: react.HTMLAttributes<HTMLElement>;
+};
+declare type UsePaginationReturn = ReturnType<typeof usePagination>;
+
+declare type PaginationProps = Assign<Assign<HTMLAtlasProps<'nav'>, UsePaginationProps>, {
+    children: ReactNode | ((pages: UsePaginationReturn) => ReactNode);
+}>;
+declare const Pagination: _polymorphic_factory_react.ComponentWithAs<"nav", PaginationProps>;
+
+declare type PaginationContext = UsePaginationReturn;
+declare const PaginationProvider: react.Provider<{
+    page: number;
+    totalPages: number;
+    pages: ({
+        type: "ellipsis";
+    } | {
+        type: "page";
+        value: number;
+    })[];
+    previousPage: number | null;
+    nextPage: number | null;
+    pageRange: {
+        start: number;
+        end: number;
+    };
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    setCount(count: number): void;
+    setPageSize(size: number): void;
+    setPage(page: number): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    getEllipsisProps(props: {
+        index: number;
+    }): react.HTMLAttributes<HTMLElement>;
+    getItemProps(page: {
+        type: "page";
+        value: number;
+    }): react.HTMLAttributes<HTMLElement>;
+    prevItemProps: react.HTMLAttributes<HTMLElement>;
+    nextItemProps: react.HTMLAttributes<HTMLElement>;
+}>;
+declare const usePaginationContext: () => {
+    page: number;
+    totalPages: number;
+    pages: ({
+        type: "ellipsis";
+    } | {
+        type: "page";
+        value: number;
+    })[];
+    previousPage: number | null;
+    nextPage: number | null;
+    pageRange: {
+        start: number;
+        end: number;
+    };
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    setCount(count: number): void;
+    setPageSize(size: number): void;
+    setPage(page: number): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    getEllipsisProps(props: {
+        index: number;
+    }): react.HTMLAttributes<HTMLElement>;
+    getItemProps(page: {
+        type: "page";
+        value: number;
+    }): react.HTMLAttributes<HTMLElement>;
+    prevItemProps: react.HTMLAttributes<HTMLElement>;
+    nextItemProps: react.HTMLAttributes<HTMLElement>;
+};
+
+declare type PaginationEllipsisProps = Assign<HTMLAtlasProps<'span'>, {
+    index: number;
+}>;
+declare const PaginationEllipsis: _polymorphic_factory_react.ComponentWithAs<"span", PaginationEllipsisProps>;
+
+declare type PaginationItemProps = Assign<HTMLAtlasProps<'a'>, {
+    value: number;
+}>;
+declare const PaginationItem: _polymorphic_factory_react.ComponentWithAs<"a", PaginationItemProps>;
+
+declare type PaginationNextItemProps = HTMLAtlasProps<'a'>;
+declare const PaginationNextItem: _polymorphic_factory_react.ComponentWithAs<"a", PaginationNextItemProps>;
+
+declare type PaginationPrevItemProps = HTMLAtlasProps<'a'>;
+declare const PaginationPrevItem: _polymorphic_factory_react.ComponentWithAs<"a", PaginationPrevItemProps>;
+
+declare type UsePinInputProps = Omit<pinInput.Context, 'id'> & {
+    defaultValue?: pinInput.Context['value'];
+};
+declare const usePinInput: (props: UsePinInputProps) => {
+    value: string[];
+    valueAsString: string;
+    isValueComplete: boolean;
+    setValue(value: string[]): void;
+    clearValue(): void;
+    setValueAtIndex(index: number, value: string): void;
+    focus: () => void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    labelProps: react.DetailedHTMLProps<react.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    hiddenInputProps: react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    getInputProps({ index }: {
+        index: number;
+    }): react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+};
+declare type UsePinInputReturn = ReturnType<typeof usePinInput>;
+
+declare type PinInputProps = Assign<HTMLAtlasProps<'div'>, UsePinInputProps>;
+declare const PinInput: _polymorphic_factory_react.ComponentWithAs<"div", PinInputProps>;
+
+declare type PinInputFieldProps = {
+    index: number;
+} & HTMLAtlasProps<'input'>;
+declare const PinInputField: _polymorphic_factory_react.ComponentWithAs<"input", PinInputFieldProps>;
+
+declare type UsePopoverProps = Omit<popover.Context, 'id'>;
+declare const usePopover: (props: UsePopoverProps) => {
+    portalled: boolean;
+    isOpen: boolean;
+    open(): void;
+    close(): void;
+    arrowProps: react.HTMLAttributes<HTMLElement>;
+    innerArrowProps: react.HTMLAttributes<HTMLElement>;
+    anchorProps: react.HTMLAttributes<HTMLElement>;
+    triggerProps: react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    positionerProps: react.HTMLAttributes<HTMLElement>;
+    contentProps: react.HTMLAttributes<HTMLElement>;
+    titleProps: react.HTMLAttributes<HTMLElement>;
+    descriptionProps: react.HTMLAttributes<HTMLElement>;
+    closeButtonProps: react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};
+declare type UsePopoverReturn = ReturnType<typeof usePopover>;
+
+declare type PopoverProps = PropsWithChildren<UsePopoverProps>;
+declare const Popover: (props: PopoverProps) => JSX.Element;
+
+declare type PopoverArrowProps = HTMLAtlasProps<'div'>;
+declare const PopoverArrow: _polymorphic_factory_react.ComponentWithAs<"div", PopoverArrowProps>;
+
+declare type PopoverCloseButtonProps = HTMLAtlasProps<'button'>;
+declare const PopoverCloseButton: _polymorphic_factory_react.ComponentWithAs<"button", PopoverCloseButtonProps>;
+
+declare type PopoverContentProps = HTMLAtlasProps<'div'>;
+declare const PopoverContent: _polymorphic_factory_react.ComponentWithAs<"div", PopoverContentProps>;
+
+declare type PopoverDescriptionProps = HTMLAtlasProps<'div'>;
+declare const PopoverDescription: _polymorphic_factory_react.ComponentWithAs<"div", PopoverDescriptionProps>;
+
+declare type PopoverInnerArrowProps = HTMLAtlasProps<'div'>;
+declare const PopoverInnerArrow: _polymorphic_factory_react.ComponentWithAs<"div", PopoverInnerArrowProps>;
+
+declare type PopoverPositionerProps = HTMLAtlasProps<'div'>;
+declare const PopoverPositioner: _polymorphic_factory_react.ComponentWithAs<"div", PopoverPositionerProps>;
+
+declare type PopoverTitleProps = HTMLAtlasProps<'div'>;
+declare const PopoverTitle: _polymorphic_factory_react.ComponentWithAs<"div", PopoverTitleProps>;
+
+declare type PopoverTriggerProps = {
+    children: ReactElement | string | number;
+};
+declare const PopoverTrigger: (props: PopoverTriggerProps) => JSX.Element;
+
+declare type UsePressableProps = Omit<pressable.Context, 'id'>;
+declare type UsePressableReturn = ReturnType<typeof usePressable>;
+declare const usePressable: (props: UsePressableProps) => {
+    isPressed: boolean;
+    pressableProps: react.HTMLAttributes<HTMLElement>;
+};
+
+declare type PressableProps = Assign<HTMLAtlasProps<'button'>, UsePressableProps>;
+declare const Pressable: _polymorphic_factory_react.ComponentWithAs<"button", PressableProps>;
+
+declare type RadioContext = Parameters<ReturnType<typeof connect>['getItemProps']>[0];
+
+declare type RadioProps = Omit<HTMLAtlasProps<'label'>, keyof RadioContext> & RadioContext;
+declare const Radio: _polymorphic_factory_react.ComponentWithAs<"label", RadioProps>;
+
+declare type RadioControlProps = HTMLAtlasProps<'div'>;
+declare const RadioControl: _polymorphic_factory_react.ComponentWithAs<"div", RadioControlProps>;
+
+declare type UseRadioGroupProps = Omit<radio.Context, 'id'> & {
+    defaultValue?: radio.Context['value'];
+};
+declare type UseRadioGroupReturn = ReturnType<typeof useRadioGroup>;
+declare const useRadioGroup: (props: UseRadioGroupProps) => {
+    value: string | null;
+    setValue(value: string): void;
+    focus: () => void;
+    blur(): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    labelProps: react.HTMLAttributes<HTMLElement>;
+    getItemProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+        readonly?: boolean | undefined;
+        invalid?: boolean | undefined;
+    }): react.DetailedHTMLProps<react.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    getItemLabelProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+        readonly?: boolean | undefined;
+        invalid?: boolean | undefined;
+    }): react.HTMLAttributes<HTMLElement>;
+    getItemControlProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+        readonly?: boolean | undefined;
+        invalid?: boolean | undefined;
+    }): react.HTMLAttributes<HTMLElement>;
+    getItemInputProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+        readonly?: boolean | undefined;
+        invalid?: boolean | undefined;
+    } & {
+        focusable?: boolean | undefined;
+        required?: boolean | undefined;
+    }): react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+};
+
+declare type RadioGroupProps = Assign<HTMLAtlasProps<'div'>, UseRadioGroupProps>;
+declare const RadioGroup: _polymorphic_factory_react.ComponentWithAs<"div", UseRadioGroupProps>;
+
+declare type RadioGroupLabelProps = HTMLAtlasProps<'label'>;
+declare const RadioGroupLabel: _polymorphic_factory_react.ComponentWithAs<"label", RadioGroupLabelProps>;
+
+declare type RadioInputProps = HTMLAtlasProps<'input'>;
+declare const RadioInput: _polymorphic_factory_react.ComponentWithAs<"input", RadioInputProps>;
+
+declare type RadioLabelProps = HTMLAtlasProps<'span'>;
+declare const RadioLabel: _polymorphic_factory_react.ComponentWithAs<"span", RadioLabelProps>;
+
+declare type UseRatingProps = Omit<rating.Context, 'id'> & {
+    defaultValue?: rating.Context['value'];
+};
+declare type UseRatingReturn = ReturnType<typeof useRating>;
+declare const useRating: (props: UseRatingProps) => {
+    isHovering: boolean;
+    value: number;
+    hoveredValue: number;
+    size: number;
+    sizeArray: number[];
+    getRatingState(index: number): {
+        isEqual: boolean;
+        isValueEmpty: boolean;
+        isHighlighted: boolean;
+        isHalf: boolean;
+        isChecked: boolean;
+    };
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    inputProps: react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    labelProps: react.HTMLAttributes<HTMLElement>;
+    itemGroupProps: react.HTMLAttributes<HTMLElement>;
+    getItemProps({ index }: {
+        index: number;
+    }): react.HTMLAttributes<HTMLElement>;
+};
+
+declare type RatingProps = Assign<HTMLAtlasProps<'input'>, UseRatingProps>;
+declare const Rating: _polymorphic_factory_react.ComponentWithAs<"input", RatingProps>;
+
+declare type RatingContext = UseRatingReturn;
+
+declare type RatingGroupProps = Omit<HTMLAtlasProps<'div'>, 'children'> & {
+    children: ReactNode | ((context: RatingContext) => ReactNode);
+    renderIcon?: never;
+};
+declare const RatingGroup: _polymorphic_factory_react.ComponentWithAs<"div", RatingGroupProps>;
+
+declare type RatingItemContext = ReturnType<ReturnType<typeof connect$1>['getRatingState']>;
+
+declare type RenderIconFn = (state: RatingItemContext) => ReactNode;
+declare type RatingItemProps = Omit<HTMLAtlasProps<'span'>, 'children'> & {
+    index: number;
+    children: ReactNode | RenderIconFn;
+};
+declare const RatingItem: _polymorphic_factory_react.ComponentWithAs<"span", RatingItemProps>;
+
+declare type RatingLabelProps = HTMLAtlasProps<'label'>;
+declare const RatingLabel: _polymorphic_factory_react.ComponentWithAs<"label", RatingLabelProps>;
+
+declare type TabProps = Assign<HTMLAtlasProps<'button'>, Parameters<ReturnType<typeof connect$2>['getTriggerProps']>[0]>;
+declare const Tab: _polymorphic_factory_react.ComponentWithAs<"button", TabProps>;
+
+declare type TabIndicatorProps = HTMLAtlasProps<'div'>;
+declare const TabIndicator: _polymorphic_factory_react.ComponentWithAs<"div", TabIndicatorProps>;
+
+declare type TabListProps = HTMLAtlasProps<'div'>;
+declare const TabList: _polymorphic_factory_react.ComponentWithAs<"div", TabListProps>;
+
+declare type TabPanelProps = Assign<HTMLAtlasProps<'div'>, Parameters<ReturnType<typeof connect$2>['getContentProps']>[0]>;
+declare const TabPanel: _polymorphic_factory_react.ComponentWithAs<"div", TabPanelProps>;
+
+declare type TabPanelsProps = HTMLAtlasProps<'div'>;
+declare const TabPanels: _polymorphic_factory_react.ComponentWithAs<"div", TabPanelsProps>;
+
+declare type UseTabsProps = Omit<tabs.Context, 'id'>;
+declare type UseTabsReturn = ReturnType<typeof useTabs>;
+declare const useTabs: (props: UseTabsProps) => {
+    value: string | null;
+    focusedValue: string | null;
+    previousValues: string[];
+    setValue(value: string): void;
+    rootProps: react.HTMLAttributes<HTMLElement>;
+    triggerGroupProps: react.HTMLAttributes<HTMLElement>;
+    getTriggerProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    contentGroupProps: react.HTMLAttributes<HTMLElement>;
+    getContentProps({ value }: {
+        value: string;
+    }): react.HTMLAttributes<HTMLElement>;
+    getDeleteButtonProps({ value, disabled }: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    indicatorProps: react.HTMLAttributes<HTMLElement>;
+};
+
+declare type TabsProps = Assign<HTMLAtlasProps<'div'>, UseTabsProps>;
+declare const Tabs: _polymorphic_factory_react.ComponentWithAs<"div", TabsProps>;
+
+declare type UseTooltipProps = Omit<tooltip.Context, 'id'>;
+declare const useTooltip: (props: UseTooltipProps) => {
+    isOpen: boolean;
+    open(): void;
+    close(): void;
+    getAnimationState(): {
+        enter: boolean;
+        exit: boolean;
+    };
+    triggerProps: react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    arrowProps: react.HTMLAttributes<HTMLElement>;
+    innerArrowProps: react.HTMLAttributes<HTMLElement>;
+    positionerProps: react.HTMLAttributes<HTMLElement>;
+    contentProps: react.HTMLAttributes<HTMLElement>;
+    labelProps: react.HTMLAttributes<HTMLElement>;
+    createPortal(): HTMLElement;
+};
+declare type UseTooltipReturn = ReturnType<typeof useTooltip>;
+
+declare type TooltipProps = PropsWithChildren<UseTooltipProps>;
+declare const Tooltip: (props: TooltipProps) => JSX.Element;
+
+declare type TooltipArrowProps = HTMLAtlasProps<'div'>;
+declare const TooltipArrow: _polymorphic_factory_react.ComponentWithAs<"div", TooltipArrowProps>;
+
+declare type TooltipContentProps = HTMLAtlasProps<'div'>;
+declare const TooltipContent: _polymorphic_factory_react.ComponentWithAs<"div", TooltipContentProps>;
+
+declare type TooltipInnerArrowProps = HTMLAtlasProps<'div'>;
+declare const TooltipInnerArrow: _polymorphic_factory_react.ComponentWithAs<"div", TooltipInnerArrowProps>;
+
+declare type TooltipPositionerProps = HTMLAtlasProps<'div'>;
+declare const TooltipPositioner: _polymorphic_factory_react.ComponentWithAs<"div", TooltipPositionerProps>;
+
+declare type TooltipTriggerProps = {
+    children: ReactElement | string | number;
+};
+declare const TooltipTrigger: (props: TooltipTriggerProps) => JSX.Element;
+
+export { Accordion, AccordionButton, AccordionButtonProps, AccordionIcon, AccordionIconProps, AccordionItem, AccordionItemContext, AccordionItemProps, AccordionPanel, AccordionPanelProps, AccordionProps, Checkbox, CheckboxControl, CheckboxControlProps, CheckboxInput, CheckboxInputProps, CheckboxLabel, CheckboxLabelProps, CheckboxProps, Dialog, DialogBackdrop, DialogBackdropProps, DialogCloseButton, DialogCloseButtonProps, DialogContent, DialogContentProps, DialogDescription, DialogDescriptionProps, DialogPortal, DialogPortalProps, DialogProps, DialogTitle, DialogTitleProps, DialogTrigger, DialogTriggerProps, DialogUnderlay, DialogUnderlayProps, Editable, EditableArea, EditableAreaProps, EditableCancelButton, EditableCancelButtonProps, EditableControls, EditableControlsProps, EditableEditButton, EditableEditButtonProps, EditableInput, EditableInputProps, EditablePreview, EditablePreviewProps, EditableProps, EditableSubmitButton, EditableSubmitButtonProps, NumberInput, NumberInputDecrementButton, NumberInputDecrementButtonProps, NumberInputField, NumberInputFieldProps, NumberInputIncrementButton, NumberInputIncrementButtonProps, NumberInputProps, Pagination, PaginationContext, PaginationEllipsis, PaginationEllipsisProps, PaginationItem, PaginationItemProps, PaginationNextItem, PaginationNextItemProps, PaginationPrevItem, PaginationPrevItemProps, PaginationProps, PaginationProvider, PinInput, PinInputField, PinInputFieldProps, PinInputProps, Popover, PopoverArrow, PopoverArrowProps, PopoverCloseButton, PopoverCloseButtonProps, PopoverContent, PopoverContentProps, PopoverDescription, PopoverDescriptionProps, PopoverInnerArrow, PopoverInnerArrowProps, PopoverPositioner, PopoverPositionerProps, PopoverProps, PopoverTitle, PopoverTitleProps, PopoverTrigger, PopoverTriggerProps, Pressable, PressableProps, Radio, RadioControl, RadioControlProps, RadioGroup, RadioGroupLabel, RadioGroupLabelProps, RadioGroupProps, RadioInput, RadioInputProps, RadioLabel, RadioLabelProps, RadioProps, Rating, RatingGroup, RatingGroupProps, RatingItem, RatingItemProps, RatingLabel, RatingLabelProps, RatingProps, RenderIconFn, Tab, TabIndicator, TabIndicatorProps, TabList, TabListProps, TabPanel, TabPanelProps, TabPanels, TabPanelsProps, TabProps, Tabs, TabsProps, Tooltip, TooltipArrow, TooltipArrowProps, TooltipContent, TooltipContentProps, TooltipInnerArrow, TooltipInnerArrowProps, TooltipPositioner, TooltipPositionerProps, TooltipProps, TooltipTrigger, TooltipTriggerProps, UseAccordionProps, UseAccordionReturn, UseCheckboxProps, UseCheckboxReturn, UseEditableProps, UseEditableReturn, UsePaginationProps, UsePinInputProps, UsePinInputReturn, UsePopoverProps, UsePopoverReturn, UsePressableProps, UsePressableReturn, UseRadioGroupProps, UseRadioGroupReturn, UseRatingProps, UseRatingReturn, UseTabsProps, UseTabsReturn, UseTooltipProps, UseTooltipReturn, useAccordion, useAccordionItemContext, useCheckbox, useEditable, usePagination, usePaginationContext, usePinInput, usePopover, usePressable, useRadioGroup, useRating, useTabs, useTooltip };