@vellira-ui/react 2.126.8 → 2.126.10

package/dist/components/Select/Search/types.d.ts

@@ -0,0 +1,6 @@
+export interface SelectSearchProps {
+    /** Placeholder shown in the search input. */
+    placeholder?: string;
+    /** Class name applied to the search input. */
+    className?: string;
+}

package/dist/components/Select/Select.d.ts

@@ -0,0 +1,19 @@
+export declare const Select: {
+    (props: import('./types').SelectProps): import('react').JSX.Element;
+    displayName: string;
+} & {
+    Trigger: import('./internal/types').SelectSlotComponent<import('./Trigger').SelectTriggerSlotProps>;
+    Value: import('./internal/types').SelectSlotComponent<import('./Value').SelectValueProps>;
+    Icon: import('./internal/types').SelectSlotComponent<import('./Icon').SelectIconProps>;
+    Content: import('./internal/types').SelectSlotComponent<import('./Content').SelectContentSlotProps>;
+    Search: import('./internal/types').SelectSlotComponent<import('./Search').SelectSearchProps>;
+    Group: import('./internal/types').SelectSlotComponent<import('./Group').SelectGroupProps>;
+    Label: import('./internal/types').SelectSlotComponent<import('./Group').SelectLabelProps>;
+    Item: import('./internal/types').SelectSlotComponent<import('./Item').SelectItemProps>;
+    ItemIcon: import('./internal/types').SelectSlotComponent<import('./ItemIcon').SelectItemIconProps>;
+    ItemDescription: import('./internal/types').SelectSlotComponent<import('./ItemDescription').SelectItemDescriptionProps>;
+    ItemBadge: import('./internal/types').SelectSlotComponent<import('./ItemBadge').SelectItemBadgeProps>;
+    Separator: import('./internal/types').SelectSlotComponent<import('./Group').SelectSeparatorProps>;
+    Empty: import('./internal/types').SelectSlotComponent<import('./Empty').SelectEmptyProps>;
+    Loading: import('./internal/types').SelectSlotComponent<import('./Loading').SelectLoadingProps>;
+};

package/dist/components/Select/Separator/SelectSeparator.d.ts

@@ -0,0 +1,3 @@
+import { SelectSeparatorProps } from '../Group/types';
+import { SelectSlotComponent } from '../internal/types';
+export declare const SelectSeparator: SelectSlotComponent<SelectSeparatorProps>;

package/dist/components/Select/Separator/index.d.ts

@@ -0,0 +1,2 @@
+export type { SelectSeparatorProps } from '../Group/types';
+export { SelectSeparator } from './SelectSeparator';

package/dist/components/Select/Trigger/SelectTrigger.d.ts

@@ -0,0 +1,7 @@
+import { SelectSlotComponent } from '../internal/types';
+import { SelectTriggerProps, SelectTriggerSlotProps } from './types';
+export declare const SelectTrigger: SelectSlotComponent<SelectTriggerSlotProps>;
+export declare const SelectTriggerSurface: {
+    ({ children, id, describedBy, labelledBy, isOpen, disabled, required, listboxId, activeIndex, ariaLabel, error, displayText, isPlaceholder, size, color, variant, loading, startIcon, endIcon, prefix, suffix, clearable, onClear, className, buttonRef, onClick, onKeyDown, onBlur, onFocus, }: SelectTriggerProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Select/Trigger/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectTrigger, SelectTriggerSurface } from './SelectTrigger';
+export type { SelectTriggerProps, SelectTriggerSlotProps } from './types';

package/dist/components/Select/Trigger/types.d.ts

@@ -0,0 +1,36 @@
+import { BaseSelectTriggerProps, SelectColor, SelectSize, SelectVariant } from '@vellira-ui/types';
+import { FocusEventHandler, KeyboardEvent, ReactNode, Ref } from 'react';
+export interface SelectTriggerSlotProps {
+    /** Custom trigger content. */
+    children?: ReactNode;
+    /** Class name applied to the trigger element. */
+    className?: string;
+}
+export interface SelectTriggerProps extends BaseSelectTriggerProps {
+    children?: ReactNode;
+    displayText: ReactNode;
+    isPlaceholder: boolean;
+    size?: SelectSize;
+    color: SelectColor;
+    variant: SelectVariant;
+    id?: string;
+    describedBy?: string;
+    labelledBy?: string;
+    listboxId: string;
+    activeIndex: number;
+    ariaLabel?: string;
+    error?: boolean;
+    loading?: boolean;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    clearable?: boolean;
+    onClear?: () => void;
+    className?: string;
+    onClick: () => void;
+    buttonRef: Ref<HTMLButtonElement>;
+    onKeyDown?: (event: KeyboardEvent<HTMLButtonElement>) => void;
+    onBlur?: FocusEventHandler<HTMLButtonElement>;
+    onFocus?: FocusEventHandler<HTMLButtonElement>;
+}

package/dist/components/Select/Value/SelectValue.d.ts

@@ -0,0 +1,3 @@
+import { SelectSlotComponent } from '../internal/types';
+import { SelectValueProps } from './types';
+export declare const SelectValue: SelectSlotComponent<SelectValueProps>;

package/dist/components/Select/Value/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectValue } from './SelectValue';
+export type { SelectValueProps } from './types';

