nuance-ui 0.2.6 → 0.2.8

package/dist/runtime/components/tree/_ui/tree-root.d.vue.ts

@@ -1,14 +1,22 @@
 import type { ButtonProps } from '@nui/components';
 import type { RovingFocusProps } from '../../roving-focus/roving-focus.vue.js';
-import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../model.js';
+import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../types.js';
 export type TreeRootProps = RovingFocusProps & {
+    /** Resolves the icon for a given tree item */
     iconResolver?: TreeIconResolver;
+    /** If set, selected items can be deleted with the Delete key */
     removable?: boolean;
+    /** If set, multiple items can be selected */
     selectable?: boolean;
+    /** Async loader for branch data */
     loadBranch: TreeLoader;
+    /** Filters which items are rendered */
     filter?: TreeFilter;
+    /** Visual variant */
     variant?: ButtonProps['variant'];
+    /** Color from theme */
     color?: ButtonProps['color'];
+    /** Component size */
     size?: ButtonProps['size'];
 };
 type __VLS_Props = TreeRootProps;

package/dist/runtime/components/tree/_ui/tree-root.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { useStyleResolver } from "@nui/composals";
+import { useStyleResolver } from "@nui/composables";
 import { getSize } from "@nui/utils";
 import { onClickOutside, useEventListener } from "@vueuse/core";
 import { useTemplateRef } from "vue";

package/dist/runtime/components/tree/_ui/tree-root.vue.d.ts

@@ -1,14 +1,22 @@
 import type { ButtonProps } from '@nui/components';
 import type { RovingFocusProps } from '../../roving-focus/roving-focus.vue.js';
-import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../model.js';
+import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../types.js';
 export type TreeRootProps = RovingFocusProps & {
+    /** Resolves the icon for a given tree item */
     iconResolver?: TreeIconResolver;
+    /** If set, selected items can be deleted with the Delete key */
     removable?: boolean;
+    /** If set, multiple items can be selected */
     selectable?: boolean;
+    /** Async loader for branch data */
     loadBranch: TreeLoader;
+    /** Filters which items are rendered */
     filter?: TreeFilter;
+    /** Visual variant */
     variant?: ButtonProps['variant'];
+    /** Color from theme */
     color?: ButtonProps['color'];
+    /** Component size */
     size?: ButtonProps['size'];
 };
 type __VLS_Props = TreeRootProps;

package/dist/runtime/components/tree/index.d.ts

@@ -1 +1 @@
-export * from './model.js';
+export * from './types.js';

package/dist/runtime/components/tree/index.js

@@ -1 +1 @@
-export * from "./model.js";
+export * from "./types.js";

package/dist/runtime/components/tree/lib/context.d.ts

@@ -1,25 +1,40 @@
 import type { ButtonProps } from '@nui/components';
 import type { ModelRef, ShallowRef } from 'vue';
-import type { TreeFilter, TreeIconResolver, TreeLoader } from '../model.js';
+import type { TreeFilter, TreeIconResolver, TreeLoader } from '../types.js';
 type EventType = 'select' | 'expand';
 type SelectMode = 'single' | 'multiple' | 'range';
 export interface TreeContext {
+    /** Ref to the root `<ul>` element */
     root: ShallowRef<HTMLUListElement | null>;
+    /** Path of the active (focused) item */
     active: ModelRef<string | null>;
+    /** Paths of selected items */
     selected: ModelRef<string[]>;
+    /** Paths of expanded directory items */
     expanded: ModelRef<string[]>;
+    /** Resolves the icon for a given tree item */
     iconResolver: TreeIconResolver;
+    /** Async loader for branch data */
     loadBranch: TreeLoader;
+    /** Filters which items are rendered */
     filter?: TreeFilter;
+    /** Whether multiple items can be selected */
     selectable: boolean;
+    /** Visual variant */
     variant: ButtonProps['variant'];
+    /** Color from theme */
     color: ButtonProps['color'];
+    /** Component size */
     size: ButtonProps['size'];
 }
 export interface TreeState extends Omit<TreeContext, 'root'> {
+    /** Toggles selection or expansion state of an item */
     toggle: (type: EventType, path: string, mode?: SelectMode) => void;
+    /** Activates selection or expansion for an item */
     on: ((type: 'expand', path: string) => void) & ((type: 'select', path: string, mode?: SelectMode) => void);
+    /** Deactivates selection or expansion for an item */
     off: (type: EventType, path: string) => void;
+    /** Sets the active (focused) item path */
     setActive: (path: string | null) => void;
 }
 export declare const useProvideTreeState: (args_0: TreeContext) => TreeState;

