@ui-organized/vue 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,23 @@
+import type { Component } from "vue";
+export interface TabItem {
+    /** Unique value identifier for this tab. */
+    value: string | number;
+    /** Tab label. A string, or a component for anything richer. */
+    label: string | Component;
+    /** Panel content for this tab. */
+    content: string | Component;
+    /** Whether this tab is disabled. */
+    disabled?: boolean;
+}
+export interface TabsProps {
+    /** Tab definitions including labels and panel content. */
+    tabs: TabItem[];
+    /** Active tab value. Use `v-model` for two-way binding. */
+    modelValue?: string | number;
+    /** Initial active tab value for uncontrolled usage. Defaults to first tab. */
+    defaultValue?: string | number;
+    /** Whether tabs render horizontally or vertically. Defaults to 'horizontal'. */
+    orientation?: "horizontal" | "vertical";
+    /** Tab sizing. 'default' uses body-large type, 'small' uses body-medium. */
+    size?: "default" | "small";
+}

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

@@ -0,0 +1,13 @@
+import type { TabsProps } from "./Tabs.types.js";
+import "@ui-organized/core/components/Tabs/Tabs.css";
+declare const _default: import("vue").DefineComponent<TabsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    valueChange: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<TabsProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValueChange?: ((value: string) => any) | undefined;
+}>, {
+    size: "default" | "small";
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as Tabs } from "./Tabs.vue";
+export type { TabsProps, TabItem } from "./Tabs.types.js";

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

@@ -0,0 +1,18 @@
+import type { IconName } from "../Icon/Icon.types.js";
+import type { ControlSize } from "@ui-organized/core";
+import type { IconComponent } from "../../icons/registry.js";
+export interface TagProps {
+    /** Status color variant. */
+    variant?: "success" | "info" | "info-secondary" | "caution" | "error";
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /**
+     * When true (default), renders a solid filled tag with high-contrast text.
+     * When false, renders a subdued tinted-background tag with colored text.
+     */
+    emphasized?: boolean;
+    /** Optional icon — rendered at 16px across every tag size. */
+    icon?: IconName | IconComponent;
+    /** Which side of the label the icon sits on. Defaults to 'left'. */
+    iconPosition?: "left" | "right";
+}

package/dist/components/Tag/Tag.vue.d.ts

@@ -0,0 +1,17 @@
+import type { TagProps } from "./Tag.types.js";
+import "@ui-organized/core/components/Tag/Tag.css";
+declare var __VLS_4: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_4) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TagProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TagProps> & Readonly<{}>, {
+    iconPosition: "left" | "right";
+    emphasized: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as Tag } from "./Tag.vue";
+export type { TagProps } from "./Tag.types.js";

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

@@ -0,0 +1,41 @@
+export interface TagsInputProps {
+    /** Accessible label text rendered above the control. */
+    label?: string;
+    /** Helper text rendered below the control. Hidden when an error is shown. */
+    helperText?: string;
+    /**
+     * Error state. Pass a string to show an error message.
+     * Pass `true` to mark the field invalid without a message.
+     */
+    error?: string | boolean;
+    /**
+     * Controlled list of tags. Use `v-model` for two-way binding.
+     *
+     * Spelled `modelValue` rather than React's `value` — Ark Vue names the
+     * tags-input machine's controlled value for `v-model`, and this package
+     * follows Ark.
+     */
+    modelValue?: string[];
+    /** Initial tags for the uncontrolled case. */
+    defaultValue?: string[];
+    /** Placeholder shown in the entry field. */
+    placeholder?: string;
+    /** Size variant. Defaults to 'md'. */
+    size?: "sm" | "md" | "lg";
+    /** Maximum number of tags. Further entries are rejected once reached. */
+    max?: number;
+    /** Allows a double-click to edit an existing tag in place. Defaults to true. */
+    editable?: boolean;
+    /** Splits pasted or typed text into several tags. Defaults to ','. */
+    delimiter?: string;
+    /** Creates tags from pasted text. Defaults to false. */
+    addOnPaste?: boolean;
+    /** Marks the field required and shows the required indicator. */
+    required?: boolean;
+    /** Disables the control. */
+    disabled?: boolean;
+    /** Makes the tags read-only while keeping them focusable. */
+    readOnly?: boolean;
+    /** Form field name for the hidden inputs. */
+    name?: string;
+}