package/dist/components/Select/Value/types.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface SelectValueProps {
+    /** Custom value content; defaults to the current selected value text. */
+    children?: ReactNode;
+    /** Class name applied to the value wrapper. */
+    className?: string;
+}

package/dist/components/Select/index.d.ts

@@ -0,0 +1,31 @@
+export type { SelectContentSlotProps } from './Content';
+export { SelectContent } from './Content';
+export type { SelectEmptyProps } from './Empty';
+export { SelectEmpty } from './Empty';
+export type { SelectGroupProps } from './Group';
+export { SelectGroup } from './Group';
+export type { SelectIconProps } from './Icon';
+export { SelectIcon } from './Icon';
+export type { SelectItemProps } from './Item';
+export { SelectItem } from './Item';
+export type { SelectItemBadgeProps } from './ItemBadge';
+export { SelectItemBadge } from './ItemBadge';
+export type { SelectItemDescriptionProps } from './ItemDescription';
+export { SelectItemDescription } from './ItemDescription';
+export type { SelectItemIconProps } from './ItemIcon';
+export { SelectItemIcon } from './ItemIcon';
+export type { SelectLabelProps } from './Label';
+export { SelectLabel } from './Label';
+export type { SelectLoadingProps } from './Loading';
+export { SelectLoading } from './Loading';
+export { SelectRoot } from './Root';
+export type { SelectSearchProps } from './Search';
+export { SelectSearch } from './Search';
+export { Select } from './Select';
+export type { SelectSeparatorProps } from './Separator';
+export { SelectSeparator } from './Separator';
+export type { SelectTriggerSlotProps } from './Trigger';
+export { SelectTrigger } from './Trigger';
+export type { SelectOption, SelectProps, SelectRenderOptionContext, SelectRenderValueContext, } from './types';
+export type { SelectValueProps } from './Value';
+export { SelectValue } from './Value';

package/dist/components/Select/internal/SelectCollection.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { SelectCollectionOption, SelectRenderEntry } from './types';
+export declare function collectSelectOptions(children: ReactNode): SelectCollectionOption[];
+export declare function collectSelectStructure(children: ReactNode): {
+    entries: SelectRenderEntry[];
+    options: SelectCollectionOption[];
+};
+export declare function hasSelectLayoutChildren(children: ReactNode): boolean;

package/dist/components/Select/internal/SelectContext.d.ts

@@ -0,0 +1,8 @@
+import { SelectContentProps } from '../Content/types';
+import { SelectTriggerProps } from '../Trigger/types';
+export interface SelectContextValue {
+    triggerProps: SelectTriggerProps;
+    contentProps: SelectContentProps;
+}
+export declare const SelectProvider: import('react').Provider<SelectContextValue | null>;
+export declare function useSelectContext(): SelectContextValue;

