ropav 0.0.5 → 0.0.7

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

@@ -0,0 +1,35 @@
+import { SliderProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<SliderProps & {
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        value?: (props: {
+            value: number;
+            formattedValue: string | number;
+            percent: number;
+        }) => any;
+    } & {
+        thumb?: (props: {
+            value: number;
+            formattedValue: string | number;
+            percent: number;
+        }) => any;
+    };
+    emit: (evt: "update:modelValue", value: number) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,50 @@
+import { TooltipProps } from '../tooltip/types';
+export declare const sliderColors: readonly ["primary", "secondary", "success", "warning", "danger", "info", "neutral"];
+export declare const sliderSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const sliderOrientations: readonly ["horizontal", "vertical"];
+export type SliderPresetColor = (typeof sliderColors)[number];
+export type SliderColor = SliderPresetColor | (string & {});
+export type SliderSize = (typeof sliderSizes)[number];
+export type SliderOrientation = (typeof sliderOrientations)[number];
+export type SliderValueFormatter = (value: number) => string | number;
+export type SliderTooltipMode = 'hover' | 'always';
+export type SliderTooltipOptions = Pick<TooltipProps, 'id' | 'placement' | 'color' | 'offset' | 'openDelay' | 'arrow'> & {
+    mode?: SliderTooltipMode;
+};
+export type SliderTooltip = false | SliderTooltipMode | SliderTooltipOptions;
+export type SliderMarkColor = SliderColor;
+export interface SliderMark {
+    value: number;
+    label?: string | number;
+    color?: SliderMarkColor;
+    hidden?: boolean;
+}
+export type SliderMarkInput = number | SliderMark;
+export interface SliderThumbStyle {
+    size?: number | string;
+    border?: number | string;
+    padding?: number | string;
+}
+export interface SliderProps {
+    id?: string;
+    name?: string;
+    modelValue: number;
+    min?: number;
+    max?: number;
+    step?: number | 'any';
+    marks?: SliderMarkInput[];
+    thumbStyle?: SliderThumbStyle;
+    tooltip?: SliderTooltip;
+    formatValue?: SliderValueFormatter;
+    color?: SliderColor;
+    size?: SliderSize;
+    orientation?: SliderOrientation;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    ariaLabel?: string;
+    ariaValueText?: string | SliderValueFormatter;
+    describedby?: string;
+    labelledby?: string;
+}

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

@@ -0,0 +1,50 @@
+import { CSSProperties } from 'vue';
+import { SliderProps } from './types';
+type SliderStateProps = Readonly<SliderProps & {
+    min: number;
+    max: number;
+    step: number | 'any';
+    tooltip: NonNullable<SliderProps['tooltip']>;
+    orientation: NonNullable<SliderProps['orientation']>;
+}>;
+export declare function normalizeSliderValue(value: number, min: number, max: number, step: number | 'any'): number;
+export declare function normalizeSliderBounds(min: number, max: number): {
+    min: number;
+    max: number;
+};
+export declare function normalizeSliderStep(step: number | 'any'): number | "any";
+export declare function getSliderValuePercent(value: number, min: number, max: number): number;
+export declare function useSlider(props: SliderStateProps, emitUpdate: (value: number) => void): {
+    control: import('../../composables/useControlState').ControlState;
+    nativeMin: import('vue').ComputedRef<number>;
+    nativeMax: import('vue').ComputedRef<number>;
+    nativeStep: import('vue').ComputedRef<number | "any">;
+    rootClass: import('vue').ComputedRef<string[]>;
+    normalizedValue: import('vue').ComputedRef<number>;
+    valuePercent: import('vue').ComputedRef<number>;
+    formattedValue: import('vue').ComputedRef<string | number>;
+    ariaValueText: import('vue').ComputedRef<string | undefined>;
+    markItems: import('vue').ComputedRef<{
+        key: string;
+        value: number;
+        label: string | number | undefined;
+        hasLabel: boolean;
+        filled: boolean;
+        style: CSSProperties;
+    }[]>;
+    trackStyle: import('vue').ComputedRef<CSSProperties>;
+    tooltipVisible: import('vue').ComputedRef<boolean>;
+    tooltipOpen: import('vue').ComputedRef<boolean>;
+    tooltipPlacement: import('vue').ComputedRef<import('../tooltip').TooltipPlacement>;
+    tooltipId: import('vue').ComputedRef<string | undefined>;
+    tooltipColor: import('vue').ComputedRef<import('../../utils/componentColors').ComponentColorValue | undefined>;
+    tooltipOffset: import('vue').ComputedRef<import('../tooltip').TooltipOffset | undefined>;
+    tooltipOpenDelay: import('vue').ComputedRef<number>;
+    tooltipArrow: import('vue').ComputedRef<boolean>;
+    tooltipContent: import('vue').ComputedRef<string>;
+    onInput: (e: Event) => void;
+    openTooltip: () => void;
+    closeTooltip: () => void;
+    onTooltipKeydown: (event: KeyboardEvent) => void;
+};
+export {};

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

@@ -1,4 +1,5 @@
-export type SwitchColor = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+import { ComponentColorValue } from '../../utils/componentColors';
+export type SwitchColor = ComponentColorValue;
 export type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export interface SwitchProps {
     id?: string;

package/dist/components/switch/useSwitch.d.ts

@@ -2,5 +2,8 @@ import { SwitchProps } from './types';
 export declare function useSwitch(props: Readonly<SwitchProps>, emitUpdate: (value: boolean) => void): {
     control: import('../../composables/useControlState').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<{
+        '--_rp-switch-custom-color': string & {};
+    } | undefined>;
     onChange: (e: Event) => void;
 };

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

@@ -0,0 +1,6 @@
+export { default as Tabs } from './tabs';
+export { default as TabsContent } from './tabs-content';
+export { default as TabsList } from './tabs-list';
+export { default as TabsTrigger } from './tabs-trigger';
+export { useTabs, useTabsContent, useTabsList, useTabsTrigger } from './useTabs';
+export type { TabsActivationMode, TabsContentProps, TabsContentRootProps, TabsContentSlotProps, TabsListProps, TabsListRootProps, TabsListSlotProps, TabsOrientation, TabsPlacement, TabsProps, TabsRootProps, TabsSlotProps, TabsState, TabsSize, TabsTriggerAlign, TabsTriggerProps, TabsTriggerRootProps, TabsTriggerSlotProps, TabsValue, TabsVariant, UseTabsContentReturn, UseTabsListReturn, UseTabsReturn, UseTabsTriggerReturn, } from './types';

package/dist/components/tabs/index.js

@@ -0,0 +1,2 @@
+import { a as useTabs, c as useTabsTrigger, i as tabs_default, n as tabs_list_default, o as useTabsContent, r as tabs_content_default, s as useTabsList, t as tabs_trigger_default } from "../../tabs.js";
+export { tabs_default as Tabs, tabs_content_default as TabsContent, tabs_list_default as TabsList, tabs_trigger_default as TabsTrigger, useTabs, useTabsContent, useTabsList, useTabsTrigger };

package/dist/components/tabs/tabs-content.d.ts

@@ -0,0 +1,24 @@
+import { TabsContentProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<TabsContentProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            value: import('./types').TabsValue;
+            selected: boolean;
+        }) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/tabs/tabs-list.d.ts

@@ -0,0 +1,26 @@
+import { TabsListProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<TabsListProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            disabled: boolean;
+            variant: import('./types').TabsVariant;
+            orientation: import('./types').TabsOrientation;
+            placement: import('./types').TabsPlacement;
+        }) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/tabs/tabs-trigger.d.ts