package/dist/components/TagsInput/TagsInput.vue.d.ts

@@ -0,0 +1,16 @@
+import type { TagsInputProps } from "./TagsInput.types.js";
+import "@ui-organized/core/components/TagsInput/TagsInput.css";
+declare const _default: import("vue").DefineComponent<TagsInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+    valueChange: (value: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<TagsInputProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onValueChange?: ((value: string[]) => any) | undefined;
+}>, {
+    required: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    editable: boolean;
+    addOnPaste: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as TagsInput } from "./TagsInput.vue";
+export type { TagsInputProps } from "./TagsInput.types.js";
+export type { TagsInputVariants } from "@ui-organized/core";

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

@@ -0,0 +1,28 @@
+import type { ControlSize } from "@ui-organized/core";
+export interface TextAreaProps {
+    /** The control's value. Use `v-model` for two-way binding. */
+    modelValue?: string | number;
+    /** Accessible label text rendered above the control. */
+    label?: string;
+    /**
+     * Helper text rendered below the control. Hidden when an error is shown.
+     * Commonly used as a character counter (e.g. "Characters 0/500").
+     */
+    helperText?: string;
+    /**
+     * Error state. Pass a string to show an error message.
+     * Pass `true` to mark the field invalid without a message.
+     */
+    error?: string | boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /**
+     * Native resize affordance. Defaults to 'both' (horizontal resizing is capped
+     * at the field's container width). Use 'vertical', 'horizontal', or 'none'.
+     */
+    resize?: "none" | "vertical" | "horizontal" | "both";
+    /** Marks the control required. */
+    required?: boolean;
+    /** Disables the control. */
+    disabled?: boolean;
+}

package/dist/components/TextArea/TextArea.vue.d.ts

@@ -0,0 +1,13 @@
+import type { TextAreaProps } from "./TextArea.types.js";
+import "@ui-organized/core/components/Input/Input.css";
+import "@ui-organized/core/components/TextArea/TextArea.css";
+declare const _default: import("vue").DefineComponent<TextAreaProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<TextAreaProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    required: boolean;
+    disabled: boolean;
+    resize: "none" | "vertical" | "horizontal" | "both";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as TextArea } from "./TextArea.vue";
+export type { TextAreaProps } from "./TextArea.types.js";

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

@@ -0,0 +1,27 @@
+import type { ControlSize } from "@ui-organized/core";
+export type TimerPart = "days" | "hours" | "minutes" | "seconds" | "milliseconds";
+export interface TimerProps {
+    /**
+     * Which units to display, in order. Defaults to
+     * `["hours", "minutes", "seconds"]`.
+     */
+    parts?: TimerPart[];
+    /** Counts down to `targetMs` instead of up from it. Defaults to false. */
+    countdown?: boolean;
+    /** Where the timer starts, in milliseconds. */
+    startMs?: number;
+    /** Where the timer stops, in milliseconds. */
+    targetMs?: number;
+    /** Starts as soon as it mounts. Defaults to false. */
+    autoStart?: boolean;
+    /** Milliseconds between ticks. Lower this to show milliseconds. Defaults to 1000. */
+    interval?: number;
+    /** Renders start / pause / reset buttons. Defaults to false. */
+    showControls?: boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /** Visual treatment. `boxed` puts each unit on its own tile. Defaults to 'default'. */
+    variant?: "default" | "boxed";
+    /** Shows the unit name under each value. Defaults to false. */
+    showLabels?: boolean;
+}

package/dist/components/Timer/Timer.vue.d.ts

@@ -0,0 +1,16 @@
+import type { TimerProps } from "./Timer.types.js";
+import "@ui-organized/core/components/Timer/Timer.css";
+import type { TimerPart } from "./Timer.types.js";
+declare const _default: import("vue").DefineComponent<TimerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    complete: () => any;
+}, string, import("vue").PublicProps, Readonly<TimerProps> & Readonly<{
+    onComplete?: (() => any) | undefined;
+}>, {
+    size: import("@ui-organized/core").ControlSize;
+    showControls: boolean;
+    parts: TimerPart[];
+    countdown: boolean;
+    autoStart: boolean;
+    showLabels: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as Timer } from "./Timer.vue";
+export type { TimerProps, TimerPart } from "./Timer.types.js";
+export type { TimerVariants } from "@ui-organized/core";

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