package/dist/components/Select/internal/SelectSearch.d.ts

@@ -0,0 +1,11 @@
+export interface SelectSearchOption {
+    label: string;
+    description?: unknown;
+}
+interface FilterSelectOptionsParams<TOption extends SelectSearchOption> {
+    options: TOption[];
+    searchable: boolean;
+    searchValue: string;
+}
+export declare function filterSelectOptions<TOption extends SelectSearchOption>({ options, searchable, searchValue, }: FilterSelectOptionsParams<TOption>): TOption[];
+export {};

package/dist/components/Select/internal/SelectVirtualization.d.ts

@@ -0,0 +1,25 @@
+interface ResolveSelectVirtualizationParams<TOption> {
+    loading?: boolean;
+    options: TOption[];
+    scrollTop: number;
+    virtual?: boolean | SelectVirtualizationConfig;
+    viewportHeight?: number;
+}
+export interface SelectVirtualizationConfig {
+    itemHeight?: number;
+    maxHeight?: number | string;
+    overscan?: number;
+    viewportHeight?: number;
+}
+export declare function resolveSelectVirtualization<TOption>({ loading, options, scrollTop, virtual, viewportHeight: measuredViewportHeight, }: ResolveSelectVirtualizationParams<TOption>): {
+    bottomSpacerHeight: number;
+    isVirtual: boolean;
+    itemHeight: number;
+    maxHeight: string | number | undefined;
+    overscan: number;
+    startIndex: number;
+    topSpacerHeight: number;
+    viewportHeight: number;
+    visibleOptions: TOption[];
+};
+export {};

package/dist/components/Select/internal/types.d.ts

@@ -0,0 +1,27 @@
+import { ReactElement, ReactNode } from 'react';
+import { SelectOption } from '../types';
+export type SelectSlot = 'content' | 'empty' | 'group' | 'icon' | 'item' | 'itemBadge' | 'itemDescription' | 'itemIcon' | 'label' | 'loading' | 'search' | 'separator' | 'trigger' | 'value';
+export type SelectSlotComponent<P> = ((props: P) => ReactElement | null) & {
+    displayName?: string;
+};
+export declare function markSelectSlot<P>(component: SelectSlotComponent<P>, part: SelectSlot): import('@vellira-ui/core').CompoundSlotComponent<SelectSlotComponent<P>, SelectSlot>;
+export declare function getSelectSlotPart(type: unknown): SelectSlot | undefined;
+export type SelectCollectionOption = SelectOption & {
+    asChild?: boolean;
+    children?: ReactNode;
+};
+export type SelectRenderEntry = {
+    type: 'group';
+    id: string;
+    label: ReactNode;
+    selectable?: boolean;
+    selectLabel?: ReactNode;
+    itemValues: string[];
+} | {
+    type: 'option';
+    option: SelectCollectionOption;
+    optionIndex: number;
+} | {
+    type: 'separator';
+    id: string;
+};

package/dist/components/Select/internal/useSelectCollection.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function useSelectCollection(children: ReactNode): {
+    entries: import('./types').SelectRenderEntry[];
+    options: import('./types').SelectCollectionOption[];
+};

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