package/dist/runtime/components/tree/lib/context.js

@@ -1,4 +1,4 @@
-import { createStrictInjection } from "@nui/helpers";
+import { createStrictInjection } from "@nui/composables";
 import { unrefElement } from "@vueuse/core";
 const injectionKey = Symbol("nui-tree");
 const [useProvide, useState] = createStrictInjection(({

package/dist/runtime/components/tree/lib/filter-tree-items.d.ts

@@ -1,2 +1,2 @@
-import type { TreeFilter, TreeItem } from '../model.js';
+import type { TreeFilter, TreeItem } from '../types.js';
 export declare function filterTreeItems(items: TreeItem[] | undefined, filter?: TreeFilter): TreeItem[] | undefined;

package/dist/runtime/components/tree/tree.d.vue.ts

@@ -1,5 +1,5 @@
 import type { TreeRootProps } from './_ui/tree-root.vue.js';
-import type { TreeModels } from './model.js';
+import type { TreeModels } from './types.js';
 export interface TreeProps extends TreeRootProps {
 }
 type __VLS_Props = TreeProps;

package/dist/runtime/components/tree/tree.vue

@@ -33,24 +33,24 @@ onMounted(execute);
 </script>
 
 <template>
-	<TreeRoot
-		v-bind='props'
-		v-model:active='active'
-		v-model:selected='selected'
-		v-model:expanded='expanded'
-		:load-branch
-		:size
-		:color
-		:variant
-		:filter
-		@delete='(path) => $emit("delete", path)'
-	>
-		<UTreeItem
-			v-for='item in root'
-			:key='item.path'
-			v-bind='item'
-			:path='item.path'
-			:level='1'
-		/>
-	</TreeRoot>
+	<TreeRoot
+		v-bind='props'
+		v-model:active='active'
+		v-model:selected='selected'
+		v-model:expanded='expanded'
+		:load-branch
+		:size
+		:color
+		:variant
+		:filter
+		@delete='(path) => $emit("delete", path)'
+	>
+		<UTreeItem
+			v-for='item in root'
+			:key='item.path'
+			v-bind='item'
+			:path='item.path'
+			:level='1'
+		/>
+	</TreeRoot>
 </template>

package/dist/runtime/components/tree/tree.vue.d.ts

@@ -1,5 +1,5 @@
 import type { TreeRootProps } from './_ui/tree-root.vue.js';
-import type { TreeModels } from './model.js';
+import type { TreeModels } from './types.js';
 export interface TreeProps extends TreeRootProps {
 }
 type __VLS_Props = TreeProps;

package/dist/runtime/components/tree/{model.d.ts → types.d.ts}

@@ -1,17 +1,25 @@
 import type { NuanceColor } from '@nui/types';
 import type { Ref } from 'vue';
 export interface TreeModels {
+    /** Path of the active (focused) item */
     active: string | null;
+    /** Flat tree data */
     tree: TreeItem[];
+    /** Paths of selected items */
     selected: string[];
+    /** Paths of expanded directory items */
     expanded: string[];
 }
 export interface TreeEmits {
+    /** Fired when selected items are deleted */
     delete: [path: string[]];
 }
 export interface TreeLoaderResult {
+    /** Loaded branch data */
     data: Ref<TreeItem[] | undefined>;
+    /** Whether the branch is loading */
     pending: Ref<boolean>;
+    /** Triggers data fetching */
     execute: () => Promise<unknown>;
 }
 /**
@@ -49,6 +57,7 @@ export interface TreeItem {
      *  @default `file`
      */
     type?: TreeItemType;
+    /** Nested child items */
     children?: TreeItem[];
 }
 export type TreeIconResolver = (type: TreeItemType, name?: string, path?: string, disabled?: boolean) => {

package/dist/runtime/components/visually-hidden/visually-hidden-input.d.vue.ts

@@ -1,7 +1,10 @@
 import type { VisuallyHiddenProps } from './visually-hidden.vue.js';
 export interface VisuallyHiddenInputProps extends VisuallyHiddenProps {
-    name: string;
+    /** Input name */
+    name?: string;
+    /** Marks the input as required */
     required?: boolean;
+    /** Disables the input */
     disabled?: boolean;
 }
 declare const __VLS_export: <T>(__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<{

package/dist/runtime/components/visually-hidden/visually-hidden-input.vue

@@ -1,7 +1,7 @@
 <script setup>
 import VisuallyHidden from "./visually-hidden.vue";
 const props = defineProps({
-  name: { type: String, required: true },
+  name: { type: String, required: false },
   required: { type: Boolean, required: false },
   disabled: { type: Boolean, required: false },
   feature: { type: String, required: false },

package/dist/runtime/components/visually-hidden/visually-hidden-input.vue.d.ts

@@ -1,7 +1,10 @@
 import type { VisuallyHiddenProps } from './visually-hidden.vue.js';
 export interface VisuallyHiddenInputProps extends VisuallyHiddenProps {
-    name: string;
+    /** Input name */
+    name?: string;
+    /** Marks the input as required */
     required?: boolean;
+    /** Disables the input */
     disabled?: boolean;
 }
 declare const __VLS_export: <T>(__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<{

package/dist/runtime/components/visually-hidden/visually-hidden.d.vue.ts

@@ -1,5 +1,6 @@
 import type { BoxProps } from '../box.vue.js';
 export interface VisuallyHiddenProps extends BoxProps {
+    /** Controls accessibility behaviour: `'focusable'` adds `aria-hidden`, `'fully-hidden'` removes from tab order */
     feature?: 'focusable' | 'fully-hidden';
 }
 declare var __VLS_8: {};

package/dist/runtime/components/visually-hidden/visually-hidden.vue.d.ts

@@ -1,5 +1,6 @@
 import type { BoxProps } from '../box.vue.js';
 export interface VisuallyHiddenProps extends BoxProps {
+    /** Controls accessibility behaviour: `'focusable'` adds `aria-hidden`, `'fully-hidden'` removes from tab order */
     feature?: 'focusable' | 'fully-hidden';
 }
 declare var __VLS_8: {};

package/dist/runtime/composables/create-strict-injection.d.ts

@@ -0,0 +1,42 @@
+import type { InjectionKey } from '@vue/runtime-core';
+import type { CreateInjectionStateOptions } from '@vueuse/core';
+interface StrictInjectionOptions<Return> extends Omit<CreateInjectionStateOptions<Return>, 'injectionKey'> {
+    /** Human-readable context name embedded into the missing-provider error message. */
+    name: string;
+    /** Vue injection key used to store and read the provided state. */
+    injectionKey: InjectionKey<Return>;
+}
+type StrictInjectionReturn<Arguments extends Array<any>, Return> = Readonly<[
+    /**
+     * Provider function to be called in a parent component.
+     * Creates and provides the state to all descendant components.
+     */
+    useProvidingState: (...args: Arguments) => Return,
+    /**
+     * Consumer function to be called in a child component.
+     * Injects the state provided by the nearest parent provider.
+     *
+     * @throws {Error} When called outside of a provider context
+     */
+    useInjectedState: () => Return
+]>;
+/**
+ * Creates a strict provide/inject.
+ *
+ * Unlike Vue's standard `inject`, the returned consumer hook throws a
+ * descriptive error when called outside of a provider, so misuse surfaces
+ * immediately instead of producing silent `undefined` values downstream.
+ *
+ * @example
+ * ```ts
+ * const [useProvideComboboxState, useComboboxState] = createStrictInjection(
+ *   (state: ComboboxState) => ({
+ *     ...state,
+ *     select: (item: string) => { state.selected.value = item },
+ *   }),
+ *   { name: 'ComboboxState', injectionKey: Symbol('combobox-state') },
+ * )
+ * ```
+ */
+export declare function createStrictInjection<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options: StrictInjectionOptions<Return>): StrictInjectionReturn<Arguments, Return>;
+export {};

package/dist/runtime/{composals → composables}/index.d.ts

@@ -1,4 +1,6 @@
+export * from './create-strict-injection.js';
 export * from './use-active-link.js';
 export * from './use-date-config.js';
+export * from './use-selectable-group.js';
 export * from './use-style-resolver.js';
 export * from './use-theme.js';

package/dist/runtime/{composals → composables}/index.js

@@ -1,4 +1,6 @@
+export * from "./create-strict-injection.js";
 export * from "./use-active-link.js";
 export * from "./use-date-config.js";
+export * from "./use-selectable-group.js";
 export * from "./use-style-resolver.js";
 export * from "./use-theme.js";

package/dist/runtime/composables/use-active-link.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedRef } from 'vue';
+import type { RouteLocationRaw } from 'vue-router';
+/**
+ * Computes whether a given route target matches the current route.
+ *
+ * By default the link is active when its resolved path equals the current
+ * path or is a prefix of it, so parent routes stay highlighted while
+ * browsing nested children.
+ *
+ * Pass `exact: true` to disable prefix matching.
+ */
+export declare function useActiveLink(href: RouteLocationRaw | undefined, options?: {
+    /** Require a strict path equality instead of prefix matching. */
+    exact?: boolean;
+}): ComputedRef<boolean>;

package/dist/runtime/{composals → composables}/use-date-config.d.ts

@@ -1,5 +1,7 @@
 import type { FormatOptions } from '@formkit/tempo';
+/** Locale configuration for date-aware features. */
 export type DateConfig = Omit<FormatOptions, 'date' | 'format'> & {
+    /** Index of the first day of the week (0 = Sunday, 1 = Monday, ...). */
     firstDayOfWeek: number;
 };
 declare const Inject: () => {
@@ -10,8 +12,11 @@ declare const Inject: () => {
     partFilter?: (part: import("@formkit/tempo").Part) => boolean;
 } | undefined;
 /**
- * Hook to provide the dates configuration in a root or parent component.
- * Necessary for initializing the configuration that will be used by child components.
+ * Provides the shared date configuration to the component subtree.
+ *
+ * Call once in a root or layout component.
+ *
+ * When `firstDayOfWeek` is omitted, it is resolved from the locale.
  */
 export declare const useProvideDatesConfig: (state?: Partial<DateConfig> | undefined) => {
     firstDayOfWeek: number;
@@ -21,10 +26,10 @@ export declare const useProvideDatesConfig: (state?: Partial<DateConfig> | undef
     partFilter?: (part: import("@formkit/tempo").Part) => boolean;
 };
 /**
- * Hook to inject the dates configuration in a component.
- * Used in components that depend on the dates configuration.
+ * Reads the shared date configuration provided by `useProvideDatesConfig`.
  *
- * @param localValue merges new values with ctx with `defu`
+ * A local override can be passed in and will be shallow-merged on top of the
+ * injected config.
  */
 export declare function useDatesConfig(localValue?: ReturnType<typeof Inject>): {
     firstDayOfWeek: number;

package/dist/runtime/composables/use-selectable-group.d.ts

@@ -0,0 +1,23 @@
+import type { ModelRef } from 'vue';
+export interface UseSelectableGroupOptions {
+    /** When `true`, the value cannot be changed. */
+    readOnly?: boolean;
+    /** When `true`, all items in the group are disabled. */
+    disabled?: boolean;
+    /** Maximum number of items that can be selected. When reached, unselected items become disabled. */
+    maxSelectedValues?: number;
+}
+export interface UseSelectableGroupReturn<T> {
+    /** Toggles the given value in the selection array. */
+    update: (value: T) => void;
+    /** Returns `true` when the value is currently selected. */
+    isSelected: (value: T) => boolean;
+    /** Returns `true` when an item with the given value should be disabled. */
+    isDisabled: (value: T) => boolean;
+}
+/**
+ * Shared selection logic for multi-select group components.
+ *
+ * Centralizes the add/remove, max-limit and read-only rules.
+ */
+export declare function useSelectableGroup<T extends string = string>(value: ModelRef<T[]>, options?: UseSelectableGroupOptions): UseSelectableGroupReturn<T>;

package/dist/runtime/composables/use-selectable-group.js

@@ -0,0 +1,20 @@
+export function useSelectableGroup(value, options = {}) {
+  const isSelected = (item) => value.value.includes(item);
+  const update = (item) => {
+    if (options.readOnly)
+      return;
+    const selected = isSelected(item);
+    if (!selected && options.maxSelectedValues !== void 0 && value.value.length >= options.maxSelectedValues) {
+      return;
+    }
+    value.value = selected ? value.value.filter((i) => i !== item) : [...value.value, item];
+  };
+  const isDisabled = (item) => {
+    if (options.disabled)
+      return true;
+    if (options.maxSelectedValues === void 0)
+      return false;
+    return !isSelected(item) && value.value.length >= options.maxSelectedValues;
+  };
+  return { update, isSelected, isDisabled };
+}

package/dist/runtime/{composals → composables}/use-style-resolver.d.ts

@@ -1,3 +1,6 @@
 import type { NuanceTheme } from '@nui/types';
 import type { CSSProperties } from 'vue';
+/**
+ * Builds a style object from a factory that receives the current theme.
+ */
 export declare function useStyleResolver<T extends CSSProperties>(factory: (theme: NuanceTheme) => T): T;

package/dist/runtime/composables/use-theme.d.ts

@@ -0,0 +1,16 @@
+import type { NuanceTheme } from '@nui/types';
+interface ThemeInstance {
+    /** User-selected theme preference, including `system`. Writable. */
+    preference: NuanceTheme;
+    /** Resolved theme currently applied to the document. */
+    readonly value: NuanceTheme;
+    /** `true` while the theme has not yet been determined on the client. */
+    unknown: boolean;
+    /** `true` when the theme is forced by the application and cannot be changed by the user. */
+    forced: boolean;
+}
+/**
+ * Returns the current Nuance theme instance
+ */
+export declare function useTheme(): ThemeInstance;
+export {};

package/dist/runtime/modals/_confirm-modal/confirm-modal.d.vue.ts

@@ -1,5 +1,5 @@
+import type { MaybePromise } from '@nui/types';
 import type { ButtonProps, ModalRootProps } from '../../components/index.js';
-import type { MaybePromise } from '../../types/index.js';
 type ConfirmLabels = Record<'confirm' | 'cancel', string>;
 export interface ConfirmModalProps extends /* @vue-ignore */ ModalRootProps {
     /** Modal title */

package/dist/runtime/modals/_confirm-modal/confirm-modal.vue

@@ -45,37 +45,37 @@ async function hanleConfirm() {
 </script>
 
 <template>
-	<ModalRoot v-model:open='opened' v-bind='rest' :close-on-click-outside size='sm'>
-		<ModalHeader>
-			<Title order='4'>
-				{{ title }}
-			</Title>
-			<ModalCloseButton />
-		</ModalHeader>
-
-		<p v-if='body' :class='$style.body'>
-			{{ body }}
-		</p>
-
-		<footer :class='$style.footer'>
-			<Button
-				variant='default'
-				v-bind='cancelProps'
-				@click='handleCancel()'
-			>
-				{{ labels?.cancel ?? "Cancel" }}
-			</Button>
-			<Button
-				variant='filled'
-				v-bind='confirmProps'
-				:color="variant === 'danger' ? 'red' : void 0"
-				:loading
-				@click='hanleConfirm()'
-			>
-				{{ labels?.confirm ?? "Confirm" }}
-			</Button>
-		</footer>
-	</ModalRoot>
+	<ModalRoot v-model:open='opened' v-bind='rest' :close-on-click-outside size='sm'>
+		<ModalHeader>
+			<Title order='4'>
+				{{ title }}
+			</Title>
+			<ModalCloseButton />
+		</ModalHeader>
+
+		<p v-if='body' :class='$style.body'>
+			{{ body }}
+		</p>
+
+		<footer :class='$style.footer'>
+			<Button
+				variant='default'
+				v-bind='cancelProps'
+				@click='handleCancel()'
+			>
+				{{ labels?.cancel ?? "Cancel" }}
+			</Button>
+			<Button
+				variant='filled'
+				v-bind='confirmProps'
+				:color="variant === 'danger' ? 'red' : void 0"
+				:loading
+				@click='hanleConfirm()'
+			>
+				{{ labels?.confirm ?? "Confirm" }}
+			</Button>
+		</footer>
+	</ModalRoot>
 </template>
 
 <style module>

package/dist/runtime/modals/_confirm-modal/confirm-modal.vue.d.ts

@@ -1,5 +1,5 @@
+import type { MaybePromise } from '@nui/types';
 import type { ButtonProps, ModalRootProps } from '../../components/index.js';
-import type { MaybePromise } from '../../types/index.js';
 type ConfirmLabels = Record<'confirm' | 'cancel', string>;
 export interface ConfirmModalProps extends /* @vue-ignore */ ModalRootProps {
     /** Modal title */

package/dist/runtime/modals/modal-manager.d.ts

@@ -1,68 +1,51 @@
 import type { Component } from 'vue';
-/**
- * Reactive state of a single modal within {@link ModalManager}.
- */
+/** Reactive state of a single active modal. */
 export interface ModalState<Props extends object = object, Resolve = unknown, Reject = unknown> {
-    /** Unique modal identifier */
+    /** Unique modal identifier. */
     id: string;
-    /** Vue component rendered as the modal */
+    /** Vue component rendered as the modal. */
     component: Component;
-    /** Props passed when calling `show` or the opener function */
+    /** Props passed when opening the modal. */
     props: Props;
-    /** Current visibility state */
+    /** Current visibility state. */
     opened: boolean;
-    /** Resolves the promise created when the modal was opened */
+    /** Resolves the promise created when the modal was opened. */
     resolve: (value?: Resolve) => void;
-    /** Rejects the promise created when the modal was opened */
+    /** Rejects the promise created when the modal was opened. */
     reject: (reason?: Reject) => void;
 }
+/**
+ * Global modal manager.
+ *
+ * Maintains a component registry and a reactive map of active modals.
+ * Opening a modal returns a promise that resolves via `resolve` or rejects
+ * via `reject` / user dismissal.
+ *
+ * @example
+ * ```ts
+ * const open = $modals.create<MyProps, string>('my-modal', MyModal)
+ * const result = await open({ foo: 'bar' }) // result: string
+ * ```
+ */
 export declare class ModalManager {
     #private;
     /** Reactive map of active modals */
     readonly modals: import("vue").Reactive<Map<string, ModalState<object, unknown, unknown>>>;
     private constructor();
     static get instance(): ModalManager;
-    /**
-     * Registers a modal component and returns a typed function to open it.
-     */
-    create<TProps extends object = object, TResult = void>(
-    /** unique modal identifier */
-    id: string, 
-    /** Vue component for the modal */
-    component: Component): (props?: TProps) => Promise<TResult>;
-    /**
-     * Registers a lazy modal — the component is loaded on first open.
-     */
-    createLazy<TProps extends object = object, TResult = void>(
-    /** unique modal identifier */
-    id: string, 
-    /** dynamic import function (`() => import('./my-modal.vue')`) */
-    loader: () => Promise<{
+    /** Registers a modal component and returns a typed opener function. */
+    create<TProps extends object = object, TResult = void>(id: string, component: Component): (props?: TProps) => Promise<TResult>;
+    /** Registers a lazy modal. The component is loaded on first open. */
+    createLazy<TProps extends object = object, TResult = void>(id: string, loader: () => Promise<{
         default: Component;
     }>): (props?: Omit<TProps, 'modalId'>) => Promise<TResult>;
-    /**
-     * Opens a previously registered modal by its identifier.
-     */
+    /** Opens a previously registered modal by its identifier. */
     show<T = unknown>(id: string, props?: object): Promise<T>;
-    /**
-     * Closes the modal and resolves its promise with the given result.
-     *
-     * @param id     — modal identifier
-     * @param result — value the promise resolves with
-     */
+    /** Closes the modal and resolves its promise with the given result. */
     resolve(id: string, result?: any): void;
-    /**
-     * Closes the modal and rejects its promise with the given reason.
-     *
-     * @param id     — modal identifier
-     * @param reason — rejection reason
-     */
+    /** Closes the modal and rejects its promise with the given reason. */
     reject(id: string, reason?: any): void;
-    /**
-     * Returns the reactive state of a specific modal as `ComputedRef<ModalState>`.
-     *
-     * Used inside a modal component (via {@link useModal}).
-     */
+    /** Returns the reactive state of a specific modal. */
     state<Props extends object = object, Resolve = unknown, Reject = unknown>(id: string): ModalState<Props, Resolve, Reject>;
 }
 export declare const $modals: import("vue").Raw<ModalManager>;