@@ -0,0 +1,16 @@
+/** Semantic status driving a toast's accent color and icon. Set via `add({ type })`. */
+export type ToastStatus = "info" | "success" | "warning" | "error";
+/** Options accepted by `useToastManager().add(...)`. */
+export interface ToastOptions {
+    title?: string;
+    description?: string;
+    /** Status (`info`/`success`/`warning`/`error`) — drives the accent + icon. */
+    type?: string;
+    /** Auto-dismiss after this many ms. */
+    duration?: number;
+    /** An inline action button (e.g. "Undo"). */
+    actionProps?: {
+        children?: string;
+        onClick?: () => void;
+    };
+}

package/dist/components/Toast/ToastProvider.vue.d.ts

@@ -0,0 +1,13 @@
+import "@ui-organized/core/components/Toast/Toast.css";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,3 @@
+export { default as ToastProvider } from "./ToastProvider.vue";
+export { useToastManager, toaster } from "./toaster.js";
+export type { ToastOptions, ToastStatus } from "./Toast.types.js";

package/dist/components/Toast/toaster.d.ts

@@ -0,0 +1,17 @@
+import type { SystemGlyph } from "@ui-organized/core";
+import type { ToastOptions, ToastStatus } from "./Toast.types.js";
+export declare const toaster: import("@ark-ui/vue").CreateToasterReturn<import("vue").VNodeChild>;
+export declare const STATUS_ICON: Record<ToastStatus, SystemGlyph>;
+/** Map a toast's free-form `type` to one of our four statuses. */
+export declare function resolveStatus(type: string | undefined): ToastStatus;
+/**
+ * Returns `{ add, close, update }` for imperative toasts.
+ *
+ * Named `useToastManager` to match the other libraries, though it is not a
+ * composable and can be called anywhere — there is no state behind it.
+ */
+export declare function useToastManager(): {
+    add(options: ToastOptions): string;
+    close(id: string): void;
+    update(id: string, options: ToastOptions): void;
+};

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

@@ -0,0 +1,34 @@
+import type { IconComponent, IconName } from "../Icon/Icon.types.js";
+import type { ControlSize } from "@ui-organized/core";
+export interface ToggleProps {
+    /** Whether the toggle is on (standalone usage). Use `v-model:pressed`. */
+    pressed?: boolean;
+    /** Initial pressed state for uncontrolled standalone usage. */
+    defaultPressed?: boolean;
+    /** Identifies this toggle within a `<ToggleGroup>`; turns it into a group item. */
+    value?: string;
+    /** Whether the toggle should ignore user interaction. */
+    disabled?: boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /** Optional leading icon. */
+    icon?: IconName | IconComponent;
+}
+export interface ToggleGroupProps {
+    /**
+     * Pressed values. Use `v-model` for two-way binding.
+     *
+     * Spelled `modelValue` rather than React's `value` because Ark Vue names the
+     * toggle-group machine's controlled value for `v-model`; this package follows
+     * Ark, the way Listbox, Tabs and RadioGroup already do.
+     */
+    modelValue?: string[];
+    /** Initial pressed values for uncontrolled usage. */
+    defaultValue?: string[];
+    /** Allow more than one toggle pressed at once. Defaults to single-select. */
+    multiple?: boolean;
+    /** Disable the whole group. */
+    disabled?: boolean;
+    /** Layout orientation. Defaults to 'horizontal'. */
+    orientation?: "horizontal" | "vertical";
+}

package/dist/components/Toggle/Toggle.vue.d.ts