@@ -0,0 +1,111 @@
+import { Placement } from '@floating-ui/react';
+import { BaseSelectMultipleProps, BaseSelectOption, BaseSelectSingleProps, SelectVirtualConfig } from '@vellira-ui/types';
+import { FocusEventHandler, ReactNode } from 'react';
+export interface SelectOption extends Omit<BaseSelectOption, 'badge' | 'description' | 'icon'> {
+    /** Badge content shown with the option. */
+    badge?: ReactNode;
+    /** Supporting content shown with the option. */
+    description?: ReactNode;
+    /** Icon shown with the option. */
+    icon?: ReactNode;
+}
+export interface SelectRenderValueContext {
+    /** Selected option for single selection, or the first selected option for multiple selection. */
+    option: SelectOption | undefined;
+    /** All options available to the select. */
+    options: SelectOption[];
+    /** Current selected value for single selection. */
+    value: string;
+    /** Current selected values. */
+    values: string[];
+    /** Whether multiple selection is enabled. */
+    multiple: boolean;
+}
+export interface SelectRenderOptionContext {
+    /** Option being rendered. */
+    option: SelectOption;
+    /** Whether the option is selected. */
+    selected: boolean;
+    /** Whether the option is disabled. */
+    disabled: boolean;
+    /** Whether the option is the active keyboard item. */
+    active: boolean;
+    /** Zero-based option index. */
+    index: number;
+    /** Current selected values. */
+    values: string[];
+    /** Whether multiple selection is enabled. */
+    multiple: boolean;
+    /** Whether the option is currently pressed. */
+    pressed: boolean;
+}
+interface SelectOwnProps {
+    /** Custom option elements rendered inside the select. */
+    children?: ReactNode;
+    label?: ReactNode;
+    description?: ReactNode;
+    /** Unique id applied to the select trigger. */
+    id?: string;
+    /** Form field name submitted with the selected value. */
+    name?: string;
+    /** Accessible name for the select trigger when no visible label is used. */
+    'aria-label'?: string;
+    /** Ids of elements that describe the select trigger. */
+    'aria-describedby'?: string;
+    /** Ids of elements that label the select trigger. */
+    'aria-labelledby'?: string;
+    error?: ReactNode;
+    /** Content shown when no options match the current query. */
+    empty?: ReactNode;
+    /** Content shown while options are loading. */
+    loadingText?: ReactNode;
+    /** Floating content placement relative to the trigger. */
+    placement?: Extract<Placement, 'bottom' | 'top' | 'left' | 'right'>;
+    /** Matches dropdown width to the trigger width. */
+    matchTriggerWidth?: boolean;
+    /** Renders dropdown content through a portal. */
+    portal?: boolean;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Initial open state for uncontrolled usage. */
+    defaultOpen?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Called when the search query changes. */
+    onSearch?: (value: string) => void;
+    /** Called when the clear action is activated. */
+    onClear?: () => void;
+    /** Icon rendered before the selected value. */
+    startIcon?: ReactNode;
+    /** Icon rendered after the selected value. */
+    endIcon?: ReactNode;
+    /** Content rendered before the trigger value. */
+    prefix?: ReactNode;
+    /** Content rendered after the trigger value. */
+    suffix?: ReactNode;
+    /** Custom renderer for the trigger value. */
+    renderValue?: (context: SelectRenderValueContext) => ReactNode;
+    /** Custom renderer for each dropdown option. */
+    renderOption?: (context: SelectRenderOptionContext) => ReactNode;
+    /** Called when the select trigger loses focus. */
+    onBlur?: FocusEventHandler<HTMLButtonElement>;
+    /** Called when the select trigger receives focus. */
+    onFocus?: FocusEventHandler<HTMLButtonElement>;
+    /** Class name applied to the root element. */
+    className?: string;
+    /** Class name applied to the trigger element. */
+    triggerClassName?: string;
+    /** Class name applied to the dropdown element. */
+    dropdownClassName?: string;
+}
+export type SelectSingleProps = Omit<BaseSelectSingleProps, 'options' | 'label' | 'description' | 'error' | 'value' | 'defaultValue' | 'onValueChange'> & SelectOwnProps & {
+    /** Controlled selected value. Null represents no selection. */
+    value?: string | null;
+    /** Initial selected value for uncontrolled usage. Null represents no selection. */
+    defaultValue?: string | null;
+    /** Called when the selected value changes. Null represents no selection. */
+    onValueChange?: (value: string | null) => void;
+};
+export type SelectMultipleProps = Omit<BaseSelectMultipleProps, 'options' | 'label' | 'description' | 'error'> & SelectOwnProps;
+export type SelectProps = SelectSingleProps | SelectMultipleProps;
+export type { SelectVirtualConfig };

package/dist/components/Tabs/Content/TabsContent.d.ts

@@ -0,0 +1,5 @@
+import { TabsContentProps } from './types';
+export declare const TabsContent: {
+    ({ value, children, className, forceMount, ...props }: TabsContentProps): import('react').JSX.Element | null;
+    displayName: string;
+};