@@ -0,0 +1,29 @@
+import { TabsTriggerProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<TabsTriggerProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            value: import('./types').TabsValue;
+            selected: boolean;
+            size: import('./types').TabsSize;
+            variant: import('./types').TabsVariant;
+            disabled: boolean;
+            align: import('./types').TabsTriggerAlign;
+            select: () => void;
+        }) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,31 @@
+import { TabsProps, TabsValue } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<TabsProps & {
+        "onUpdate:modelValue"?: ((value: TabsValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            value: TabsValue | null;
+            size: import('./types').TabsSize;
+            variant: import('./types').TabsVariant;
+            disabled: boolean;
+            placement: import('./types').TabsPlacement;
+            align: import('./types').TabsTriggerAlign;
+            select: (value: TabsValue) => void;
+        }) => any;
+    };
+    emit: (evt: "update:modelValue", value: TabsValue) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,160 @@
+import { ComputedRef } from 'vue';
+export type TabsValue = string | number;
+export type TabsOrientation = 'horizontal' | 'vertical';
+export type TabsPlacement = 'left' | 'right';
+export type TabsTriggerAlign = 'left' | 'center' | 'right';
+export type TabsActivationMode = 'automatic' | 'manual';
+export type TabsState = 'active' | 'inactive';
+export type TabsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type TabsVariant = 'line' | 'pills' | 'outline';
+export interface TabsProps {
+    id?: string;
+    modelValue?: TabsValue | null;
+    defaultValue?: TabsValue | null;
+    size?: TabsSize;
+    variant?: TabsVariant;
+    orientation?: TabsOrientation;
+    placement?: TabsPlacement;
+    align?: TabsTriggerAlign;
+    activationMode?: TabsActivationMode;
+    disabled?: boolean;
+    unmountOnExit?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+}
+export interface TabsListProps {
+    id?: string;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    ariaLabelledby?: string;
+}
+export interface TabsTriggerProps {
+    id?: string;
+    value: TabsValue;
+    disabled?: boolean;
+    align?: TabsTriggerAlign;
+}
+export interface TabsContentProps {
+    id?: string;
+    value: TabsValue;
+    unmountOnExit?: boolean;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    ariaLabelledby?: string;
+}
+export interface TabsRootProps {
+    id?: string;
+    class: string[];
+    'data-disabled'?: boolean;
+    'data-size': TabsSize;
+    'data-variant': TabsVariant;
+    'data-orientation': TabsOrientation;
+    'data-placement'?: TabsPlacement;
+    'data-activation-mode': TabsActivationMode;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+export interface TabsListRootProps {
+    id?: string;
+    class: string[];
+    role: 'tablist';
+    'data-disabled'?: boolean;
+    'data-variant': TabsVariant;
+    'data-orientation': TabsOrientation;
+    'data-placement'?: TabsPlacement;
+    'aria-orientation': TabsOrientation;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface TabsTriggerRootProps {
+    id: string;
+    class: string[];
+    role: 'tab';
+    type: 'button';
+    disabled?: boolean;
+    tabIndex: number;
+    'data-state': TabsState;
+    'data-disabled'?: boolean;
+    'data-variant': TabsVariant;
+    'data-align'?: TabsTriggerAlign;
+    'aria-selected': boolean;
+    'aria-controls'?: string;
+    'aria-disabled'?: boolean;
+    onClick: (event: MouseEvent) => void;
+    onFocus: (event: FocusEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface TabsContentRootProps {
+    id: string;
+    class: string[];
+    role: 'tabpanel';
+    tabIndex: number;
+    hidden?: boolean;
+    'data-state': TabsState;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+export interface TabsSlotProps {
+    value: TabsValue | null;
+    size: TabsSize;
+    variant: TabsVariant;
+    disabled: boolean;
+    placement: TabsPlacement;
+    align: TabsTriggerAlign;
+    select: (value: TabsValue) => void;
+}
+export interface TabsListSlotProps {
+    disabled: boolean;
+    variant: TabsVariant;
+    orientation: TabsOrientation;
+    placement: TabsPlacement;
+}
+export interface TabsTriggerSlotProps {
+    value: TabsValue;
+    selected: boolean;
+    size: TabsSize;
+    variant: TabsVariant;
+    disabled: boolean;
+    align: TabsTriggerAlign;
+    select: () => void;
+}
+export interface TabsContentSlotProps {
+    value: TabsValue;
+    selected: boolean;
+}
+export interface UseTabsReturn {
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<TabsRootProps>;
+    slotProps: ComputedRef<TabsSlotProps>;
+    selectedValue: ComputedRef<TabsValue | null>;
+    selectValue: (value: TabsValue) => void;
+}
+export interface UseTabsListReturn {
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<TabsListRootProps>;
+    slotProps: ComputedRef<TabsListSlotProps>;
+}
+export interface UseTabsTriggerReturn {
+    id: ComputedRef<string>;
+    state: ComputedRef<TabsState>;
+    isSelected: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<TabsTriggerRootProps>;
+    slotProps: ComputedRef<TabsTriggerSlotProps>;
+    select: () => void;
+}
+export interface UseTabsContentReturn {
+    id: ComputedRef<string>;
+    state: ComputedRef<TabsState>;
+    isSelected: ComputedRef<boolean>;
+    shouldRenderContent: ComputedRef<boolean>;
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<TabsContentRootProps>;
+    slotProps: ComputedRef<TabsContentSlotProps>;
+}

package/dist/components/tabs/useTabs.d.ts

@@ -0,0 +1,5 @@
+import { TabsContentProps, TabsListProps, TabsProps, TabsTriggerProps, TabsValue, UseTabsContentReturn, UseTabsListReturn, UseTabsReturn, UseTabsTriggerReturn } from './types';
+export declare function useTabs(props: Readonly<TabsProps>, emitUpdate: (value: TabsValue) => void): UseTabsReturn;
+export declare function useTabsList(props: Readonly<TabsListProps>): UseTabsListReturn;
+export declare function useTabsTrigger(props: Readonly<TabsTriggerProps>): UseTabsTriggerReturn;
+export declare function useTabsContent(props: Readonly<TabsContentProps>): UseTabsContentReturn;

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

@@ -1,2 +1,2 @@
 export { default as Textarea } from './textarea';
-export type { TextareaProps, TextareaRadius, TextareaSize } from './types';
+export type { TextareaProps, TextareaRadius, TextareaResize, TextareaSize } from './types';

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

@@ -1,11 +1,16 @@
 export type TextareaRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type TextareaSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type TextareaResize = 'none' | 'vertical' | 'both';
 export interface TextareaProps {
     id?: string;
     name?: string;
     modelValue: string;
     size?: TextareaSize;
     radius?: TextareaRadius;
+    resize?: TextareaResize;
+    autosize?: boolean;
+    minRows?: number;
+    maxRows?: number;
     placeholder?: string;
     rows?: number;
     disabled?: boolean;

package/dist/components/textarea/useTextarea.d.ts

@@ -1,7 +1,9 @@
 import { TextareaProps } from './types';
 export declare function useTextarea(props: Readonly<TextareaProps>, emitUpdate: (value: string) => void): {
+    textareaRef: import('vue').Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
     control: import('../../composables/useControlState').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
+    nativeRows: import('vue').ComputedRef<number | undefined>;
     onInput: (e: Event) => void;
     focusTextarea: (e: MouseEvent) => void;
 };

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

@@ -0,0 +1,2 @@
+export { default as Tooltip } from './tooltip';
+export type { TooltipColor, TooltipOffset, TooltipOffsetOptions, TooltipPlacement, TooltipProps, TooltipSlotProps, TooltipTarget, TooltipTriggerProps, } from './types';

package/dist/components/tooltip/index.js

@@ -0,0 +1,2 @@
+import { t as tooltip_default } from "../../tooltip.js";
+export { tooltip_default as Tooltip };

package/dist/components/tooltip/tooltip.d.ts

@@ -0,0 +1,27 @@
+import { TooltipProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<TooltipProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            triggerProps: import('./types').TooltipTriggerProps;
+        }) => any;
+    } & {
+        content?: (props: {}) => any;
+    };
+    emit: (evt: "update:open", value: boolean) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+import { ComponentColorValue } from '../../utils/componentColors';
+export type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type TooltipColor = ComponentColorValue;
+export type TooltipTarget = string | HTMLElement | Ref<HTMLElement | null | undefined>;
+export interface TooltipOffsetOptions {
+    mainAxis?: number;
+    crossAxis?: number;
+}
+export type TooltipOffset = number | TooltipOffsetOptions;
+export interface TooltipTriggerProps {
+    'aria-describedby'?: string;
+}
+export interface TooltipSlotProps {
+    triggerProps: TooltipTriggerProps;
+}
+export interface TooltipProps {
+    id?: string;
+    content?: string;
+    target?: TooltipTarget | null;
+    placement?: TooltipPlacement;
+    color?: TooltipColor;
+    offset?: TooltipOffset;
+    open?: boolean;
+    openDelay?: number;
+    arrow?: boolean;
+    disabled?: boolean;
+    decorative?: boolean;
+}

package/dist/components/tooltip/useTooltip.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'vue';
+import { TooltipProps, TooltipTriggerProps } from './types';
+export declare function useTooltip(props: Readonly<TooltipProps>, emitOpenChange?: (open: boolean) => void): {
+    tooltipId: import('vue').ComputedRef<string>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    isVisible: import('vue').ComputedRef<boolean>;
+    isTargetMode: import('vue').ComputedRef<boolean>;
+    shouldRenderContent: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    triggerProps: import('vue').ComputedRef<TooltipTriggerProps>;
+    contentRole: import('vue').ComputedRef<"tooltip" | undefined>;
+    contentAriaHidden: import('vue').ComputedRef<"true" | undefined>;
+    contentStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    openTooltip: () => void;
+    closeTooltip: () => void;
+    onKeydown: (event: KeyboardEvent) => void;
+};