@@ -0,0 +1,24 @@
+import type { ToggleProps } from "./Toggle.types.js";
+import "@ui-organized/core/components/Toggle/Toggle.css";
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<ToggleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:pressed": (pressed: boolean) => any;
+    pressedChange: (pressed: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ToggleProps> & Readonly<{
+    "onUpdate:pressed"?: ((pressed: boolean) => any) | undefined;
+    onPressedChange?: ((pressed: boolean) => any) | undefined;
+}>, {
+    size: import("@ui-organized/core").ControlSize;
+    disabled: boolean;
+    pressed: boolean;
+    defaultPressed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Toggle/ToggleGroup.vue.d.ts

@@ -0,0 +1,23 @@
+import type { ToggleGroupProps } from "./Toggle.types.js";
+import "@ui-organized/core/components/Toggle/Toggle.css";
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ToggleGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+    valueChange: (value: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<ToggleGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onValueChange?: ((value: string[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    multiple: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,4 @@
+export { default as Toggle } from "./Toggle.vue";
+export { default as ToggleGroup } from "./ToggleGroup.vue";
+export type { ToggleProps, ToggleGroupProps } from "./Toggle.types.js";
+export type { ToggleVariants } from "@ui-organized/core";

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

@@ -0,0 +1,4 @@
+export interface ToolbarProps {
+    /** Layout orientation. Defaults to 'horizontal'. */
+    orientation?: "horizontal" | "vertical";
+}

package/dist/components/Toolbar/Toolbar.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ToolbarProps } from "./Toolbar.types.js";
+import "@ui-organized/core/components/Toolbar/Toolbar.css";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ToolbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToolbarProps> & Readonly<{}>, {
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Toolbar/ToolbarGroup.vue.d.ts

@@ -0,0 +1,12 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,3 @@
+export { default as Toolbar } from "./Toolbar.vue";
+export { default as ToolbarGroup } from "./ToolbarGroup.vue";
+export type { ToolbarProps } from "./Toolbar.types.js";

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

@@ -0,0 +1,31 @@
+import type { Component } from "vue";
+export type TooltipSide = "top" | "right" | "bottom" | "left";
+export type TooltipAlign = "start" | "center" | "end";
+export interface TooltipProps {
+    /** Content shown in the tooltip bubble. A string, or a component. */
+    content: string | Component;
+    /** Side of the trigger to position against. Defaults to 'top'. */
+    side?: TooltipSide;
+    /** Alignment along the chosen side. Defaults to 'center'. */
+    align?: TooltipAlign;
+    /** Gap between the trigger and bubble, in px. Defaults to 6. */
+    sideOffset?: number;
+    /** Delay before opening, in ms. Falls back to a wrapping TooltipProvider. */
+    delay?: number;
+    /** Delay before closing, in ms. Falls back to a wrapping TooltipProvider. */
+    closeDelay?: number;
+    /** When true, renders the trigger without a tooltip. */
+    disabled?: boolean;
+    /** Open state. Use `v-model:open` for two-way binding. */
+    open?: boolean;
+    /** Initial open state for uncontrolled usage. */
+    defaultOpen?: boolean;
+    /** DOM element to teleport into. Defaults to `body`. */
+    container?: HTMLElement | null;
+}
+export interface TooltipProviderProps {
+    /** Default delay before opening, in ms, for descendant tooltips. */
+    delay?: number;
+    /** Default delay before closing, in ms, for descendant tooltips. */
+    closeDelay?: number;
+}

package/dist/components/Tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,29 @@
+import type { TooltipProps } from "./Tooltip.types.js";
+import "@ui-organized/core/components/Tooltip/Tooltip.css";
+declare var __VLS_1: {}, __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    openChange: (open: boolean) => any;
+    "update:open": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<TooltipProps> & Readonly<{
+    onOpenChange?: ((open: boolean) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    open: boolean;
+    defaultOpen: boolean;
+    side: import("./Tooltip.types.js").TooltipSide;
+    align: import("./Tooltip.types.js").TooltipAlign;
+    sideOffset: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Tooltip/TooltipProvider.vue.d.ts

@@ -0,0 +1,13 @@
+import type { TooltipProviderProps } from "./Tooltip.types.js";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Tooltip/delays.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared open/close delays for descendant tooltips.
+ *
+ * Ark UI has no app-level delay provider — delays are per-tooltip Root props —
+ * so this facade supplies the contract itself, exactly as the React and Svelte
+ * packages do. Provided as a ref so a provider driven by reactive props keeps
+ * its descendants current.
+ */
+import { type Ref } from "vue";
+export interface TooltipDelays {
+    delay?: number;
+    closeDelay?: number;
+}
+export declare function provideTooltipDelays(delays: Ref<TooltipDelays>): void;
+export declare function useTooltipDelays(): Ref<TooltipDelays> | undefined;

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

@@ -0,0 +1,3 @@
+export { default as Tooltip } from "./Tooltip.vue";
+export { default as TooltipProvider } from "./TooltipProvider.vue";
+export type { TooltipProps, TooltipProviderProps, TooltipSide, TooltipAlign, } from "./Tooltip.types.js";

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

@@ -0,0 +1,73 @@
+export interface TourStepAction {
+    /** Button text. */
+    label: string;
+    /** What the button does. Defaults to 'next'. */
+    action?: "next" | "prev" | "dismiss" | "skip";
+}
+export interface TourStep {
+    /** Unique id across the tour. This is what `stepId` names. */
+    id: string;
+    /**
+     * Step heading.
+     *
+     * A plain string rather than a component: the machine hands this straight to
+     * Ark's Title part as its content, and anything richer would need a slot the
+     * part does not offer per step.
+     */
+    title: string;
+    /** Step body copy. A plain string, for the same reason as `title`. */
+    description: string;
+    /**
+     * Returns the element to highlight. Omit it for a centred step with no
+     * target, which the machine treats as a modal `dialog` step.
+     */
+    target?: () => HTMLElement | null;
+    /**
+     * How the step is presented. `tooltip` anchors to the target, `dialog`
+     * centres, `floating` sits unanchored, `wait` pauses for an app event.
+     * Inferred from `target` when omitted.
+     */
+    type?: "tooltip" | "dialog" | "wait" | "floating";
+    /** Where the card sits relative to its target. */
+    placement?: "top" | "bottom" | "left" | "right" | "center";
+    /** Buttons in the card's action row. Defaults to Back and Next. */
+    actions?: TourStepAction[];
+    /** Dims the rest of the page behind this step. Defaults to true. */
+    backdrop?: boolean;
+    /** Points an arrow at the target. Defaults to true for anchored steps. */
+    arrow?: boolean;
+}
+export interface TourProps {
+    /** The steps, in order. */
+    steps: TourStep[];
+    /**
+     * The step to show, by id. Set it to a step's id to open the tour there, and
+     * to another id to jump.
+     *
+     * Opening and navigating are controlled; **closing is not**. The machine
+     * exposes no programmatic close, so setting this back to `null` does not shut
+     * the tour — people close it with the card's close button, Escape, or a
+     * `dismiss` action, and that arrives as `stepChange` with `null`. Keep this
+     * prop wired to that event and the two stay in step.
+     *
+     * Open it *after* mount. The watcher that drives the machine is a client-side
+     * one, so opening on an anchored step during the first render measures a null
+     * target: the spotlight collapses and the card is parked off-screen. Opening
+     * from a click is always safe.
+     */
+    stepId: string | null;
+    /** Corner radius of the spotlight cutout, in pixels. Defaults to 4. */
+    spotlightRadius?: number;
+    /** Blocks interaction with the page behind the tour. Defaults to false. */
+    preventInteraction?: boolean;
+    /** Closes when clicking outside the card. Defaults to true. */
+    closeOnInteractOutside?: boolean;
+    /** Closes on Escape. Defaults to true. */
+    closeOnEscape?: boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: "sm" | "md" | "lg";
+    /** Card treatment. `compact` tightens the padding. Defaults to 'default'. */
+    variant?: "default" | "compact";
+    /** Shows the "step N of M" counter. Defaults to true. */
+    showProgress?: boolean;
+}

package/dist/components/Tour/Tour.vue.d.ts

@@ -0,0 +1,13 @@
+import type { TourProps } from "./Tour.types.js";
+import "@ui-organized/core/components/Tour/Tour.css";
+declare const _default: import("vue").DefineComponent<TourProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    stepChange: (stepId: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<TourProps> & Readonly<{
+    onStepChange?: ((stepId: string | null) => any) | undefined;
+}>, {
+    closeOnEscape: boolean;
+    closeOnInteractOutside: boolean;
+    preventInteraction: boolean;
+    showProgress: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as Tour } from "./Tour.vue";
+export type { TourProps, TourStep, TourStepAction } from "./Tour.types.js";
+export type { TourVariants } from "@ui-organized/core";