package/dist/components/Tabs/Content/index.d.ts

@@ -0,0 +1,2 @@
+export { TabsContent } from './TabsContent';
+export type { TabsContentProps } from './types';

package/dist/components/Tabs/Content/types.d.ts

@@ -0,0 +1,6 @@
+import { BaseTabsContentProps } from '@vellira-ui/types';
+import { HTMLAttributes, ReactNode } from 'react';
+export interface TabsContentProps extends BaseTabsContentProps, Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'value'> {
+    /** Tab panel content. */
+    children: ReactNode;
+}

package/dist/components/Tabs/List/TabsIndicator.d.ts

@@ -0,0 +1,5 @@
+import { TabsIndicatorProps } from './types';
+export declare const TabsIndicator: {
+    ({ className, style, ...props }: TabsIndicatorProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tabs/List/TabsList.d.ts

@@ -0,0 +1,5 @@
+import { TabsListProps } from './types';
+export declare const TabsList: {
+    ({ children, className, scrollable: scrollableProp, ...props }: TabsListProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tabs/List/index.d.ts

@@ -0,0 +1,3 @@
+export { TabsIndicator } from './TabsIndicator';
+export { TabsList } from './TabsList';
+export type { TabsIndicatorProps, TabsListProps } from './types';

package/dist/components/Tabs/List/types.d.ts

@@ -0,0 +1,10 @@
+import { BaseTabsListProps } from '@vellira-ui/types';
+import { ComponentPropsWithoutRef, HTMLAttributes, ReactNode } from 'react';
+export interface TabsIndicatorProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    /** Class name applied to the active tab indicator. */
+    className?: string;
+}
+export interface TabsListProps extends BaseTabsListProps, Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Tab trigger children. */
+    children: ReactNode;
+}

package/dist/components/Tabs/Root/TabsRoot.d.ts

@@ -0,0 +1,5 @@
+import { TabsProps } from './types';
+export declare const TabsRoot: {
+    ({ children, value: controlledValue, defaultValue, onValueChange, orientation, activationMode, dir, loop, mode, variant, color, size, keepMounted, lazyMount, disabled, className, ...props }: TabsProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tabs/Root/index.d.ts

@@ -0,0 +1,2 @@
+export { TabsRoot } from './TabsRoot';
+export type { TabsProps } from './types';

package/dist/components/Tabs/Root/types.d.ts

@@ -0,0 +1,8 @@
+import { BaseTabsProps } from '@vellira-ui/types';
+import { HTMLAttributes, ReactNode } from 'react';
+type DivProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'color' | 'defaultValue' | 'dir' | 'onChange'>;
+export interface TabsProps extends BaseTabsProps, DivProps {
+    /** Tab list and tab panel content. */
+    children: ReactNode;
+}
+export {};

package/dist/components/Tabs/Tabs.d.ts

@@ -0,0 +1,26 @@
+export declare const Tabs: {
+    ({ children, value: controlledValue, defaultValue, onValueChange, orientation, activationMode, dir, loop, mode, variant, color, size, keepMounted, lazyMount, disabled, className, ...props }: import('./Root').TabsProps): import('react').JSX.Element;
+    displayName: string;
+} & {
+    List: {
+        ({ children, className, scrollable: scrollableProp, ...props }: import('./List').TabsListProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Trigger: import('react').ForwardRefExoticComponent<import('./Trigger').TabsTriggerProps & import('react').RefAttributes<HTMLElement>>;
+    Content: {
+        ({ value, children, className, forceMount, ...props }: import('./Content').TabsContentProps): import('react').JSX.Element | null;
+        displayName: string;
+    };
+    Indicator: {
+        ({ className, style, ...props }: import('./List').TabsIndicatorProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Icon: {
+        ({ children, className }: import('./Trigger').TabsSlotProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Badge: {
+        ({ children, className }: import('./Trigger').TabsSlotProps): import('react').JSX.Element;
+        displayName: string;
+    };
+};

package/dist/components/Tabs/Trigger/TabsBadge.d.ts

@@ -0,0 +1,5 @@
+import { TabsSlotProps } from './types';
+export declare const TabsBadge: {
+    ({ children, className }: TabsSlotProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tabs/Trigger/TabsIcon.d.ts

@@ -0,0 +1,5 @@
+import { TabsSlotProps } from './types';
+export declare const TabsIcon: {
+    ({ children, className }: TabsSlotProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tabs/Trigger/TabsTrigger.d.ts

@@ -0,0 +1,2 @@
+import { TabsTriggerProps } from './types';
+export declare const TabsTrigger: import('react').ForwardRefExoticComponent<TabsTriggerProps & import('react').RefAttributes<HTMLElement>>;

package/dist/components/Tabs/Trigger/index.d.ts

@@ -0,0 +1,4 @@
+export { TabsBadge } from './TabsBadge';
+export { TabsIcon } from './TabsIcon';
+export { TabsTrigger } from './TabsTrigger';
+export type { TabsSlotProps, TabsTriggerProps } from './types';

package/dist/components/Tabs/Trigger/types.d.ts

@@ -0,0 +1,32 @@
+import { BaseTabsTriggerProps } from '@vellira-ui/types';
+import { ButtonHTMLAttributes, MouseEventHandler, ReactNode, Ref } from 'react';
+export interface TabsTriggerChildProps {
+    children?: ReactNode;
+    id?: string;
+    className?: string;
+    href?: string;
+    'aria-current'?: 'page' | 'step' | 'location' | 'date' | 'time' | boolean;
+    'aria-disabled'?: boolean;
+    'data-state'?: 'active' | 'inactive';
+    'data-disabled'?: string;
+    onClick?: MouseEventHandler<HTMLElement>;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
+    ref?: Ref<HTMLElement>;
+    tabIndex?: number;
+}
+export interface TabsTriggerProps extends BaseTabsTriggerProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'disabled' | 'value'> {
+    /** Trigger label content. */
+    children?: ReactNode;
+    /** Icon rendered before the trigger label. */
+    icon?: ReactNode;
+    /** Badge content rendered with the trigger label. */
+    badge?: ReactNode;
+    /** Supporting text rendered below the trigger label. */
+    description?: ReactNode;
+}
+export interface TabsSlotProps {
+    /** Slot content. */
+    children: ReactNode;
+    /** Class name applied to the slot element. */
+    className?: string;
+}

package/dist/components/Tabs/index.d.ts

@@ -0,0 +1,2 @@
+export { Tabs } from './Tabs';
+export type { TabsContentProps, TabsIndicatorProps, TabsListProps, TabsProps, TabsSlotProps, TabsTriggerProps, } from './types';

package/dist/components/Tabs/internal/TabsContext.d.ts

@@ -0,0 +1,3 @@
+import { TabsContextValue } from './types';
+export declare const TabsContext: import('react').Context<TabsContextValue | null>;
+export declare const useTabsContext: () => TabsContextValue;

package/dist/components/Tabs/internal/types.d.ts

@@ -0,0 +1,33 @@
+import { Orientation, TabsActivationMode, TabsColor, TabsMode, TabsSize, TabsValue, TabsVariant } from '@vellira-ui/types';
+import { KeyboardEvent } from 'react';
+export interface RegisteredTab {
+    value: TabsValue;
+    element: HTMLElement;
+    disabled: boolean;
+}
+export interface RegisteredContent {
+    value: TabsValue;
+}
+export interface TabsContextValue {
+    value?: TabsValue;
+    focusedValue?: TabsValue;
+    collectionVersion: number;
+    setValue: (value: TabsValue) => void;
+    setFocusedValue: (value: TabsValue) => void;
+    mode: TabsMode;
+    orientation: Orientation;
+    activationMode: TabsActivationMode;
+    dir: 'ltr' | 'rtl';
+    loop: boolean;
+    variant: TabsVariant;
+    color: TabsColor;
+    size: TabsSize;
+    keepMounted: boolean;
+    lazyMount: boolean;
+    disabled: boolean;
+    registerTrigger: (value: TabsValue, element: HTMLElement | null, disabled?: boolean) => void;
+    registerContent: (value: TabsValue, mounted: boolean) => void;
+    onTriggerKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+    getTriggerId: (value: TabsValue) => string;
+    getContentId: (value: TabsValue) => string;
+}

package/dist/components/Tabs/internal/useTabsCollection.d.ts

@@ -0,0 +1,9 @@
+import { TabsValue } from '@vellira-ui/types';
+import { RegisteredContent, RegisteredTab } from './types';
+export declare const useTabsCollection: () => {
+    version: number;
+    triggersRef: import('react').RefObject<RegisteredTab[]>;
+    contentsRef: import('react').RefObject<RegisteredContent[]>;
+    registerTrigger: (value: TabsValue, element: HTMLElement | null, disabled?: boolean) => void;
+    registerContent: (value: TabsValue, mounted: boolean) => void;
+};

package/dist/components/Tabs/internal/useTabsIndicator.d.ts

@@ -0,0 +1,6 @@
+import { CSSProperties } from 'react';
+export type TabsIndicatorStyle = Pick<CSSProperties, 'width' | 'height' | 'transform'>;
+export declare const useTabsIndicator: () => {
+    ref: import('react').RefObject<HTMLSpanElement | null>;
+    style: TabsIndicatorStyle;
+};

package/dist/components/Tabs/internal/useTabsKeyboard.d.ts

@@ -0,0 +1,16 @@
+import { Orientation, TabsActivationMode } from '@vellira-ui/types';
+import { KeyboardEvent } from 'react';
+import { RegisteredTab } from './types';
+export interface UseTabsKeyboardParams {
+    focusedValue?: string;
+    setValue: (value: string) => void;
+    setFocusedValue: (value: string) => void;
+    getTabs: () => RegisteredTab[];
+    orientation: Orientation;
+    activationMode: TabsActivationMode;
+    dir: 'ltr' | 'rtl';
+    loop: boolean;
+}
+export declare const useTabsKeyboard: ({ focusedValue, setValue, setFocusedValue, getTabs, orientation, activationMode, dir, loop, }: UseTabsKeyboardParams) => {
+    onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+};

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

@@ -0,0 +1,4 @@
+export type { TabsContentProps } from './Content';
+export type { TabsIndicatorProps, TabsListProps } from './List';
+export type { TabsProps } from './Root';
+export type { TabsSlotProps, TabsTriggerProps } from './Trigger';

package/dist/components/Tooltip/Content/TooltipContent.d.ts

@@ -0,0 +1,2 @@
+import { TooltipContentProps } from './types';
+export declare const TooltipContent: import('react').ForwardRefExoticComponent<TooltipContentProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/Tooltip/Content/index.d.ts

@@ -0,0 +1,2 @@
+export { TooltipContent } from './TooltipContent';
+export type { TooltipContentProps } from './types';

package/dist/components/Tooltip/Content/types.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+export interface TooltipContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** Tooltip content shown while open. */
+    children: ReactNode;
+    /** Keeps tooltip content mounted when closed. */
+    forceMount?: boolean;
+    /** Renders a small arrow pointing at the trigger. */
+    withArrow?: boolean;
+    /** Class name applied to the tooltip content element. */
+    className?: string;
+    /** Inline style applied to the tooltip content element. */
+    style?: CSSProperties;
+}

package/dist/components/Tooltip/Root/TooltipRoot.d.ts

@@ -0,0 +1,5 @@
+import { TooltipRootProps } from './types';
+export declare const TooltipRoot: {
+    ({ children, open: openProp, defaultOpen, onOpenChange, placement, offset, delay, skipDelay, disabled, interactive, avoidCollisions, matchTriggerWidth, }: TooltipRootProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tooltip/Root/index.d.ts

@@ -0,0 +1,2 @@
+export { TooltipRoot } from './TooltipRoot';
+export type { TooltipRootProps } from './types';