@hydrateless/vue 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/README.md +125 -40
  2. package/dist/index.d.ts +2340 -1007
  3. package/dist/index.js +1297 -1451
  4. package/package.json +5 -5
package/dist/index.d.ts CHANGED
@@ -1,148 +1,749 @@
1
1
  import * as vue from 'vue';
2
- import { WatchSource, Ref, ShallowRef, Plugin, Directive, PropType } from 'vue';
2
+ import { Ref, MaybeRefOrGetter, WatchSource, ShallowRef, ExtractPublicPropTypes, PropType, VNode } from 'vue';
3
3
  import * as _hydrateless_enhancers from '@hydrateless/enhancers';
4
- import { EnhancerHandle, EnhanceToastOptions, ToastApi, EnhanceTabsOptions, EnhanceDropdownOptions, EnhanceMenuOptions, EnhanceComboboxOptions } from '@hydrateless/enhancers';
5
- export { AccordionApi, ComboboxApi, CommandApi, DisclosureApi, Disposer, DrawerApi, DropdownApi, EnhancerHandle, MenuApi, ModalApi, PopoverApi, TabsApi, ToastApi, TocApi, TooltipApi } from '@hydrateless/enhancers';
4
+ import { EnhancerHandle, EnhanceToastOptions, ToastApi, EnhanceTabsOptions, EnhanceDropdownOptions, EnhanceMenuOptions, EnhancePopoverOptions, EnhanceTooltipOptions, EnhanceComboboxOptions } from '@hydrateless/enhancers';
5
+ export { AccordionApi, ComboboxApi, CommandApi, DisclosureApi, Disposer, DrawerApi, DropdownApi, EnhancerHandle, MenuApi, ModalApi, PopoverApi, TabsApi, ToastApi, ToastIntent, ToastOptions, TocApi, TooltipApi } from '@hydrateless/enhancers';
6
6
 
7
7
  /**
8
- * Attach any Hydrateless enhancer to a host element for the lifetime of a
9
- * component. Returns a template ref to bind onto the element you want
10
- * enhanced plus a shallow ref to the enhancer's imperative API (e.g.
11
- * `setValue`/`setOpen`). The enhancer runs client-side only (so components
12
- * stay SSR-safe) and is destroyed automatically on unmount. Pass a reactive
13
- * `source` to destroy and re-attach whenever an enhancer option changes.
8
+ * Attach a Hydrateless enhancer to a template ref for the lifetime of the
9
+ * component. This is the one low-level escape hatch in `@hydrateless/vue`:
10
+ * every component in the package is built on it, and you can use it directly
11
+ * for markup the components don't cover. Returns a shallow ref to the
12
+ * enhancer's imperative API (`setValue`, `setOpen`, and so on), `null` until
13
+ * mounted. The enhancer runs client-side only, so components stay SSR-safe,
14
+ * and is destroyed on unmount. `options` may be a getter; it's re-read, and
15
+ * the enhancer re-attached, whenever `deps` changes.
14
16
  *
15
17
  * ```vue
16
18
  * <script setup>
17
- * const { host, api } = useEnhancer((el) => enhanceTabs(el));
19
+ * import { useTemplateRef } from 'vue';
20
+ * import { enhanceTabs } from '@hydrateless/enhancers';
21
+ * const host = useTemplateRef('host');
22
+ * const api = useEnhancer(host, enhanceTabs, { activation: 'automatic' });
18
23
  * // api.value?.setValue('two');
19
24
  * </script>
20
- * <template><div data-hl-tabs ref="host">…</div></template>
25
+ * <template><div data-hl-tabs ref="host">...</div></template>
21
26
  * ```
22
27
  */
23
- declare function useEnhancer<Api = null>(enhance: (el: HTMLElement) => EnhancerHandle<Api>, source?: WatchSource<unknown>): {
24
- host: Ref<HTMLElement | null>;
25
- api: ShallowRef<Api | null>;
26
- };
28
+ declare function useEnhancer<Options extends object, Api>(el: Ref<HTMLElement | null>, enhancer: (container: HTMLElement, options?: Partial<Options>) => EnhancerHandle<Api>, options?: MaybeRefOrGetter<Partial<Options>>, deps?: WatchSource<unknown>): ShallowRef<Api | null>;
27
29
 
28
30
  /**
29
- * Imperative toast API backed by a lazily-created document-level region (or a
30
- * `[data-hl-toast-region]` you render yourself, e.g. via `<ToastRegion>`).
31
- * Safe to call from any component: no provider required.
31
+ * Imperative toast API: `show(message, { duration, intent })` and
32
+ * `dismiss(toast)`. Toasts render into the page's `[data-hl-toast-region]`
33
+ * (mount a `<ToastRegion>` once near the app root) or into a region created
34
+ * on demand, so no provider is required and it's safe to call from any
35
+ * component.
32
36
  */
33
37
  declare function useToast(options?: EnhanceToastOptions): ToastApi;
34
38
 
39
+ type Size = 'sm' | 'md' | 'lg';
40
+ /** Bindings a control inside a `<Field>` reads through {@link useField}. */
41
+ interface FieldBindings {
42
+ /** Id shared by the control and its `<FieldLabel>`. */
43
+ readonly id: string;
44
+ /** Space-separated ids of the rendered help and error text, if any. */
45
+ readonly describedBy: string | undefined;
46
+ readonly invalid: boolean;
47
+ readonly required: boolean;
48
+ }
49
+ declare const fieldProps: {
50
+ readonly id: {
51
+ readonly type: StringConstructor;
52
+ readonly default: undefined;
53
+ };
54
+ /** Renders a `<FieldLabel>`; the `label` slot takes precedence. */
55
+ readonly label: {
56
+ readonly type: StringConstructor;
57
+ readonly default: undefined;
58
+ };
59
+ /** Renders a `<FieldHelp>`. */
60
+ readonly description: {
61
+ readonly type: StringConstructor;
62
+ readonly default: undefined;
63
+ };
64
+ /** Renders a `<FieldError>` and marks the field invalid. */
65
+ readonly error: {
66
+ readonly type: StringConstructor;
67
+ readonly default: undefined;
68
+ };
69
+ readonly invalid: {
70
+ readonly type: BooleanConstructor;
71
+ readonly default: false;
72
+ };
73
+ readonly required: {
74
+ readonly type: BooleanConstructor;
75
+ readonly default: false;
76
+ };
77
+ };
78
+ /** Props for {@link Field}. */
79
+ type FieldProps = ExtractPublicPropTypes<typeof fieldProps>;
35
80
  /**
36
- * Registers every Hydrateless directive globally:
37
- *
38
- * ```ts
39
- * import { HydratelessPlugin } from '@hydrateless/vue';
40
- * createApp(App).use(HydratelessPlugin);
41
- * ```
42
- *
43
- * Then use `v-hl-tabs`, `v-hl-dropdown`, etc. in templates.
81
+ * Layout + accessibility wrapper for a control. Provides a shared id so
82
+ * `<FieldLabel>`, `<FieldHelp>`, and `<FieldError>` (or the `label`,
83
+ * `description`, and `error` props) wire up automatically, and every
84
+ * Hydrateless control placed inside reads its `id`, `aria-describedby`,
85
+ * `aria-invalid`, and `required` through {@link useField}.
44
86
  */
45
- declare const HydratelessPlugin: Plugin;
46
-
47
- /** `v-hl-accordion` directive: single-open accordion behavior on the bound element. */
48
- declare const vHlAccordion: Directive<HTMLElement>;
49
- /** `v-hl-disclosure` directive: groups `[data-hl-disclosure]` elements within the bound element. */
50
- declare const vHlDisclosure: Directive<HTMLElement>;
51
- /** `v-hl-tabs` directive: ARIA and keyboard navigation for a `[data-hl-tabs]` element. */
52
- declare const vHlTabs: Directive<HTMLElement>;
53
- /** `v-hl-dropdown` directive: menu-button behavior for a `[data-hl-dropdown]` element. */
54
- declare const vHlDropdown: Directive<HTMLElement>;
55
- /** `v-hl-modal` directive: wires modal openers/closers and a focus trap within the bound element. */
56
- declare const vHlModal: Directive<HTMLElement>;
57
- /** `v-hl-drawer` directive: wires drawer openers/closers within the bound element. */
58
- declare const vHlDrawer: Directive<HTMLElement>;
59
- /** `v-hl-popover` directive: wires popover openers/closers within the bound element. */
60
- declare const vHlPopover: Directive<HTMLElement>;
61
- /** `v-hl-tooltip` directive: wires `[data-hl-tooltip]` triggers within the bound element. */
62
- declare const vHlTooltip: Directive<HTMLElement>;
63
- /** `v-hl-toc` directive: builds a table of contents from the surrounding document. */
64
- declare const vHlToc: Directive<HTMLElement>;
65
- /** `v-hl-menu` directive: menubar/navigation behavior for a `[data-hl-menu]` element. */
66
- declare const vHlMenu: Directive<HTMLElement>;
67
- /** `v-hl-combobox` directive: editable combobox behavior for a `[data-hl-combobox]` element. */
68
- declare const vHlCombobox: Directive<HTMLElement>;
69
- /** `v-hl-command` directive: command-palette behavior for a `[data-hl-command]` element. */
70
- declare const vHlCommand: Directive<HTMLElement>;
71
- /** Map of directive names (without the `v-` prefix) to their definitions. */
72
- declare const directives: Record<string, Directive<HTMLElement>>;
87
+ declare const Field: vue.DefineComponent<vue.ExtractPropTypes<{
88
+ readonly id: {
89
+ readonly type: StringConstructor;
90
+ readonly default: undefined;
91
+ };
92
+ /** Renders a `<FieldLabel>`; the `label` slot takes precedence. */
93
+ readonly label: {
94
+ readonly type: StringConstructor;
95
+ readonly default: undefined;
96
+ };
97
+ /** Renders a `<FieldHelp>`. */
98
+ readonly description: {
99
+ readonly type: StringConstructor;
100
+ readonly default: undefined;
101
+ };
102
+ /** Renders a `<FieldError>` and marks the field invalid. */
103
+ readonly error: {
104
+ readonly type: StringConstructor;
105
+ readonly default: undefined;
106
+ };
107
+ readonly invalid: {
108
+ readonly type: BooleanConstructor;
109
+ readonly default: false;
110
+ };
111
+ readonly required: {
112
+ readonly type: BooleanConstructor;
113
+ readonly default: false;
114
+ };
115
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
116
+ [key: string]: any;
117
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
118
+ readonly id: {
119
+ readonly type: StringConstructor;
120
+ readonly default: undefined;
121
+ };
122
+ /** Renders a `<FieldLabel>`; the `label` slot takes precedence. */
123
+ readonly label: {
124
+ readonly type: StringConstructor;
125
+ readonly default: undefined;
126
+ };
127
+ /** Renders a `<FieldHelp>`. */
128
+ readonly description: {
129
+ readonly type: StringConstructor;
130
+ readonly default: undefined;
131
+ };
132
+ /** Renders a `<FieldError>` and marks the field invalid. */
133
+ readonly error: {
134
+ readonly type: StringConstructor;
135
+ readonly default: undefined;
136
+ };
137
+ readonly invalid: {
138
+ readonly type: BooleanConstructor;
139
+ readonly default: false;
140
+ };
141
+ readonly required: {
142
+ readonly type: BooleanConstructor;
143
+ readonly default: false;
144
+ };
145
+ }>> & Readonly<{}>, {
146
+ readonly error: string;
147
+ readonly invalid: boolean;
148
+ readonly label: string;
149
+ readonly id: string;
150
+ readonly description: string;
151
+ readonly required: boolean;
152
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
153
+ /**
154
+ * Bindings for a custom control inside a `<Field>` (`id`, `describedBy`,
155
+ * `invalid`, `required`), live as the field's props change. Returns `null`
156
+ * outside a `<Field>`, so controls can read it unconditionally.
157
+ */
158
+ declare function useField(): FieldBindings | null;
159
+ /** Props for {@link FieldLabel}. */
160
+ type FieldLabelProps = Record<never, never>;
161
+ /** Props for {@link FieldHelp}. */
162
+ type FieldHelpProps = Record<never, never>;
163
+ /** Props for {@link FieldError}. */
164
+ type FieldErrorProps = Record<never, never>;
165
+ /** Props for {@link Fieldset}. */
166
+ type FieldsetProps = Record<never, never>;
167
+ /** Label for a {@link Field}'s control, associated with it by id. */
168
+ declare const FieldLabel: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
169
+ [key: string]: any;
170
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
171
+ /** Help text for a {@link Field}, linked to its control via `aria-describedby`. */
172
+ declare const FieldHelp: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
173
+ [key: string]: any;
174
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
175
+ /** Validation message for a {@link Field}; renders nothing until it has content. */
176
+ declare const FieldError: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
177
+ [key: string]: any;
178
+ }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
179
+ /** Groups related controls in a native fieldset with an optional `legend` slot. */
180
+ declare const Fieldset: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
181
+ [key: string]: any;
182
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
183
+ declare const inputProps: {
184
+ readonly modelValue: {
185
+ readonly type: PropType<string | number>;
186
+ readonly default: undefined;
187
+ };
188
+ readonly size: {
189
+ readonly type: PropType<Size>;
190
+ readonly default: undefined;
191
+ };
192
+ readonly invalid: {
193
+ readonly type: BooleanConstructor;
194
+ readonly default: false;
195
+ };
196
+ };
197
+ /** Props for {@link Input}. */
198
+ type InputProps = ExtractPublicPropTypes<typeof inputProps>;
199
+ /** Text input styled with the `hl-input` primitive. Supports `v-model` and `<Field>` wiring. */
200
+ declare const Input: vue.DefineComponent<vue.ExtractPropTypes<{
201
+ readonly modelValue: {
202
+ readonly type: PropType<string | number>;
203
+ readonly default: undefined;
204
+ };
205
+ readonly size: {
206
+ readonly type: PropType<Size>;
207
+ readonly default: undefined;
208
+ };
209
+ readonly invalid: {
210
+ readonly type: BooleanConstructor;
211
+ readonly default: false;
212
+ };
213
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
214
+ [key: string]: any;
215
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
216
+ readonly modelValue: {
217
+ readonly type: PropType<string | number>;
218
+ readonly default: undefined;
219
+ };
220
+ readonly size: {
221
+ readonly type: PropType<Size>;
222
+ readonly default: undefined;
223
+ };
224
+ readonly invalid: {
225
+ readonly type: BooleanConstructor;
226
+ readonly default: false;
227
+ };
228
+ }>> & Readonly<{
229
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
230
+ }>, {
231
+ readonly invalid: boolean;
232
+ readonly size: Size;
233
+ readonly modelValue: string | number;
234
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
235
+ declare const textareaProps: {
236
+ readonly modelValue: {
237
+ readonly type: StringConstructor;
238
+ readonly default: undefined;
239
+ };
240
+ /** Grow with the content (`field-sizing: content`). */
241
+ readonly autosize: {
242
+ readonly type: BooleanConstructor;
243
+ readonly default: false;
244
+ };
245
+ readonly size: {
246
+ readonly type: PropType<Size>;
247
+ readonly default: undefined;
248
+ };
249
+ readonly invalid: {
250
+ readonly type: BooleanConstructor;
251
+ readonly default: false;
252
+ };
253
+ };
254
+ /** Props for {@link Textarea}. */
255
+ type TextareaProps = ExtractPublicPropTypes<typeof textareaProps>;
256
+ /** Multi-line text input. Supports `v-model` and `<Field>` wiring. */
257
+ declare const Textarea: vue.DefineComponent<vue.ExtractPropTypes<{
258
+ readonly modelValue: {
259
+ readonly type: StringConstructor;
260
+ readonly default: undefined;
261
+ };
262
+ /** Grow with the content (`field-sizing: content`). */
263
+ readonly autosize: {
264
+ readonly type: BooleanConstructor;
265
+ readonly default: false;
266
+ };
267
+ readonly size: {
268
+ readonly type: PropType<Size>;
269
+ readonly default: undefined;
270
+ };
271
+ readonly invalid: {
272
+ readonly type: BooleanConstructor;
273
+ readonly default: false;
274
+ };
275
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
276
+ [key: string]: any;
277
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
278
+ readonly modelValue: {
279
+ readonly type: StringConstructor;
280
+ readonly default: undefined;
281
+ };
282
+ /** Grow with the content (`field-sizing: content`). */
283
+ readonly autosize: {
284
+ readonly type: BooleanConstructor;
285
+ readonly default: false;
286
+ };
287
+ readonly size: {
288
+ readonly type: PropType<Size>;
289
+ readonly default: undefined;
290
+ };
291
+ readonly invalid: {
292
+ readonly type: BooleanConstructor;
293
+ readonly default: false;
294
+ };
295
+ }>> & Readonly<{
296
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
297
+ }>, {
298
+ readonly invalid: boolean;
299
+ readonly size: Size;
300
+ readonly modelValue: string;
301
+ readonly autosize: boolean;
302
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
303
+ declare const selectProps: {
304
+ readonly modelValue: {
305
+ readonly type: StringConstructor;
306
+ readonly default: undefined;
307
+ };
308
+ readonly size: {
309
+ readonly type: PropType<Size>;
310
+ readonly default: undefined;
311
+ };
312
+ readonly invalid: {
313
+ readonly type: BooleanConstructor;
314
+ readonly default: false;
315
+ };
316
+ };
317
+ /** Props for {@link Select}. */
318
+ type SelectProps = ExtractPublicPropTypes<typeof selectProps>;
319
+ /** Native `<select>` styled with `hl-select`. Supports `v-model` and `<Field>` wiring. */
320
+ declare const Select: vue.DefineComponent<vue.ExtractPropTypes<{
321
+ readonly modelValue: {
322
+ readonly type: StringConstructor;
323
+ readonly default: undefined;
324
+ };
325
+ readonly size: {
326
+ readonly type: PropType<Size>;
327
+ readonly default: undefined;
328
+ };
329
+ readonly invalid: {
330
+ readonly type: BooleanConstructor;
331
+ readonly default: false;
332
+ };
333
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
334
+ [key: string]: any;
335
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
336
+ readonly modelValue: {
337
+ readonly type: StringConstructor;
338
+ readonly default: undefined;
339
+ };
340
+ readonly size: {
341
+ readonly type: PropType<Size>;
342
+ readonly default: undefined;
343
+ };
344
+ readonly invalid: {
345
+ readonly type: BooleanConstructor;
346
+ readonly default: false;
347
+ };
348
+ }>> & Readonly<{
349
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
350
+ }>, {
351
+ readonly invalid: boolean;
352
+ readonly size: Size;
353
+ readonly modelValue: string;
354
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
355
+ declare const checkedProps: {
356
+ readonly modelValue: {
357
+ readonly type: BooleanConstructor;
358
+ readonly default: undefined;
359
+ };
360
+ };
361
+ /** Props for {@link Checkbox}. */
362
+ type CheckboxProps = ExtractPublicPropTypes<typeof checkedProps>;
363
+ /** Props for {@link Switch}. */
364
+ type SwitchProps = ExtractPublicPropTypes<typeof checkedProps>;
365
+ /** Checkbox built on a native input, label-wrapped. Supports `v-model` and `<Field>` wiring. */
366
+ declare const Checkbox: vue.DefineComponent<vue.ExtractPropTypes<{
367
+ readonly modelValue: {
368
+ readonly type: BooleanConstructor;
369
+ readonly default: undefined;
370
+ };
371
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
372
+ [key: string]: any;
373
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
374
+ readonly modelValue: {
375
+ readonly type: BooleanConstructor;
376
+ readonly default: undefined;
377
+ };
378
+ }>> & Readonly<{
379
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
380
+ }>, {
381
+ readonly modelValue: boolean;
382
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
383
+ /** Toggle switch built on a native checkbox. Supports `v-model` and `<Field>` wiring. */
384
+ declare const Switch: vue.DefineComponent<vue.ExtractPropTypes<{
385
+ readonly modelValue: {
386
+ readonly type: BooleanConstructor;
387
+ readonly default: undefined;
388
+ };
389
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
390
+ [key: string]: any;
391
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
392
+ readonly modelValue: {
393
+ readonly type: BooleanConstructor;
394
+ readonly default: undefined;
395
+ };
396
+ }>> & Readonly<{
397
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
398
+ }>, {
399
+ readonly modelValue: boolean;
400
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
401
+ declare const sliderProps: {
402
+ readonly modelValue: {
403
+ readonly type: PropType<string | number>;
404
+ readonly default: undefined;
405
+ };
406
+ };
407
+ /** Props for {@link Slider}. */
408
+ type SliderProps = ExtractPublicPropTypes<typeof sliderProps>;
409
+ /** Range slider primitive. Supports `v-model` and `<Field>` wiring. */
410
+ declare const Slider: vue.DefineComponent<vue.ExtractPropTypes<{
411
+ readonly modelValue: {
412
+ readonly type: PropType<string | number>;
413
+ readonly default: undefined;
414
+ };
415
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
416
+ [key: string]: any;
417
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
418
+ readonly modelValue: {
419
+ readonly type: PropType<string | number>;
420
+ readonly default: undefined;
421
+ };
422
+ }>> & Readonly<{
423
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
424
+ }>, {
425
+ readonly modelValue: string | number;
426
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
427
+ declare const radioGroupProps: {
428
+ /** Controlled selected value (`v-model`). */
429
+ readonly modelValue: {
430
+ readonly type: StringConstructor;
431
+ readonly default: undefined;
432
+ };
433
+ /** Initially selected value for uncontrolled usage. */
434
+ readonly defaultValue: {
435
+ readonly type: StringConstructor;
436
+ readonly default: undefined;
437
+ };
438
+ /** Shared `name` for the radios; generated when omitted. */
439
+ readonly name: {
440
+ readonly type: StringConstructor;
441
+ readonly default: undefined;
442
+ };
443
+ /** Layout direction; sets `data-hl-orientation` and `aria-orientation`. */
444
+ readonly orientation: {
445
+ readonly type: PropType<"horizontal" | "vertical">;
446
+ readonly default: undefined;
447
+ };
448
+ };
449
+ /** Props for {@link RadioGroup}. */
450
+ type RadioGroupProps = ExtractPublicPropTypes<typeof radioGroupProps>;
451
+ /**
452
+ * Groups radios under `role="radiogroup"`, sharing a name and managing the
453
+ * selected value (uncontrolled via `defaultValue` or controlled via `v-model`).
454
+ */
455
+ declare const RadioGroup: vue.DefineComponent<vue.ExtractPropTypes<{
456
+ /** Controlled selected value (`v-model`). */
457
+ readonly modelValue: {
458
+ readonly type: StringConstructor;
459
+ readonly default: undefined;
460
+ };
461
+ /** Initially selected value for uncontrolled usage. */
462
+ readonly defaultValue: {
463
+ readonly type: StringConstructor;
464
+ readonly default: undefined;
465
+ };
466
+ /** Shared `name` for the radios; generated when omitted. */
467
+ readonly name: {
468
+ readonly type: StringConstructor;
469
+ readonly default: undefined;
470
+ };
471
+ /** Layout direction; sets `data-hl-orientation` and `aria-orientation`. */
472
+ readonly orientation: {
473
+ readonly type: PropType<"horizontal" | "vertical">;
474
+ readonly default: undefined;
475
+ };
476
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
477
+ [key: string]: any;
478
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
479
+ /** Controlled selected value (`v-model`). */
480
+ readonly modelValue: {
481
+ readonly type: StringConstructor;
482
+ readonly default: undefined;
483
+ };
484
+ /** Initially selected value for uncontrolled usage. */
485
+ readonly defaultValue: {
486
+ readonly type: StringConstructor;
487
+ readonly default: undefined;
488
+ };
489
+ /** Shared `name` for the radios; generated when omitted. */
490
+ readonly name: {
491
+ readonly type: StringConstructor;
492
+ readonly default: undefined;
493
+ };
494
+ /** Layout direction; sets `data-hl-orientation` and `aria-orientation`. */
495
+ readonly orientation: {
496
+ readonly type: PropType<"horizontal" | "vertical">;
497
+ readonly default: undefined;
498
+ };
499
+ }>> & Readonly<{
500
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
501
+ }>, {
502
+ readonly name: string;
503
+ readonly modelValue: string;
504
+ readonly defaultValue: string;
505
+ readonly orientation: "horizontal" | "vertical";
506
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
507
+ declare const radioProps: {
508
+ readonly value: {
509
+ readonly type: StringConstructor;
510
+ readonly required: true;
511
+ };
512
+ };
513
+ /** Props for {@link Radio}. */
514
+ type RadioProps = ExtractPublicPropTypes<typeof radioProps>;
515
+ /** A single radio. Inside a `<RadioGroup>` it binds to the shared value. */
516
+ declare const Radio: vue.DefineComponent<vue.ExtractPropTypes<{
517
+ readonly value: {
518
+ readonly type: StringConstructor;
519
+ readonly required: true;
520
+ };
521
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
522
+ [key: string]: any;
523
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
524
+ readonly value: {
525
+ readonly type: StringConstructor;
526
+ readonly required: true;
527
+ };
528
+ }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
529
+ /** One choice in a {@link SegmentedControl}. */
530
+ interface SegmentedOption {
531
+ label: string;
532
+ value: string;
533
+ disabled?: boolean;
534
+ }
535
+ declare const segmentedControlProps: {
536
+ readonly options: {
537
+ readonly type: PropType<SegmentedOption[]>;
538
+ readonly default: () => never[];
539
+ };
540
+ /** Controlled selected value (`v-model`). */
541
+ readonly modelValue: {
542
+ readonly type: StringConstructor;
543
+ readonly default: undefined;
544
+ };
545
+ /** Initially selected value for uncontrolled usage; defaults to the first option. */
546
+ readonly defaultValue: {
547
+ readonly type: StringConstructor;
548
+ readonly default: undefined;
549
+ };
550
+ readonly name: {
551
+ readonly type: StringConstructor;
552
+ readonly default: undefined;
553
+ };
554
+ readonly size: {
555
+ readonly type: PropType<Size>;
556
+ readonly default: undefined;
557
+ };
558
+ };
559
+ /** Props for {@link SegmentedControl}. */
560
+ type SegmentedControlProps = ExtractPublicPropTypes<typeof segmentedControlProps>;
561
+ /**
562
+ * Segmented control: a styled radiogroup. The selected value works
563
+ * uncontrolled (`defaultValue`, else the first option) or with `v-model`.
564
+ */
565
+ declare const SegmentedControl: vue.DefineComponent<vue.ExtractPropTypes<{
566
+ readonly options: {
567
+ readonly type: PropType<SegmentedOption[]>;
568
+ readonly default: () => never[];
569
+ };
570
+ /** Controlled selected value (`v-model`). */
571
+ readonly modelValue: {
572
+ readonly type: StringConstructor;
573
+ readonly default: undefined;
574
+ };
575
+ /** Initially selected value for uncontrolled usage; defaults to the first option. */
576
+ readonly defaultValue: {
577
+ readonly type: StringConstructor;
578
+ readonly default: undefined;
579
+ };
580
+ readonly name: {
581
+ readonly type: StringConstructor;
582
+ readonly default: undefined;
583
+ };
584
+ readonly size: {
585
+ readonly type: PropType<Size>;
586
+ readonly default: undefined;
587
+ };
588
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
589
+ [key: string]: any;
590
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
591
+ readonly options: {
592
+ readonly type: PropType<SegmentedOption[]>;
593
+ readonly default: () => never[];
594
+ };
595
+ /** Controlled selected value (`v-model`). */
596
+ readonly modelValue: {
597
+ readonly type: StringConstructor;
598
+ readonly default: undefined;
599
+ };
600
+ /** Initially selected value for uncontrolled usage; defaults to the first option. */
601
+ readonly defaultValue: {
602
+ readonly type: StringConstructor;
603
+ readonly default: undefined;
604
+ };
605
+ readonly name: {
606
+ readonly type: StringConstructor;
607
+ readonly default: undefined;
608
+ };
609
+ readonly size: {
610
+ readonly type: PropType<Size>;
611
+ readonly default: undefined;
612
+ };
613
+ }>> & Readonly<{
614
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
615
+ }>, {
616
+ readonly name: string;
617
+ readonly size: Size;
618
+ readonly modelValue: string;
619
+ readonly defaultValue: string;
620
+ readonly options: SegmentedOption[];
621
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
73
622
 
623
+ declare const accordionProps: {
624
+ readonly allowMultiple: {
625
+ readonly type: BooleanConstructor;
626
+ readonly default: false;
627
+ };
628
+ /** Controlled list of open item values (`v-model`). */
629
+ readonly modelValue: {
630
+ readonly type: PropType<string[]>;
631
+ readonly default: undefined;
632
+ };
633
+ /** Initially open item values for uncontrolled usage. */
634
+ readonly defaultValue: {
635
+ readonly type: PropType<string[]>;
636
+ readonly default: undefined;
637
+ };
638
+ };
639
+ /** Props for {@link Accordion}. */
640
+ type AccordionProps = ExtractPublicPropTypes<typeof accordionProps>;
74
641
  /**
75
642
  * Accordion root of native `<details>` items. Compose with `<AccordionItem>`.
76
643
  * Item values come from each `<AccordionItem value>`, defaulting to the index;
77
- * open state works uncontrolled (`defaultValue` or `defaultOpen` on items) or
78
- * with `v-model`.
644
+ * open state works uncontrolled (`defaultValue`) or with `v-model`.
79
645
  */
80
646
  declare const Accordion: vue.DefineComponent<vue.ExtractPropTypes<{
81
- allowMultiple: {
82
- type: BooleanConstructor;
83
- default: boolean;
647
+ readonly allowMultiple: {
648
+ readonly type: BooleanConstructor;
649
+ readonly default: false;
84
650
  };
85
651
  /** Controlled list of open item values (`v-model`). */
86
- modelValue: {
87
- type: PropType<string[]>;
88
- default: undefined;
652
+ readonly modelValue: {
653
+ readonly type: PropType<string[]>;
654
+ readonly default: undefined;
89
655
  };
90
656
  /** Initially open item values for uncontrolled usage. */
91
- defaultValue: {
92
- type: PropType<string[]>;
93
- default: undefined;
657
+ readonly defaultValue: {
658
+ readonly type: PropType<string[]>;
659
+ readonly default: undefined;
94
660
  };
95
661
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
96
662
  [key: string]: any;
97
663
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
98
- allowMultiple: {
99
- type: BooleanConstructor;
100
- default: boolean;
664
+ readonly allowMultiple: {
665
+ readonly type: BooleanConstructor;
666
+ readonly default: false;
101
667
  };
102
668
  /** Controlled list of open item values (`v-model`). */
103
- modelValue: {
104
- type: PropType<string[]>;
105
- default: undefined;
669
+ readonly modelValue: {
670
+ readonly type: PropType<string[]>;
671
+ readonly default: undefined;
106
672
  };
107
673
  /** Initially open item values for uncontrolled usage. */
108
- defaultValue: {
109
- type: PropType<string[]>;
110
- default: undefined;
674
+ readonly defaultValue: {
675
+ readonly type: PropType<string[]>;
676
+ readonly default: undefined;
111
677
  };
112
678
  }>> & Readonly<{
113
679
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
114
680
  }>, {
115
- allowMultiple: boolean;
116
- modelValue: string[];
117
- defaultValue: string[];
681
+ readonly modelValue: string[];
682
+ readonly defaultValue: string[];
683
+ readonly allowMultiple: boolean;
118
684
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
119
- /** A `<details>`-based accordion section. Use the `summary` slot for the trigger. */
685
+ declare const accordionItemProps: {
686
+ /** Stable value identifying this item; defaults to its index. */
687
+ readonly value: {
688
+ readonly type: StringConstructor;
689
+ readonly default: undefined;
690
+ };
691
+ /** Header text; the `summary` slot takes precedence. */
692
+ readonly title: {
693
+ readonly type: StringConstructor;
694
+ readonly default: undefined;
695
+ };
696
+ };
697
+ /** Props for {@link AccordionItem}. */
698
+ type AccordionItemProps = ExtractPublicPropTypes<typeof accordionItemProps>;
699
+ /** A `<details>`-based accordion section. Use `title` or the `summary` slot for the header. */
120
700
  declare const AccordionItem: vue.DefineComponent<vue.ExtractPropTypes<{
121
701
  /** Stable value identifying this item; defaults to its index. */
122
- value: {
123
- type: StringConstructor;
124
- default: undefined;
702
+ readonly value: {
703
+ readonly type: StringConstructor;
704
+ readonly default: undefined;
125
705
  };
126
- defaultOpen: {
127
- type: BooleanConstructor;
128
- default: boolean;
706
+ /** Header text; the `summary` slot takes precedence. */
707
+ readonly title: {
708
+ readonly type: StringConstructor;
709
+ readonly default: undefined;
129
710
  };
130
711
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
131
712
  [key: string]: any;
132
713
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
133
714
  /** Stable value identifying this item; defaults to its index. */
134
- value: {
135
- type: StringConstructor;
136
- default: undefined;
715
+ readonly value: {
716
+ readonly type: StringConstructor;
717
+ readonly default: undefined;
137
718
  };
138
- defaultOpen: {
139
- type: BooleanConstructor;
140
- default: boolean;
719
+ /** Header text; the `summary` slot takes precedence. */
720
+ readonly title: {
721
+ readonly type: StringConstructor;
722
+ readonly default: undefined;
141
723
  };
142
724
  }>> & Readonly<{}>, {
143
- value: string;
144
- defaultOpen: boolean;
725
+ readonly value: string;
726
+ readonly title: string;
145
727
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
728
+ declare const disclosureProps: {
729
+ /** Controlled open state (`v-model:open`). */
730
+ readonly open: {
731
+ readonly type: PropType<boolean | undefined>;
732
+ readonly default: undefined;
733
+ };
734
+ /** Open the disclosure initially for uncontrolled usage. */
735
+ readonly defaultOpen: {
736
+ readonly type: BooleanConstructor;
737
+ readonly default: false;
738
+ };
739
+ /** Header text; the `summary` slot takes precedence. */
740
+ readonly title: {
741
+ readonly type: StringConstructor;
742
+ readonly default: undefined;
743
+ };
744
+ };
745
+ /** Props for {@link Disclosure}. */
746
+ type DisclosureProps = ExtractPublicPropTypes<typeof disclosureProps>;
146
747
  /**
147
748
  * A single expandable section built on native `<details>`, which handles
148
749
  * open/close (and exclusive groups, via the `name` attribute) on its own.
@@ -150,39 +751,74 @@ declare const AccordionItem: vue.DefineComponent<vue.ExtractPropTypes<{
150
751
  */
151
752
  declare const Disclosure: vue.DefineComponent<vue.ExtractPropTypes<{
152
753
  /** Controlled open state (`v-model:open`). */
153
- open: {
154
- type: PropType<boolean | undefined>;
155
- default: undefined;
754
+ readonly open: {
755
+ readonly type: PropType<boolean | undefined>;
756
+ readonly default: undefined;
156
757
  };
157
758
  /** Open the disclosure initially for uncontrolled usage. */
158
- defaultOpen: {
159
- type: BooleanConstructor;
160
- default: boolean;
759
+ readonly defaultOpen: {
760
+ readonly type: BooleanConstructor;
761
+ readonly default: false;
762
+ };
763
+ /** Header text; the `summary` slot takes precedence. */
764
+ readonly title: {
765
+ readonly type: StringConstructor;
766
+ readonly default: undefined;
161
767
  };
162
768
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
163
769
  [key: string]: any;
164
770
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
165
771
  /** Controlled open state (`v-model:open`). */
166
- open: {
167
- type: PropType<boolean | undefined>;
168
- default: undefined;
772
+ readonly open: {
773
+ readonly type: PropType<boolean | undefined>;
774
+ readonly default: undefined;
169
775
  };
170
776
  /** Open the disclosure initially for uncontrolled usage. */
171
- defaultOpen: {
172
- type: BooleanConstructor;
173
- default: boolean;
777
+ readonly defaultOpen: {
778
+ readonly type: BooleanConstructor;
779
+ readonly default: false;
780
+ };
781
+ /** Header text; the `summary` slot takes precedence. */
782
+ readonly title: {
783
+ readonly type: StringConstructor;
784
+ readonly default: undefined;
174
785
  };
175
786
  }>> & Readonly<{
176
787
  "onUpdate:open"?: ((...args: any[]) => any) | undefined;
177
788
  }>, {
178
- defaultOpen: boolean;
179
- open: boolean | undefined;
789
+ readonly title: string;
790
+ readonly open: boolean | undefined;
791
+ readonly defaultOpen: boolean;
180
792
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
181
793
 
794
+ declare const tabsProps: {
795
+ readonly activation: {
796
+ readonly type: PropType<EnhanceTabsOptions["activation"]>;
797
+ readonly default: undefined;
798
+ };
799
+ readonly orientation: {
800
+ readonly type: PropType<EnhanceTabsOptions["orientation"]>;
801
+ readonly default: undefined;
802
+ };
803
+ /** Controlled value of the selected tab (`v-model`). */
804
+ readonly modelValue: {
805
+ readonly type: StringConstructor;
806
+ readonly default: undefined;
807
+ };
808
+ /** Initial value for uncontrolled usage. */
809
+ readonly defaultValue: {
810
+ readonly type: StringConstructor;
811
+ readonly default: undefined;
812
+ };
813
+ };
814
+ /** Props for {@link Tabs}. */
815
+ type TabsProps = ExtractPublicPropTypes<typeof tabsProps>;
182
816
  /**
183
817
  * Tabbed interface root. Compose with `<TabList>`, `<Tab>`, and `<TabPanel>`.
184
818
  * Tab values come from each `<Tab value>`, defaulting to the index; selection
185
- * works uncontrolled (`defaultValue`) or with `v-model`.
819
+ * works uncontrolled (`defaultValue`) or with `v-model`. Selection state is
820
+ * rendered (`aria-selected`, `hidden`, roving `tabindex`), so server output
821
+ * is correct before the enhancer takes over.
186
822
  *
187
823
  * ```vue
188
824
  * <Tabs v-model="tab">
@@ -196,212 +832,558 @@ declare const Disclosure: vue.DefineComponent<vue.ExtractPropTypes<{
196
832
  * ```
197
833
  */
198
834
  declare const Tabs: vue.DefineComponent<vue.ExtractPropTypes<{
199
- activation: {
200
- type: PropType<EnhanceTabsOptions["activation"]>;
201
- default: undefined;
835
+ readonly activation: {
836
+ readonly type: PropType<EnhanceTabsOptions["activation"]>;
837
+ readonly default: undefined;
202
838
  };
203
- orientation: {
204
- type: PropType<EnhanceTabsOptions["orientation"]>;
205
- default: undefined;
839
+ readonly orientation: {
840
+ readonly type: PropType<EnhanceTabsOptions["orientation"]>;
841
+ readonly default: undefined;
206
842
  };
207
843
  /** Controlled value of the selected tab (`v-model`). */
208
- modelValue: {
209
- type: StringConstructor;
210
- default: undefined;
844
+ readonly modelValue: {
845
+ readonly type: StringConstructor;
846
+ readonly default: undefined;
211
847
  };
212
848
  /** Initial value for uncontrolled usage. */
213
- defaultValue: {
214
- type: StringConstructor;
215
- default: undefined;
849
+ readonly defaultValue: {
850
+ readonly type: StringConstructor;
851
+ readonly default: undefined;
216
852
  };
217
853
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
218
854
  [key: string]: any;
219
855
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
220
- activation: {
221
- type: PropType<EnhanceTabsOptions["activation"]>;
222
- default: undefined;
856
+ readonly activation: {
857
+ readonly type: PropType<EnhanceTabsOptions["activation"]>;
858
+ readonly default: undefined;
223
859
  };
224
- orientation: {
225
- type: PropType<EnhanceTabsOptions["orientation"]>;
226
- default: undefined;
860
+ readonly orientation: {
861
+ readonly type: PropType<EnhanceTabsOptions["orientation"]>;
862
+ readonly default: undefined;
227
863
  };
228
864
  /** Controlled value of the selected tab (`v-model`). */
229
- modelValue: {
230
- type: StringConstructor;
231
- default: undefined;
865
+ readonly modelValue: {
866
+ readonly type: StringConstructor;
867
+ readonly default: undefined;
232
868
  };
233
869
  /** Initial value for uncontrolled usage. */
234
- defaultValue: {
235
- type: StringConstructor;
236
- default: undefined;
870
+ readonly defaultValue: {
871
+ readonly type: StringConstructor;
872
+ readonly default: undefined;
237
873
  };
238
874
  }>> & Readonly<{
239
875
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
240
876
  }>, {
241
- modelValue: string;
242
- defaultValue: string;
243
- activation: "manual" | "automatic" | undefined;
244
- orientation: "horizontal" | "vertical" | undefined;
877
+ readonly modelValue: string;
878
+ readonly defaultValue: string;
879
+ readonly orientation: "horizontal" | "vertical" | undefined;
880
+ readonly activation: "manual" | "automatic" | undefined;
245
881
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
882
+ /** Props for {@link TabList}. */
883
+ type TabListProps = Record<never, never>;
246
884
  /** The row of tab triggers (`role="tablist"`). */
247
885
  declare const TabList: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
248
886
  [key: string]: any;
249
887
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
888
+ declare const tabProps: {
889
+ /** Stable value identifying this tab; defaults to its index. */
890
+ readonly value: {
891
+ readonly type: StringConstructor;
892
+ readonly default: undefined;
893
+ };
894
+ readonly disabled: {
895
+ readonly type: BooleanConstructor;
896
+ readonly default: false;
897
+ };
898
+ };
899
+ /** Props for {@link Tab}. */
900
+ type TabProps = ExtractPublicPropTypes<typeof tabProps>;
250
901
  /** A single tab trigger (`role="tab"`). */
251
902
  declare const Tab: vue.DefineComponent<vue.ExtractPropTypes<{
252
903
  /** Stable value identifying this tab; defaults to its index. */
253
- value: {
254
- type: StringConstructor;
255
- default: undefined;
904
+ readonly value: {
905
+ readonly type: StringConstructor;
906
+ readonly default: undefined;
907
+ };
908
+ readonly disabled: {
909
+ readonly type: BooleanConstructor;
910
+ readonly default: false;
256
911
  };
257
912
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
258
913
  [key: string]: any;
259
914
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
260
915
  /** Stable value identifying this tab; defaults to its index. */
261
- value: {
262
- type: StringConstructor;
263
- default: undefined;
916
+ readonly value: {
917
+ readonly type: StringConstructor;
918
+ readonly default: undefined;
919
+ };
920
+ readonly disabled: {
921
+ readonly type: BooleanConstructor;
922
+ readonly default: false;
264
923
  };
265
924
  }>> & Readonly<{}>, {
266
- value: string;
925
+ readonly value: string;
926
+ readonly disabled: boolean;
267
927
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
268
- /** Content for the matching tab (`role="tabpanel"`). */
928
+ /** Props for {@link TabPanel}. */
929
+ type TabPanelProps = Record<never, never>;
930
+ /** Content for the tab at the same position (`role="tabpanel"`). */
269
931
  declare const TabPanel: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
270
932
  [key: string]: any;
271
933
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
272
934
 
935
+ declare const dropdownProps: {
936
+ readonly placement: {
937
+ readonly type: PropType<EnhanceDropdownOptions["placement"]>;
938
+ readonly default: undefined;
939
+ };
940
+ /** Close the menu after an item is activated. Defaults to `true`. */
941
+ readonly closeOnSelect: {
942
+ readonly type: BooleanConstructor;
943
+ readonly default: true;
944
+ };
945
+ /** Controlled open state (`v-model:open`). */
946
+ readonly open: {
947
+ readonly type: PropType<boolean | undefined>;
948
+ readonly default: undefined;
949
+ };
950
+ /** Open the menu initially for uncontrolled usage. */
951
+ readonly defaultOpen: {
952
+ readonly type: BooleanConstructor;
953
+ readonly default: false;
954
+ };
955
+ };
956
+ /** Props for {@link Dropdown}. */
957
+ type DropdownProps = ExtractPublicPropTypes<typeof dropdownProps>;
273
958
  /**
274
959
  * Button-triggered menu (WAI-ARIA menu-button pattern). Compose with
275
- * `<DropdownTrigger>`, `<DropdownMenu>`, `<DropdownItem>`, and
276
- * `<DropdownSeparator>`. Open state works uncontrolled or with
277
- * `v-model:open`.
960
+ * `<DropdownTrigger>`, `<DropdownMenu>`, `<DropdownItem>`, `<DropdownGroup>`,
961
+ * and `<DropdownSeparator>`. The menu is a native `popover` toggled through
962
+ * `popovertarget`, so it opens before hydration; open state works
963
+ * uncontrolled or with `v-model:open`, and activating an item emits `select`
964
+ * with `(value, item, checked?)`.
278
965
  */
279
966
  declare const Dropdown: vue.DefineComponent<vue.ExtractPropTypes<{
280
- placement: {
281
- type: PropType<EnhanceDropdownOptions["placement"]>;
282
- default: undefined;
967
+ readonly placement: {
968
+ readonly type: PropType<EnhanceDropdownOptions["placement"]>;
969
+ readonly default: undefined;
970
+ };
971
+ /** Close the menu after an item is activated. Defaults to `true`. */
972
+ readonly closeOnSelect: {
973
+ readonly type: BooleanConstructor;
974
+ readonly default: true;
283
975
  };
284
976
  /** Controlled open state (`v-model:open`). */
285
- open: {
286
- type: PropType<boolean | undefined>;
287
- default: undefined;
977
+ readonly open: {
978
+ readonly type: PropType<boolean | undefined>;
979
+ readonly default: undefined;
288
980
  };
289
981
  /** Open the menu initially for uncontrolled usage. */
290
- defaultOpen: {
291
- type: BooleanConstructor;
292
- default: boolean;
982
+ readonly defaultOpen: {
983
+ readonly type: BooleanConstructor;
984
+ readonly default: false;
293
985
  };
294
986
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
295
987
  [key: string]: any;
296
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
297
- placement: {
298
- type: PropType<EnhanceDropdownOptions["placement"]>;
299
- default: undefined;
988
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("select" | "update:open")[], "select" | "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
989
+ readonly placement: {
990
+ readonly type: PropType<EnhanceDropdownOptions["placement"]>;
991
+ readonly default: undefined;
992
+ };
993
+ /** Close the menu after an item is activated. Defaults to `true`. */
994
+ readonly closeOnSelect: {
995
+ readonly type: BooleanConstructor;
996
+ readonly default: true;
300
997
  };
301
998
  /** Controlled open state (`v-model:open`). */
302
- open: {
303
- type: PropType<boolean | undefined>;
304
- default: undefined;
999
+ readonly open: {
1000
+ readonly type: PropType<boolean | undefined>;
1001
+ readonly default: undefined;
305
1002
  };
306
1003
  /** Open the menu initially for uncontrolled usage. */
307
- defaultOpen: {
308
- type: BooleanConstructor;
309
- default: boolean;
1004
+ readonly defaultOpen: {
1005
+ readonly type: BooleanConstructor;
1006
+ readonly default: false;
310
1007
  };
311
1008
  }>> & Readonly<{
1009
+ onSelect?: ((...args: any[]) => any) | undefined;
312
1010
  "onUpdate:open"?: ((...args: any[]) => any) | undefined;
313
1011
  }>, {
314
- defaultOpen: boolean;
315
- open: boolean | undefined;
316
- placement: _hydrateless_enhancers.Placement | undefined;
1012
+ readonly open: boolean | undefined;
1013
+ readonly defaultOpen: boolean;
1014
+ readonly placement: _hydrateless_enhancers.Placement | undefined;
1015
+ readonly closeOnSelect: boolean;
317
1016
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
318
- /** The button that opens the menu. */
1017
+ /** Props for {@link DropdownTrigger}. */
1018
+ type DropdownTriggerProps = Record<never, never>;
1019
+ /** The button that opens the menu (`popovertarget` points at the menu). */
319
1020
  declare const DropdownTrigger: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
320
1021
  [key: string]: any;
321
1022
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
322
- /** The menu surface. */
1023
+ /** Props for {@link DropdownMenu}. */
1024
+ type DropdownMenuProps = Record<never, never>;
1025
+ /** The menu surface: a `popover` list of items. */
323
1026
  declare const DropdownMenu: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
324
1027
  [key: string]: any;
325
1028
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
326
- /** A selectable menu item (`role="menuitem"`). Emits `select` on click. */
327
- declare const DropdownItem: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1029
+ declare const dropdownItemProps: {
1030
+ /** Value reported on selection; defaults to the item's text. */
1031
+ readonly value: {
1032
+ readonly type: StringConstructor;
1033
+ readonly default: undefined;
1034
+ };
1035
+ readonly disabled: {
1036
+ readonly type: BooleanConstructor;
1037
+ readonly default: false;
1038
+ };
1039
+ /** `menuitemcheckbox` toggles, `menuitemradio` checks one per group. */
1040
+ readonly role: {
1041
+ readonly type: PropType<"menuitem" | "menuitemcheckbox" | "menuitemradio">;
1042
+ readonly default: "menuitem";
1043
+ };
1044
+ /** Checked state for checkable roles (sets `aria-checked`). */
1045
+ readonly checked: {
1046
+ readonly type: PropType<boolean | undefined>;
1047
+ readonly default: undefined;
1048
+ };
1049
+ };
1050
+ /** Props for {@link DropdownItem}. */
1051
+ type DropdownItemProps = ExtractPublicPropTypes<typeof dropdownItemProps>;
1052
+ /**
1053
+ * A menu item button. Emits both `click` (the native event) and `select`
1054
+ * (`value`, plus the new `checked` state for checkable roles).
1055
+ */
1056
+ declare const DropdownItem: vue.DefineComponent<vue.ExtractPropTypes<{
1057
+ /** Value reported on selection; defaults to the item's text. */
1058
+ readonly value: {
1059
+ readonly type: StringConstructor;
1060
+ readonly default: undefined;
1061
+ };
1062
+ readonly disabled: {
1063
+ readonly type: BooleanConstructor;
1064
+ readonly default: false;
1065
+ };
1066
+ /** `menuitemcheckbox` toggles, `menuitemradio` checks one per group. */
1067
+ readonly role: {
1068
+ readonly type: PropType<"menuitem" | "menuitemcheckbox" | "menuitemradio">;
1069
+ readonly default: "menuitem";
1070
+ };
1071
+ /** Checked state for checkable roles (sets `aria-checked`). */
1072
+ readonly checked: {
1073
+ readonly type: PropType<boolean | undefined>;
1074
+ readonly default: undefined;
1075
+ };
1076
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
328
1077
  [key: string]: any;
329
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<{}> & Readonly<{
1078
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("click" | "select")[], "click" | "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1079
+ /** Value reported on selection; defaults to the item's text. */
1080
+ readonly value: {
1081
+ readonly type: StringConstructor;
1082
+ readonly default: undefined;
1083
+ };
1084
+ readonly disabled: {
1085
+ readonly type: BooleanConstructor;
1086
+ readonly default: false;
1087
+ };
1088
+ /** `menuitemcheckbox` toggles, `menuitemradio` checks one per group. */
1089
+ readonly role: {
1090
+ readonly type: PropType<"menuitem" | "menuitemcheckbox" | "menuitemradio">;
1091
+ readonly default: "menuitem";
1092
+ };
1093
+ /** Checked state for checkable roles (sets `aria-checked`). */
1094
+ readonly checked: {
1095
+ readonly type: PropType<boolean | undefined>;
1096
+ readonly default: undefined;
1097
+ };
1098
+ }>> & Readonly<{
1099
+ onClick?: ((...args: any[]) => any) | undefined;
330
1100
  onSelect?: ((...args: any[]) => any) | undefined;
331
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1101
+ }>, {
1102
+ readonly value: string;
1103
+ readonly role: "menuitem" | "menuitemcheckbox" | "menuitemradio";
1104
+ readonly checked: boolean | undefined;
1105
+ readonly disabled: boolean;
1106
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1107
+ declare const dropdownGroupProps: {
1108
+ /** Accessible name of the group. */
1109
+ readonly label: {
1110
+ readonly type: StringConstructor;
1111
+ readonly default: undefined;
1112
+ };
1113
+ };
1114
+ /** Props for {@link DropdownGroup}. */
1115
+ type DropdownGroupProps = ExtractPublicPropTypes<typeof dropdownGroupProps>;
1116
+ /** A labelled `role="group"` of items; `menuitemradio` items check per group. */
1117
+ declare const DropdownGroup: vue.DefineComponent<vue.ExtractPropTypes<{
1118
+ /** Accessible name of the group. */
1119
+ readonly label: {
1120
+ readonly type: StringConstructor;
1121
+ readonly default: undefined;
1122
+ };
1123
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1124
+ [key: string]: any;
1125
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1126
+ /** Accessible name of the group. */
1127
+ readonly label: {
1128
+ readonly type: StringConstructor;
1129
+ readonly default: undefined;
1130
+ };
1131
+ }>> & Readonly<{}>, {
1132
+ readonly label: string;
1133
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1134
+ /** Props for {@link DropdownSeparator}. */
1135
+ type DropdownSeparatorProps = Record<never, never>;
332
1136
  /** A visual divider between groups of items. */
333
1137
  declare const DropdownSeparator: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
334
1138
  [key: string]: any;
335
1139
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
336
1140
 
1141
+ declare const menuProps: {
1142
+ readonly orientation: {
1143
+ readonly type: PropType<EnhanceMenuOptions["orientation"]>;
1144
+ readonly default: "horizontal";
1145
+ };
1146
+ /** Controlled value of the open submenu (`v-model`), or `null` for none. */
1147
+ readonly modelValue: {
1148
+ readonly type: PropType<string | null | undefined>;
1149
+ readonly default: undefined;
1150
+ };
1151
+ /** Submenu to open initially for uncontrolled usage. */
1152
+ readonly defaultValue: {
1153
+ readonly type: PropType<string | null>;
1154
+ readonly default: null;
1155
+ };
1156
+ };
1157
+ /** Props for {@link Menu}. */
1158
+ type MenuProps = ExtractPublicPropTypes<typeof menuProps>;
337
1159
  /**
338
1160
  * Menubar / navigation menu with single-level submenus rendered in the top
339
- * layer. Compose with `<MenuItem>`; nest a flyout via the `submenu` slot. The
340
- * open submenu works uncontrolled or with `v-model:open` (a submenu value or
341
- * `null`), and activating a leaf item emits `select` with its value.
1161
+ * layer. Compose with `<MenuItem>` leaves and `<MenuSubmenu>` flyouts. The
1162
+ * open submenu's value (from `<MenuSubmenu value>`) works uncontrolled
1163
+ * or with `v-model` (a submenu value or `null`), and activating a leaf item
1164
+ * emits `select` with `(value, item, checked?)`.
342
1165
  */
343
1166
  declare const Menu: vue.DefineComponent<vue.ExtractPropTypes<{
344
- orientation: {
345
- type: PropType<EnhanceMenuOptions["orientation"]>;
346
- default: string;
1167
+ readonly orientation: {
1168
+ readonly type: PropType<EnhanceMenuOptions["orientation"]>;
1169
+ readonly default: "horizontal";
347
1170
  };
348
- /** Controlled open submenu value (`v-model:open`), or `null` for none. */
349
- open: {
350
- type: PropType<string | null | undefined>;
351
- default: undefined;
1171
+ /** Controlled value of the open submenu (`v-model`), or `null` for none. */
1172
+ readonly modelValue: {
1173
+ readonly type: PropType<string | null | undefined>;
1174
+ readonly default: undefined;
1175
+ };
1176
+ /** Submenu to open initially for uncontrolled usage. */
1177
+ readonly defaultValue: {
1178
+ readonly type: PropType<string | null>;
1179
+ readonly default: null;
352
1180
  };
353
1181
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
354
1182
  [key: string]: any;
355
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("select" | "update:open")[], "select" | "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
356
- orientation: {
357
- type: PropType<EnhanceMenuOptions["orientation"]>;
358
- default: string;
1183
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("select" | "update:modelValue")[], "select" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1184
+ readonly orientation: {
1185
+ readonly type: PropType<EnhanceMenuOptions["orientation"]>;
1186
+ readonly default: "horizontal";
359
1187
  };
360
- /** Controlled open submenu value (`v-model:open`), or `null` for none. */
361
- open: {
362
- type: PropType<string | null | undefined>;
363
- default: undefined;
1188
+ /** Controlled value of the open submenu (`v-model`), or `null` for none. */
1189
+ readonly modelValue: {
1190
+ readonly type: PropType<string | null | undefined>;
1191
+ readonly default: undefined;
1192
+ };
1193
+ /** Submenu to open initially for uncontrolled usage. */
1194
+ readonly defaultValue: {
1195
+ readonly type: PropType<string | null>;
1196
+ readonly default: null;
364
1197
  };
365
1198
  }>> & Readonly<{
366
1199
  onSelect?: ((...args: any[]) => any) | undefined;
367
- "onUpdate:open"?: ((...args: any[]) => any) | undefined;
1200
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
368
1201
  }>, {
369
- open: string | null | undefined;
370
- orientation: "horizontal" | "vertical" | undefined;
1202
+ readonly modelValue: string | null | undefined;
1203
+ readonly defaultValue: string | null;
1204
+ readonly orientation: "horizontal" | "vertical" | undefined;
371
1205
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1206
+ declare const menuItemProps: {
1207
+ /** Render a link instead of a button. */
1208
+ readonly href: {
1209
+ readonly type: StringConstructor;
1210
+ readonly default: undefined;
1211
+ };
1212
+ /** Value reported to `select`; defaults to the item's text. */
1213
+ readonly value: {
1214
+ readonly type: StringConstructor;
1215
+ readonly default: undefined;
1216
+ };
1217
+ /** `menuitemcheckbox` toggles; `menuitemradio` is exclusive within its menu. Defaults to `menuitem`. */
1218
+ readonly role: {
1219
+ readonly type: PropType<"menuitem" | "menuitemcheckbox" | "menuitemradio">;
1220
+ readonly default: "menuitem";
1221
+ };
1222
+ /** Checked state for checkable roles (rendered as `aria-checked`). */
1223
+ readonly checked: {
1224
+ readonly type: BooleanConstructor;
1225
+ readonly default: undefined;
1226
+ };
1227
+ /** Skip the item in keyboard navigation and ignore activation. */
1228
+ readonly disabled: {
1229
+ readonly type: BooleanConstructor;
1230
+ readonly default: false;
1231
+ };
1232
+ };
1233
+ /** Props for {@link MenuItem}. */
1234
+ type MenuItemProps = ExtractPublicPropTypes<typeof menuItemProps>;
372
1235
  /**
373
- * A menu entry. Default slot is the label; the `submenu` slot nests a flyout.
374
- * With `href` it renders an anchor, otherwise a button. Emits `select`.
1236
+ * A leaf menu entry. Default slot is the label. With `href` it renders an
1237
+ * anchor, otherwise a button. Emits `click` on activation; the owning `Menu`
1238
+ * emits `select` with the item's value.
375
1239
  */
376
1240
  declare const MenuItem: vue.DefineComponent<vue.ExtractPropTypes<{
377
- href: {
378
- type: StringConstructor;
379
- default: undefined;
380
- };
381
- /** Stable value identifying this item; defaults to its label text. */
382
- value: {
383
- type: StringConstructor;
384
- default: undefined;
1241
+ /** Render a link instead of a button. */
1242
+ readonly href: {
1243
+ readonly type: StringConstructor;
1244
+ readonly default: undefined;
1245
+ };
1246
+ /** Value reported to `select`; defaults to the item's text. */
1247
+ readonly value: {
1248
+ readonly type: StringConstructor;
1249
+ readonly default: undefined;
1250
+ };
1251
+ /** `menuitemcheckbox` toggles; `menuitemradio` is exclusive within its menu. Defaults to `menuitem`. */
1252
+ readonly role: {
1253
+ readonly type: PropType<"menuitem" | "menuitemcheckbox" | "menuitemradio">;
1254
+ readonly default: "menuitem";
1255
+ };
1256
+ /** Checked state for checkable roles (rendered as `aria-checked`). */
1257
+ readonly checked: {
1258
+ readonly type: BooleanConstructor;
1259
+ readonly default: undefined;
1260
+ };
1261
+ /** Skip the item in keyboard navigation and ignore activation. */
1262
+ readonly disabled: {
1263
+ readonly type: BooleanConstructor;
1264
+ readonly default: false;
385
1265
  };
386
1266
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
387
1267
  [key: string]: any;
388
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
389
- href: {
390
- type: StringConstructor;
391
- default: undefined;
1268
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "click"[], "click", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1269
+ /** Render a link instead of a button. */
1270
+ readonly href: {
1271
+ readonly type: StringConstructor;
1272
+ readonly default: undefined;
392
1273
  };
393
- /** Stable value identifying this item; defaults to its label text. */
394
- value: {
395
- type: StringConstructor;
396
- default: undefined;
1274
+ /** Value reported to `select`; defaults to the item's text. */
1275
+ readonly value: {
1276
+ readonly type: StringConstructor;
1277
+ readonly default: undefined;
1278
+ };
1279
+ /** `menuitemcheckbox` toggles; `menuitemradio` is exclusive within its menu. Defaults to `menuitem`. */
1280
+ readonly role: {
1281
+ readonly type: PropType<"menuitem" | "menuitemcheckbox" | "menuitemradio">;
1282
+ readonly default: "menuitem";
1283
+ };
1284
+ /** Checked state for checkable roles (rendered as `aria-checked`). */
1285
+ readonly checked: {
1286
+ readonly type: BooleanConstructor;
1287
+ readonly default: undefined;
1288
+ };
1289
+ /** Skip the item in keyboard navigation and ignore activation. */
1290
+ readonly disabled: {
1291
+ readonly type: BooleanConstructor;
1292
+ readonly default: false;
397
1293
  };
398
1294
  }>> & Readonly<{
399
- onSelect?: ((...args: any[]) => any) | undefined;
1295
+ onClick?: ((...args: any[]) => any) | undefined;
400
1296
  }>, {
401
- value: string;
402
- href: string;
1297
+ readonly value: string;
1298
+ readonly role: "menuitem" | "menuitemcheckbox" | "menuitemradio";
1299
+ readonly checked: boolean;
1300
+ readonly disabled: boolean;
1301
+ readonly href: string;
1302
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1303
+ declare const menuSubmenuProps: {
1304
+ /** Plain-text label of the trigger item. Use the `trigger` slot for rich content. */
1305
+ readonly label: {
1306
+ readonly type: StringConstructor;
1307
+ readonly default: undefined;
1308
+ };
1309
+ /** Value the Menu reports while this submenu is open; defaults to the top-level index. */
1310
+ readonly value: {
1311
+ readonly type: StringConstructor;
1312
+ readonly default: undefined;
1313
+ };
1314
+ /** Skip the trigger in keyboard navigation and keep the submenu closed. */
1315
+ readonly disabled: {
1316
+ readonly type: BooleanConstructor;
1317
+ readonly default: false;
1318
+ };
1319
+ };
1320
+ /** Props for {@link MenuSubmenu}. */
1321
+ type MenuSubmenuProps = ExtractPublicPropTypes<typeof menuSubmenuProps>;
1322
+ /**
1323
+ * A top-level menu entry that opens a flyout of `<MenuItem>`s. Attrs go to
1324
+ * the submenu list (`role="menu"`). No `hidden` is rendered: before the
1325
+ * enhancer runs, the stylesheet shows the submenu on hover and focus-within so
1326
+ * the navigation stays usable.
1327
+ */
1328
+ declare const MenuSubmenu: vue.DefineComponent<vue.ExtractPropTypes<{
1329
+ /** Plain-text label of the trigger item. Use the `trigger` slot for rich content. */
1330
+ readonly label: {
1331
+ readonly type: StringConstructor;
1332
+ readonly default: undefined;
1333
+ };
1334
+ /** Value the Menu reports while this submenu is open; defaults to the top-level index. */
1335
+ readonly value: {
1336
+ readonly type: StringConstructor;
1337
+ readonly default: undefined;
1338
+ };
1339
+ /** Skip the trigger in keyboard navigation and keep the submenu closed. */
1340
+ readonly disabled: {
1341
+ readonly type: BooleanConstructor;
1342
+ readonly default: false;
1343
+ };
1344
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1345
+ [key: string]: any;
1346
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1347
+ /** Plain-text label of the trigger item. Use the `trigger` slot for rich content. */
1348
+ readonly label: {
1349
+ readonly type: StringConstructor;
1350
+ readonly default: undefined;
1351
+ };
1352
+ /** Value the Menu reports while this submenu is open; defaults to the top-level index. */
1353
+ readonly value: {
1354
+ readonly type: StringConstructor;
1355
+ readonly default: undefined;
1356
+ };
1357
+ /** Skip the trigger in keyboard navigation and keep the submenu closed. */
1358
+ readonly disabled: {
1359
+ readonly type: BooleanConstructor;
1360
+ readonly default: false;
1361
+ };
1362
+ }>> & Readonly<{}>, {
1363
+ readonly value: string;
1364
+ readonly label: string;
1365
+ readonly disabled: boolean;
403
1366
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
404
1367
 
1368
+ declare const modalProps: {
1369
+ /** Let Escape and backdrop clicks close the dialog (`closedby="any"`). */
1370
+ readonly closeOnBackdrop: {
1371
+ readonly type: BooleanConstructor;
1372
+ readonly default: true;
1373
+ };
1374
+ /** Controlled open state (`v-model:open`). */
1375
+ readonly open: {
1376
+ readonly type: PropType<boolean | undefined>;
1377
+ readonly default: undefined;
1378
+ };
1379
+ /** Open initially for uncontrolled usage. */
1380
+ readonly defaultOpen: {
1381
+ readonly type: BooleanConstructor;
1382
+ readonly default: false;
1383
+ };
1384
+ };
1385
+ /** Props for {@link Modal}. */
1386
+ type ModalProps = ExtractPublicPropTypes<typeof modalProps>;
405
1387
  /**
406
1388
  * Dialog overlay on the native `<dialog>` plus the modal enhancer (focus
407
1389
  * trap, scroll-lock, background `inert`). Open state works uncontrolled
@@ -410,44 +1392,70 @@ declare const MenuItem: vue.DefineComponent<vue.ExtractPropTypes<{
410
1392
  * with `<ModalHeader>`, `<ModalBody>`, `<ModalFooter>`.
411
1393
  */
412
1394
  declare const Modal: vue.DefineComponent<vue.ExtractPropTypes<{
413
- /** Controlled open state (`v-model:open`). */
414
- open: {
415
- type: PropType<boolean | undefined>;
416
- default: undefined;
1395
+ /** Let Escape and backdrop clicks close the dialog (`closedby="any"`). */
1396
+ readonly closeOnBackdrop: {
1397
+ readonly type: BooleanConstructor;
1398
+ readonly default: true;
417
1399
  };
418
- /** Open the dialog initially for uncontrolled usage. */
419
- defaultOpen: {
420
- type: BooleanConstructor;
421
- default: boolean;
1400
+ /** Controlled open state (`v-model:open`). */
1401
+ readonly open: {
1402
+ readonly type: PropType<boolean | undefined>;
1403
+ readonly default: undefined;
422
1404
  };
423
- closeOnBackdrop: {
424
- type: BooleanConstructor;
425
- default: boolean;
1405
+ /** Open initially for uncontrolled usage. */
1406
+ readonly defaultOpen: {
1407
+ readonly type: BooleanConstructor;
1408
+ readonly default: false;
426
1409
  };
427
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1410
+ }>, () => VNode<vue.RendererNode, vue.RendererElement, {
428
1411
  [key: string]: any;
429
1412
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
430
- /** Controlled open state (`v-model:open`). */
431
- open: {
432
- type: PropType<boolean | undefined>;
433
- default: undefined;
1413
+ /** Let Escape and backdrop clicks close the dialog (`closedby="any"`). */
1414
+ readonly closeOnBackdrop: {
1415
+ readonly type: BooleanConstructor;
1416
+ readonly default: true;
434
1417
  };
435
- /** Open the dialog initially for uncontrolled usage. */
436
- defaultOpen: {
437
- type: BooleanConstructor;
438
- default: boolean;
1418
+ /** Controlled open state (`v-model:open`). */
1419
+ readonly open: {
1420
+ readonly type: PropType<boolean | undefined>;
1421
+ readonly default: undefined;
439
1422
  };
440
- closeOnBackdrop: {
441
- type: BooleanConstructor;
442
- default: boolean;
1423
+ /** Open initially for uncontrolled usage. */
1424
+ readonly defaultOpen: {
1425
+ readonly type: BooleanConstructor;
1426
+ readonly default: false;
443
1427
  };
444
1428
  }>> & Readonly<{
445
1429
  "onUpdate:open"?: ((...args: any[]) => any) | undefined;
446
1430
  }>, {
447
- defaultOpen: boolean;
448
- open: boolean | undefined;
449
- closeOnBackdrop: boolean;
1431
+ readonly open: boolean | undefined;
1432
+ readonly defaultOpen: boolean;
1433
+ readonly closeOnBackdrop: boolean;
450
1434
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1435
+ declare const drawerProps: {
1436
+ /** Edge the panel slides in from (logical, so `end` is the right in LTR). */
1437
+ readonly side: {
1438
+ readonly type: PropType<"start" | "end">;
1439
+ readonly default: "end";
1440
+ };
1441
+ /** Let Escape and backdrop clicks close the dialog (`closedby="any"`). */
1442
+ readonly closeOnBackdrop: {
1443
+ readonly type: BooleanConstructor;
1444
+ readonly default: true;
1445
+ };
1446
+ /** Controlled open state (`v-model:open`). */
1447
+ readonly open: {
1448
+ readonly type: PropType<boolean | undefined>;
1449
+ readonly default: undefined;
1450
+ };
1451
+ /** Open initially for uncontrolled usage. */
1452
+ readonly defaultOpen: {
1453
+ readonly type: BooleanConstructor;
1454
+ readonly default: false;
1455
+ };
1456
+ };
1457
+ /** Props for {@link Drawer}. */
1458
+ type DrawerProps = ExtractPublicPropTypes<typeof drawerProps>;
451
1459
  /**
452
1460
  * Off-canvas panel on the native `<dialog>` plus the drawer enhancer. Open
453
1461
  * state works uncontrolled (`defaultOpen`, or an invoker button) or with
@@ -455,77 +1463,116 @@ declare const Modal: vue.DefineComponent<vue.ExtractPropTypes<{
455
1463
  * `<DrawerBody>`, `<DrawerFooter>`.
456
1464
  */
457
1465
  declare const Drawer: vue.DefineComponent<vue.ExtractPropTypes<{
458
- /** Controlled open state (`v-model:open`). */
459
- open: {
460
- type: PropType<boolean | undefined>;
461
- default: undefined;
1466
+ /** Edge the panel slides in from (logical, so `end` is the right in LTR). */
1467
+ readonly side: {
1468
+ readonly type: PropType<"start" | "end">;
1469
+ readonly default: "end";
462
1470
  };
463
- /** Open the drawer initially for uncontrolled usage. */
464
- defaultOpen: {
465
- type: BooleanConstructor;
466
- default: boolean;
1471
+ /** Let Escape and backdrop clicks close the dialog (`closedby="any"`). */
1472
+ readonly closeOnBackdrop: {
1473
+ readonly type: BooleanConstructor;
1474
+ readonly default: true;
467
1475
  };
468
- side: {
469
- type: PropType<"left" | "right">;
470
- default: string;
1476
+ /** Controlled open state (`v-model:open`). */
1477
+ readonly open: {
1478
+ readonly type: PropType<boolean | undefined>;
1479
+ readonly default: undefined;
471
1480
  };
472
- closeOnBackdrop: {
473
- type: BooleanConstructor;
474
- default: boolean;
1481
+ /** Open initially for uncontrolled usage. */
1482
+ readonly defaultOpen: {
1483
+ readonly type: BooleanConstructor;
1484
+ readonly default: false;
475
1485
  };
476
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1486
+ }>, () => VNode<vue.RendererNode, vue.RendererElement, {
477
1487
  [key: string]: any;
478
1488
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
479
- /** Controlled open state (`v-model:open`). */
480
- open: {
481
- type: PropType<boolean | undefined>;
482
- default: undefined;
1489
+ /** Edge the panel slides in from (logical, so `end` is the right in LTR). */
1490
+ readonly side: {
1491
+ readonly type: PropType<"start" | "end">;
1492
+ readonly default: "end";
483
1493
  };
484
- /** Open the drawer initially for uncontrolled usage. */
485
- defaultOpen: {
486
- type: BooleanConstructor;
487
- default: boolean;
1494
+ /** Let Escape and backdrop clicks close the dialog (`closedby="any"`). */
1495
+ readonly closeOnBackdrop: {
1496
+ readonly type: BooleanConstructor;
1497
+ readonly default: true;
488
1498
  };
489
- side: {
490
- type: PropType<"left" | "right">;
491
- default: string;
1499
+ /** Controlled open state (`v-model:open`). */
1500
+ readonly open: {
1501
+ readonly type: PropType<boolean | undefined>;
1502
+ readonly default: undefined;
492
1503
  };
493
- closeOnBackdrop: {
494
- type: BooleanConstructor;
495
- default: boolean;
1504
+ /** Open initially for uncontrolled usage. */
1505
+ readonly defaultOpen: {
1506
+ readonly type: BooleanConstructor;
1507
+ readonly default: false;
496
1508
  };
497
1509
  }>> & Readonly<{
498
1510
  "onUpdate:open"?: ((...args: any[]) => any) | undefined;
499
1511
  }>, {
500
- defaultOpen: boolean;
501
- open: boolean | undefined;
502
- closeOnBackdrop: boolean;
503
- side: "left" | "right";
1512
+ readonly open: boolean | undefined;
1513
+ readonly defaultOpen: boolean;
1514
+ readonly closeOnBackdrop: boolean;
1515
+ readonly side: "start" | "end";
504
1516
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1517
+ /** Props for {@link ModalHeader}. */
1518
+ type ModalHeaderProps = Record<never, never>;
1519
+ /** Props for {@link ModalBody}. */
1520
+ type ModalBodyProps = Record<never, never>;
1521
+ /** Props for {@link ModalFooter}. */
1522
+ type ModalFooterProps = Record<never, never>;
1523
+ /** Props for {@link DrawerHeader}. */
1524
+ type DrawerHeaderProps = Record<never, never>;
1525
+ /** Props for {@link DrawerBody}. */
1526
+ type DrawerBodyProps = Record<never, never>;
1527
+ /** Props for {@link DrawerFooter}. */
1528
+ type DrawerFooterProps = Record<never, never>;
505
1529
  /** Header region of a {@link Modal}. */
506
- declare const ModalHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1530
+ declare const ModalHeader: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
507
1531
  [key: string]: any;
508
1532
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
509
1533
  /** Body region of a {@link Modal}. */
510
- declare const ModalBody: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1534
+ declare const ModalBody: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
511
1535
  [key: string]: any;
512
1536
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
513
1537
  /** Footer region of a {@link Modal}. */
514
- declare const ModalFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1538
+ declare const ModalFooter: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
515
1539
  [key: string]: any;
516
1540
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
517
1541
  /** Header region of a {@link Drawer}. */
518
- declare const DrawerHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1542
+ declare const DrawerHeader: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
519
1543
  [key: string]: any;
520
1544
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
521
1545
  /** Body region of a {@link Drawer}. */
522
- declare const DrawerBody: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1546
+ declare const DrawerBody: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
523
1547
  [key: string]: any;
524
1548
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
525
1549
  /** Footer region of a {@link Drawer}. */
526
- declare const DrawerFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1550
+ declare const DrawerFooter: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
527
1551
  [key: string]: any;
528
1552
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1553
+ declare const popoverProps: {
1554
+ readonly placement: {
1555
+ readonly type: PropType<EnhancePopoverOptions["placement"]>;
1556
+ readonly default: undefined;
1557
+ };
1558
+ /** Open on pointer hover and focus of the invoker instead of click. */
1559
+ readonly hover: {
1560
+ readonly type: BooleanConstructor;
1561
+ readonly default: false;
1562
+ };
1563
+ /** Controlled open state (`v-model:open`). */
1564
+ readonly open: {
1565
+ readonly type: PropType<boolean | undefined>;
1566
+ readonly default: undefined;
1567
+ };
1568
+ /** Open initially for uncontrolled usage. */
1569
+ readonly defaultOpen: {
1570
+ readonly type: BooleanConstructor;
1571
+ readonly default: false;
1572
+ };
1573
+ };
1574
+ /** Props for {@link Popover}. */
1575
+ type PopoverProps = ExtractPublicPropTypes<typeof popoverProps>;
529
1576
  /**
530
1577
  * Floating content built on the native Popover API. The surface lives in the
531
1578
  * top layer with light-dismiss and Escape handled by the browser; visibility
@@ -534,64 +1581,153 @@ declare const DrawerFooter: vue.DefineComponent<{}, () => vue.VNode<vue.Renderer
534
1581
  * it).
535
1582
  */
536
1583
  declare const Popover: vue.DefineComponent<vue.ExtractPropTypes<{
1584
+ readonly placement: {
1585
+ readonly type: PropType<EnhancePopoverOptions["placement"]>;
1586
+ readonly default: undefined;
1587
+ };
1588
+ /** Open on pointer hover and focus of the invoker instead of click. */
1589
+ readonly hover: {
1590
+ readonly type: BooleanConstructor;
1591
+ readonly default: false;
1592
+ };
537
1593
  /** Controlled open state (`v-model:open`). */
538
- open: {
539
- type: PropType<boolean | undefined>;
540
- default: undefined;
1594
+ readonly open: {
1595
+ readonly type: PropType<boolean | undefined>;
1596
+ readonly default: undefined;
541
1597
  };
542
- /** Show the popover initially for uncontrolled usage. */
543
- defaultOpen: {
544
- type: BooleanConstructor;
545
- default: boolean;
1598
+ /** Open initially for uncontrolled usage. */
1599
+ readonly defaultOpen: {
1600
+ readonly type: BooleanConstructor;
1601
+ readonly default: false;
546
1602
  };
547
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1603
+ }>, () => VNode<vue.RendererNode, vue.RendererElement, {
548
1604
  [key: string]: any;
549
1605
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1606
+ readonly placement: {
1607
+ readonly type: PropType<EnhancePopoverOptions["placement"]>;
1608
+ readonly default: undefined;
1609
+ };
1610
+ /** Open on pointer hover and focus of the invoker instead of click. */
1611
+ readonly hover: {
1612
+ readonly type: BooleanConstructor;
1613
+ readonly default: false;
1614
+ };
550
1615
  /** Controlled open state (`v-model:open`). */
551
- open: {
552
- type: PropType<boolean | undefined>;
553
- default: undefined;
1616
+ readonly open: {
1617
+ readonly type: PropType<boolean | undefined>;
1618
+ readonly default: undefined;
554
1619
  };
555
- /** Show the popover initially for uncontrolled usage. */
556
- defaultOpen: {
557
- type: BooleanConstructor;
558
- default: boolean;
1620
+ /** Open initially for uncontrolled usage. */
1621
+ readonly defaultOpen: {
1622
+ readonly type: BooleanConstructor;
1623
+ readonly default: false;
559
1624
  };
560
1625
  }>> & Readonly<{
561
1626
  "onUpdate:open"?: ((...args: any[]) => any) | undefined;
562
1627
  }>, {
563
- defaultOpen: boolean;
564
- open: boolean | undefined;
1628
+ readonly open: boolean | undefined;
1629
+ readonly defaultOpen: boolean;
1630
+ readonly placement: _hydrateless_enhancers.Placement | undefined;
1631
+ readonly hover: boolean;
565
1632
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1633
+ declare const tooltipProps: {
1634
+ /** Hint text; the `content` slot takes precedence. */
1635
+ readonly content: {
1636
+ readonly type: StringConstructor;
1637
+ readonly default: undefined;
1638
+ };
1639
+ readonly placement: {
1640
+ readonly type: PropType<EnhanceTooltipOptions["placement"]>;
1641
+ readonly default: undefined;
1642
+ };
1643
+ /** Delay in ms before showing on hover. */
1644
+ readonly showDelay: {
1645
+ readonly type: NumberConstructor;
1646
+ readonly default: undefined;
1647
+ };
1648
+ /** Grace period in ms before hiding. */
1649
+ readonly hideDelay: {
1650
+ readonly type: NumberConstructor;
1651
+ readonly default: undefined;
1652
+ };
1653
+ /** Controlled visibility (`v-model:open`). */
1654
+ readonly open: {
1655
+ readonly type: PropType<boolean | undefined>;
1656
+ readonly default: undefined;
1657
+ };
1658
+ };
1659
+ /** Props for {@link Tooltip}. */
1660
+ type TooltipProps = ExtractPublicPropTypes<typeof tooltipProps>;
566
1661
  /**
567
- * Accessible tooltip wrapping a single focusable trigger (the default slot).
568
- * The hint text comes from the `label` prop or `label` slot.
1662
+ * Accessible tooltip wrapping a single focusable trigger (the default slot),
1663
+ * which receives `data-hl-tooltip` and `aria-describedby`. The hint comes
1664
+ * from `content` (prop or slot). Visibility is observable with
1665
+ * `v-model:open`.
569
1666
  */
570
1667
  declare const Tooltip: vue.DefineComponent<vue.ExtractPropTypes<{
571
- label: {
572
- type: StringConstructor;
573
- default: undefined;
1668
+ /** Hint text; the `content` slot takes precedence. */
1669
+ readonly content: {
1670
+ readonly type: StringConstructor;
1671
+ readonly default: undefined;
1672
+ };
1673
+ readonly placement: {
1674
+ readonly type: PropType<EnhanceTooltipOptions["placement"]>;
1675
+ readonly default: undefined;
1676
+ };
1677
+ /** Delay in ms before showing on hover. */
1678
+ readonly showDelay: {
1679
+ readonly type: NumberConstructor;
1680
+ readonly default: undefined;
1681
+ };
1682
+ /** Grace period in ms before hiding. */
1683
+ readonly hideDelay: {
1684
+ readonly type: NumberConstructor;
1685
+ readonly default: undefined;
574
1686
  };
575
- id: {
576
- type: StringConstructor;
577
- default: undefined;
1687
+ /** Controlled visibility (`v-model:open`). */
1688
+ readonly open: {
1689
+ readonly type: PropType<boolean | undefined>;
1690
+ readonly default: undefined;
578
1691
  };
579
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1692
+ }>, () => VNode<vue.RendererNode, vue.RendererElement, {
580
1693
  [key: string]: any;
581
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
582
- label: {
583
- type: StringConstructor;
584
- default: undefined;
585
- };
586
- id: {
587
- type: StringConstructor;
588
- default: undefined;
1694
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1695
+ /** Hint text; the `content` slot takes precedence. */
1696
+ readonly content: {
1697
+ readonly type: StringConstructor;
1698
+ readonly default: undefined;
1699
+ };
1700
+ readonly placement: {
1701
+ readonly type: PropType<EnhanceTooltipOptions["placement"]>;
1702
+ readonly default: undefined;
1703
+ };
1704
+ /** Delay in ms before showing on hover. */
1705
+ readonly showDelay: {
1706
+ readonly type: NumberConstructor;
1707
+ readonly default: undefined;
1708
+ };
1709
+ /** Grace period in ms before hiding. */
1710
+ readonly hideDelay: {
1711
+ readonly type: NumberConstructor;
1712
+ readonly default: undefined;
1713
+ };
1714
+ /** Controlled visibility (`v-model:open`). */
1715
+ readonly open: {
1716
+ readonly type: PropType<boolean | undefined>;
1717
+ readonly default: undefined;
589
1718
  };
590
- }>> & Readonly<{}>, {
591
- label: string;
592
- id: string;
1719
+ }>> & Readonly<{
1720
+ "onUpdate:open"?: ((...args: any[]) => any) | undefined;
1721
+ }>, {
1722
+ readonly open: boolean | undefined;
1723
+ readonly placement: _hydrateless_enhancers.Placement | undefined;
1724
+ readonly content: string;
1725
+ readonly showDelay: number;
1726
+ readonly hideDelay: number;
593
1727
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
594
1728
 
1729
+ /** Props for {@link Breadcrumb}. */
1730
+ type BreadcrumbProps = Record<never, never>;
595
1731
  /**
596
1732
  * Semantic breadcrumb navigation (`<nav> > <ol>`). CSS-only. Compose with
597
1733
  * `<BreadcrumbItem>`.
@@ -599,784 +1735,810 @@ declare const Tooltip: vue.DefineComponent<vue.ExtractPropTypes<{
599
1735
  declare const Breadcrumb: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
600
1736
  [key: string]: any;
601
1737
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1738
+ declare const breadcrumbItemProps: {
1739
+ readonly href: {
1740
+ readonly type: StringConstructor;
1741
+ readonly default: undefined;
1742
+ };
1743
+ /** Marks the current page (`aria-current="page"`). */
1744
+ readonly current: {
1745
+ readonly type: BooleanConstructor;
1746
+ readonly default: false;
1747
+ };
1748
+ };
1749
+ /** Props for {@link BreadcrumbItem}. */
1750
+ type BreadcrumbItemProps = ExtractPublicPropTypes<typeof breadcrumbItemProps>;
602
1751
  /** A single crumb. Renders a link unless `current` (or no `href`) is set. */
603
1752
  declare const BreadcrumbItem: vue.DefineComponent<vue.ExtractPropTypes<{
604
- href: {
605
- type: StringConstructor;
606
- default: undefined;
1753
+ readonly href: {
1754
+ readonly type: StringConstructor;
1755
+ readonly default: undefined;
607
1756
  };
608
- current: {
609
- type: BooleanConstructor;
610
- default: boolean;
1757
+ /** Marks the current page (`aria-current="page"`). */
1758
+ readonly current: {
1759
+ readonly type: BooleanConstructor;
1760
+ readonly default: false;
611
1761
  };
612
1762
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
613
1763
  [key: string]: any;
614
1764
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
615
- href: {
616
- type: StringConstructor;
617
- default: undefined;
1765
+ readonly href: {
1766
+ readonly type: StringConstructor;
1767
+ readonly default: undefined;
618
1768
  };
619
- current: {
620
- type: BooleanConstructor;
621
- default: boolean;
1769
+ /** Marks the current page (`aria-current="page"`). */
1770
+ readonly current: {
1771
+ readonly type: BooleanConstructor;
1772
+ readonly default: false;
622
1773
  };
623
1774
  }>> & Readonly<{}>, {
624
- href: string;
625
- current: boolean;
1775
+ readonly href: string;
1776
+ readonly current: boolean;
626
1777
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
627
1778
 
1779
+ declare const comboboxProps: {
1780
+ readonly filter: {
1781
+ readonly type: PropType<EnhanceComboboxOptions["filter"]>;
1782
+ readonly default: undefined;
1783
+ };
1784
+ readonly autoHighlight: {
1785
+ readonly type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
1786
+ readonly default: undefined;
1787
+ };
1788
+ /** Controlled committed value (`v-model`). */
1789
+ readonly modelValue: {
1790
+ readonly type: StringConstructor;
1791
+ readonly default: undefined;
1792
+ };
1793
+ /** Initial committed value for uncontrolled usage. */
1794
+ readonly defaultValue: {
1795
+ readonly type: StringConstructor;
1796
+ readonly default: undefined;
1797
+ };
1798
+ /** Controlled listbox state (`v-model:open`). */
1799
+ readonly open: {
1800
+ readonly type: PropType<boolean | undefined>;
1801
+ readonly default: undefined;
1802
+ };
1803
+ /** Expand the listbox initially for uncontrolled usage. */
1804
+ readonly defaultOpen: {
1805
+ readonly type: BooleanConstructor;
1806
+ readonly default: false;
1807
+ };
1808
+ };
1809
+ /** Props for {@link Combobox}. */
1810
+ type ComboboxProps = ExtractPublicPropTypes<typeof comboboxProps>;
628
1811
  /**
629
1812
  * Editable combobox (input + listbox), APG pattern. Compose with
630
1813
  * `<ComboboxInput>`, `<ComboboxList>`, `<ComboboxOption>`. The committed
631
- * value works uncontrolled (`defaultValue`) or with `v-model`; selection also
632
- * emits `select`.
1814
+ * value works uncontrolled (`defaultValue`) or with `v-model`; the listbox
1815
+ * state with `defaultOpen` or `v-model:open`.
633
1816
  */
634
1817
  declare const Combobox: vue.DefineComponent<vue.ExtractPropTypes<{
635
- filter: {
636
- type: PropType<EnhanceComboboxOptions["filter"]>;
637
- default: undefined;
1818
+ readonly filter: {
1819
+ readonly type: PropType<EnhanceComboboxOptions["filter"]>;
1820
+ readonly default: undefined;
638
1821
  };
639
- autoHighlight: {
640
- type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
641
- default: undefined;
1822
+ readonly autoHighlight: {
1823
+ readonly type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
1824
+ readonly default: undefined;
642
1825
  };
643
1826
  /** Controlled committed value (`v-model`). */
644
- modelValue: {
645
- type: StringConstructor;
646
- default: undefined;
1827
+ readonly modelValue: {
1828
+ readonly type: StringConstructor;
1829
+ readonly default: undefined;
647
1830
  };
648
1831
  /** Initial committed value for uncontrolled usage. */
649
- defaultValue: {
650
- type: StringConstructor;
651
- default: undefined;
1832
+ readonly defaultValue: {
1833
+ readonly type: StringConstructor;
1834
+ readonly default: undefined;
1835
+ };
1836
+ /** Controlled listbox state (`v-model:open`). */
1837
+ readonly open: {
1838
+ readonly type: PropType<boolean | undefined>;
1839
+ readonly default: undefined;
1840
+ };
1841
+ /** Expand the listbox initially for uncontrolled usage. */
1842
+ readonly defaultOpen: {
1843
+ readonly type: BooleanConstructor;
1844
+ readonly default: false;
652
1845
  };
653
1846
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
654
1847
  [key: string]: any;
655
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "select")[], "update:modelValue" | "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
656
- filter: {
657
- type: PropType<EnhanceComboboxOptions["filter"]>;
658
- default: undefined;
1848
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "update:open")[], "update:modelValue" | "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1849
+ readonly filter: {
1850
+ readonly type: PropType<EnhanceComboboxOptions["filter"]>;
1851
+ readonly default: undefined;
659
1852
  };
660
- autoHighlight: {
661
- type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
662
- default: undefined;
1853
+ readonly autoHighlight: {
1854
+ readonly type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
1855
+ readonly default: undefined;
663
1856
  };
664
1857
  /** Controlled committed value (`v-model`). */
665
- modelValue: {
666
- type: StringConstructor;
667
- default: undefined;
1858
+ readonly modelValue: {
1859
+ readonly type: StringConstructor;
1860
+ readonly default: undefined;
668
1861
  };
669
1862
  /** Initial committed value for uncontrolled usage. */
670
- defaultValue: {
671
- type: StringConstructor;
672
- default: undefined;
1863
+ readonly defaultValue: {
1864
+ readonly type: StringConstructor;
1865
+ readonly default: undefined;
1866
+ };
1867
+ /** Controlled listbox state (`v-model:open`). */
1868
+ readonly open: {
1869
+ readonly type: PropType<boolean | undefined>;
1870
+ readonly default: undefined;
1871
+ };
1872
+ /** Expand the listbox initially for uncontrolled usage. */
1873
+ readonly defaultOpen: {
1874
+ readonly type: BooleanConstructor;
1875
+ readonly default: false;
673
1876
  };
674
1877
  }>> & Readonly<{
675
1878
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
676
- onSelect?: ((...args: any[]) => any) | undefined;
1879
+ "onUpdate:open"?: ((...args: any[]) => any) | undefined;
677
1880
  }>, {
678
- modelValue: string;
679
- defaultValue: string;
680
- filter: boolean | undefined;
681
- autoHighlight: boolean | undefined;
1881
+ readonly filter: boolean | undefined;
1882
+ readonly modelValue: string;
1883
+ readonly defaultValue: string;
1884
+ readonly open: boolean | undefined;
1885
+ readonly defaultOpen: boolean;
1886
+ readonly autoHighlight: boolean | undefined;
682
1887
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
683
- /** The combobox text field. */
1888
+ declare const comboboxInputProps: {
1889
+ readonly styled: {
1890
+ readonly type: BooleanConstructor;
1891
+ readonly default: true;
1892
+ };
1893
+ };
1894
+ /** Props for {@link ComboboxInput}. */
1895
+ type ComboboxInputProps = ExtractPublicPropTypes<typeof comboboxInputProps>;
1896
+ /** The combobox text field. Wires itself to a surrounding `<Field>`. */
684
1897
  declare const ComboboxInput: vue.DefineComponent<vue.ExtractPropTypes<{
685
- styled: {
686
- type: BooleanConstructor;
687
- default: boolean;
1898
+ readonly styled: {
1899
+ readonly type: BooleanConstructor;
1900
+ readonly default: true;
688
1901
  };
689
1902
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
690
1903
  [key: string]: any;
691
1904
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
692
- styled: {
693
- type: BooleanConstructor;
694
- default: boolean;
1905
+ readonly styled: {
1906
+ readonly type: BooleanConstructor;
1907
+ readonly default: true;
695
1908
  };
696
1909
  }>> & Readonly<{}>, {
697
- styled: boolean;
1910
+ readonly styled: boolean;
698
1911
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1912
+ /** Props for {@link ComboboxList}. */
1913
+ type ComboboxListProps = Record<never, never>;
699
1914
  /** The option popup (`role="listbox"`). */
700
1915
  declare const ComboboxList: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
701
1916
  [key: string]: any;
702
1917
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
703
- /** A selectable option. The `value` is committed on selection. */
1918
+ declare const comboboxOptionProps: {
1919
+ readonly value: {
1920
+ readonly type: StringConstructor;
1921
+ readonly required: true;
1922
+ };
1923
+ readonly disabled: {
1924
+ readonly type: BooleanConstructor;
1925
+ readonly default: false;
1926
+ };
1927
+ };
1928
+ /** Props for {@link ComboboxOption}. */
1929
+ type ComboboxOptionProps = ExtractPublicPropTypes<typeof comboboxOptionProps>;
1930
+ /** A selectable option. The `value` is committed on selection; `disabled` options are skipped. */
704
1931
  declare const ComboboxOption: vue.DefineComponent<vue.ExtractPropTypes<{
705
- value: {
706
- type: StringConstructor;
707
- required: true;
1932
+ readonly value: {
1933
+ readonly type: StringConstructor;
1934
+ readonly required: true;
1935
+ };
1936
+ readonly disabled: {
1937
+ readonly type: BooleanConstructor;
1938
+ readonly default: false;
708
1939
  };
709
1940
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
710
1941
  [key: string]: any;
711
1942
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
712
- value: {
713
- type: StringConstructor;
714
- required: true;
1943
+ readonly value: {
1944
+ readonly type: StringConstructor;
1945
+ readonly required: true;
715
1946
  };
716
- }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1947
+ readonly disabled: {
1948
+ readonly type: BooleanConstructor;
1949
+ readonly default: false;
1950
+ };
1951
+ }>> & Readonly<{}>, {
1952
+ readonly disabled: boolean;
1953
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
717
1954
 
1955
+ declare const commandProps: {
1956
+ /** Lowercased key that, with Cmd/Ctrl, opens the hosting `<dialog>`. */
1957
+ readonly hotkey: {
1958
+ readonly type: StringConstructor;
1959
+ readonly default: undefined;
1960
+ };
1961
+ /** Controlled filter query (`v-model:query`). */
1962
+ readonly query: {
1963
+ readonly type: StringConstructor;
1964
+ readonly default: undefined;
1965
+ };
1966
+ /** Initial query for uncontrolled usage. */
1967
+ readonly defaultQuery: {
1968
+ readonly type: StringConstructor;
1969
+ readonly default: undefined;
1970
+ };
1971
+ };
1972
+ /** Props for {@link Command}. */
1973
+ type CommandProps = ExtractPublicPropTypes<typeof commandProps>;
718
1974
  /**
719
1975
  * Command palette. Compose with `<CommandInput>`, `<CommandList>`,
720
- * `<CommandGroup>`, `<CommandItem>`, `<CommandEmpty>`. Emits `select` with the
721
- * chosen value and `update:query` as the filter changes. Place inside a
722
- * `<dialog>` to use `hotkey`.
1976
+ * `<CommandGroup>`, `<CommandItem>`, `<CommandEmpty>`. The filter query works
1977
+ * uncontrolled (`defaultQuery`) or with `v-model:query`; running a command
1978
+ * emits `command` with `(value, item)`. Place inside a `<dialog>` to use
1979
+ * `hotkey`.
723
1980
  */
724
1981
  declare const Command: vue.DefineComponent<vue.ExtractPropTypes<{
725
- hotkey: {
726
- type: StringConstructor;
727
- default: undefined;
1982
+ /** Lowercased key that, with Cmd/Ctrl, opens the hosting `<dialog>`. */
1983
+ readonly hotkey: {
1984
+ readonly type: StringConstructor;
1985
+ readonly default: undefined;
1986
+ };
1987
+ /** Controlled filter query (`v-model:query`). */
1988
+ readonly query: {
1989
+ readonly type: StringConstructor;
1990
+ readonly default: undefined;
1991
+ };
1992
+ /** Initial query for uncontrolled usage. */
1993
+ readonly defaultQuery: {
1994
+ readonly type: StringConstructor;
1995
+ readonly default: undefined;
728
1996
  };
729
1997
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
730
1998
  [key: string]: any;
731
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("select" | "update:query")[], "select" | "update:query", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
732
- hotkey: {
733
- type: StringConstructor;
734
- default: undefined;
1999
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:query" | "command")[], "update:query" | "command", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
2000
+ /** Lowercased key that, with Cmd/Ctrl, opens the hosting `<dialog>`. */
2001
+ readonly hotkey: {
2002
+ readonly type: StringConstructor;
2003
+ readonly default: undefined;
2004
+ };
2005
+ /** Controlled filter query (`v-model:query`). */
2006
+ readonly query: {
2007
+ readonly type: StringConstructor;
2008
+ readonly default: undefined;
2009
+ };
2010
+ /** Initial query for uncontrolled usage. */
2011
+ readonly defaultQuery: {
2012
+ readonly type: StringConstructor;
2013
+ readonly default: undefined;
735
2014
  };
736
2015
  }>> & Readonly<{
737
- onSelect?: ((...args: any[]) => any) | undefined;
738
2016
  "onUpdate:query"?: ((...args: any[]) => any) | undefined;
2017
+ onCommand?: ((...args: any[]) => any) | undefined;
739
2018
  }>, {
740
- hotkey: string;
2019
+ readonly hotkey: string;
2020
+ readonly query: string;
2021
+ readonly defaultQuery: string;
741
2022
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2023
+ declare const commandInputProps: {
2024
+ readonly styled: {
2025
+ readonly type: BooleanConstructor;
2026
+ readonly default: true;
2027
+ };
2028
+ };
2029
+ /** Props for {@link CommandInput}. */
2030
+ type CommandInputProps = ExtractPublicPropTypes<typeof commandInputProps>;
742
2031
  /** The palette search field. */
743
2032
  declare const CommandInput: vue.DefineComponent<vue.ExtractPropTypes<{
744
- styled: {
745
- type: BooleanConstructor;
746
- default: boolean;
2033
+ readonly styled: {
2034
+ readonly type: BooleanConstructor;
2035
+ readonly default: true;
747
2036
  };
748
2037
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
749
2038
  [key: string]: any;
750
2039
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
751
- styled: {
752
- type: BooleanConstructor;
753
- default: boolean;
2040
+ readonly styled: {
2041
+ readonly type: BooleanConstructor;
2042
+ readonly default: true;
754
2043
  };
755
2044
  }>> & Readonly<{}>, {
756
- styled: boolean;
2045
+ readonly styled: boolean;
757
2046
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2047
+ /** Props for {@link CommandList}. */
2048
+ type CommandListProps = Record<never, never>;
758
2049
  /** The scrollable list of commands (`role="listbox"`). */
759
2050
  declare const CommandList: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
760
2051
  [key: string]: any;
761
2052
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
762
- /** A labelled group of commands. The optional heading uses the `label` slot. */
763
- declare const CommandGroup: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
764
- [key: string]: any;
765
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
766
- /** A runnable command (`role="option"`). */
767
- declare const CommandItem: vue.DefineComponent<vue.ExtractPropTypes<{
768
- value: {
769
- type: StringConstructor;
770
- required: true;
2053
+ declare const commandGroupProps: {
2054
+ /** Group heading; the `label` slot takes precedence. */
2055
+ readonly label: {
2056
+ readonly type: StringConstructor;
2057
+ readonly default: undefined;
771
2058
  };
772
- keywords: {
773
- type: StringConstructor;
774
- default: undefined;
2059
+ };
2060
+ /** Props for {@link CommandGroup}. */
2061
+ type CommandGroupProps = ExtractPublicPropTypes<typeof commandGroupProps>;
2062
+ /** A labelled group of commands. */
2063
+ declare const CommandGroup: vue.DefineComponent<vue.ExtractPropTypes<{
2064
+ /** Group heading; the `label` slot takes precedence. */
2065
+ readonly label: {
2066
+ readonly type: StringConstructor;
2067
+ readonly default: undefined;
775
2068
  };
776
2069
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
777
2070
  [key: string]: any;
778
2071
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
779
- value: {
780
- type: StringConstructor;
781
- required: true;
782
- };
783
- keywords: {
784
- type: StringConstructor;
785
- default: undefined;
2072
+ /** Group heading; the `label` slot takes precedence. */
2073
+ readonly label: {
2074
+ readonly type: StringConstructor;
2075
+ readonly default: undefined;
786
2076
  };
787
2077
  }>> & Readonly<{}>, {
788
- keywords: string;
2078
+ readonly label: string;
789
2079
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
790
- /** Shown when no commands match the query. */
791
- declare const CommandEmpty: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
792
- [key: string]: any;
793
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
794
-
795
- type Size = 'sm' | 'md' | 'lg';
796
- /**
797
- * Layout + accessibility wrapper for a control. Provides a shared id so
798
- * `<FieldLabel>`, `<FieldHelp>`, and `<FieldError>` wire up automatically.
799
- * Bind the control with `v-bind="useField()"` or place an `<Input>` inside.
800
- */
801
- declare const Field: vue.DefineComponent<vue.ExtractPropTypes<{
802
- id: {
803
- type: StringConstructor;
804
- default: undefined;
2080
+ declare const commandItemProps: {
2081
+ readonly value: {
2082
+ readonly type: StringConstructor;
2083
+ readonly required: true;
805
2084
  };
806
- invalid: {
807
- type: BooleanConstructor;
808
- default: boolean;
2085
+ /** Extra search terms matched by the filter. */
2086
+ readonly keywords: {
2087
+ readonly type: StringConstructor;
2088
+ readonly default: undefined;
2089
+ };
2090
+ };
2091
+ /** Props for {@link CommandItem}. */
2092
+ type CommandItemProps = ExtractPublicPropTypes<typeof commandItemProps>;
2093
+ /** A runnable command (`role="option"`). */
2094
+ declare const CommandItem: vue.DefineComponent<vue.ExtractPropTypes<{
2095
+ readonly value: {
2096
+ readonly type: StringConstructor;
2097
+ readonly required: true;
809
2098
  };
810
- required: {
811
- type: BooleanConstructor;
812
- default: boolean;
2099
+ /** Extra search terms matched by the filter. */
2100
+ readonly keywords: {
2101
+ readonly type: StringConstructor;
2102
+ readonly default: undefined;
813
2103
  };
814
2104
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
815
2105
  [key: string]: any;
816
2106
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
817
- id: {
818
- type: StringConstructor;
819
- default: undefined;
2107
+ readonly value: {
2108
+ readonly type: StringConstructor;
2109
+ readonly required: true;
820
2110
  };
821
- invalid: {
822
- type: BooleanConstructor;
823
- default: boolean;
824
- };
825
- required: {
826
- type: BooleanConstructor;
827
- default: boolean;
2111
+ /** Extra search terms matched by the filter. */
2112
+ readonly keywords: {
2113
+ readonly type: StringConstructor;
2114
+ readonly default: undefined;
828
2115
  };
829
2116
  }>> & Readonly<{}>, {
830
- invalid: boolean;
831
- id: string;
832
- required: boolean;
2117
+ readonly keywords: string;
833
2118
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
834
- /** Returns props (`id`, `aria-describedby`, `aria-invalid`) to bind onto a control. */
835
- declare function useFieldBindings(): {
836
- id?: undefined;
837
- 'aria-describedby'?: undefined;
838
- 'aria-invalid'?: undefined;
839
- } | {
840
- id: string;
841
- 'aria-describedby': string | undefined;
842
- 'aria-invalid': true | undefined;
843
- };
844
- /** Label for a {@link Field}'s control, associated with it by id. */
845
- declare const FieldLabel: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
846
- [key: string]: any;
847
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
848
- /** Help text for a {@link Field}, linked to its control via `aria-describedby`. */
849
- declare const FieldHelp: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
850
- [key: string]: any;
851
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
852
- /** Validation message for a {@link Field}; renders nothing until it has content. */
853
- declare const FieldError: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
854
- [key: string]: any;
855
- }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
856
- /** Groups related controls in a native fieldset with an optional `legend` slot. */
857
- declare const Fieldset: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
2119
+ /** Props for {@link CommandEmpty}. */
2120
+ type CommandEmptyProps = Record<never, never>;
2121
+ /** Shown when no commands match the query. */
2122
+ declare const CommandEmpty: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
858
2123
  [key: string]: any;
859
2124
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
860
- /** Text input styled with the `hl-input` primitive. Supports `v-model`. */
861
- declare const Input: vue.DefineComponent<vue.ExtractPropTypes<{
862
- modelValue: {
863
- type: (StringConstructor | NumberConstructor)[];
864
- default: undefined;
865
- };
866
- size: {
867
- type: PropType<Size>;
868
- default: undefined;
869
- };
870
- invalid: {
871
- type: BooleanConstructor;
872
- default: boolean;
873
- };
874
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
875
- [key: string]: any;
876
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
877
- modelValue: {
878
- type: (StringConstructor | NumberConstructor)[];
879
- default: undefined;
880
- };
881
- size: {
882
- type: PropType<Size>;
883
- default: undefined;
884
- };
885
- invalid: {
886
- type: BooleanConstructor;
887
- default: boolean;
888
- };
889
- }>> & Readonly<{
890
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
891
- }>, {
892
- modelValue: string | number;
893
- invalid: boolean;
894
- size: Size;
895
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
896
- /** Multi-line text input. Supports `v-model`. */
897
- declare const Textarea: vue.DefineComponent<vue.ExtractPropTypes<{
898
- modelValue: {
899
- type: StringConstructor;
900
- default: undefined;
901
- };
902
- size: {
903
- type: PropType<Size>;
904
- default: undefined;
905
- };
906
- invalid: {
907
- type: BooleanConstructor;
908
- default: boolean;
909
- };
910
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
911
- [key: string]: any;
912
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
913
- modelValue: {
914
- type: StringConstructor;
915
- default: undefined;
916
- };
917
- size: {
918
- type: PropType<Size>;
919
- default: undefined;
920
- };
921
- invalid: {
922
- type: BooleanConstructor;
923
- default: boolean;
924
- };
925
- }>> & Readonly<{
926
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
927
- }>, {
928
- modelValue: string;
929
- invalid: boolean;
930
- size: Size;
931
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
932
- /** Native `<select>` styled with `hl-select`. Supports `v-model`. */
933
- declare const Select: vue.DefineComponent<vue.ExtractPropTypes<{
934
- modelValue: {
935
- type: StringConstructor;
936
- default: undefined;
937
- };
938
- size: {
939
- type: PropType<Size>;
940
- default: undefined;
941
- };
942
- invalid: {
943
- type: BooleanConstructor;
944
- default: boolean;
945
- };
946
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
947
- [key: string]: any;
948
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
949
- modelValue: {
950
- type: StringConstructor;
951
- default: undefined;
952
- };
953
- size: {
954
- type: PropType<Size>;
955
- default: undefined;
956
- };
957
- invalid: {
958
- type: BooleanConstructor;
959
- default: boolean;
960
- };
961
- }>> & Readonly<{
962
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
963
- }>, {
964
- modelValue: string;
965
- invalid: boolean;
966
- size: Size;
967
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
968
- /** Checkbox built on a native input, label-wrapped. Supports `v-model`. */
969
- declare const Checkbox: vue.DefineComponent<vue.ExtractPropTypes<{
970
- modelValue: {
971
- type: BooleanConstructor;
972
- default: undefined;
973
- };
974
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
975
- [key: string]: any;
976
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
977
- modelValue: {
978
- type: BooleanConstructor;
979
- default: undefined;
980
- };
981
- }>> & Readonly<{
982
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
983
- }>, {
984
- modelValue: boolean;
985
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
986
- /** Toggle switch built on a native checkbox. Supports `v-model`. */
987
- declare const Switch: vue.DefineComponent<vue.ExtractPropTypes<{
988
- modelValue: {
989
- type: BooleanConstructor;
990
- default: undefined;
991
- };
992
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
993
- [key: string]: any;
994
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
995
- modelValue: {
996
- type: BooleanConstructor;
997
- default: undefined;
998
- };
999
- }>> & Readonly<{
1000
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1001
- }>, {
1002
- modelValue: boolean;
1003
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1004
- /** Range slider primitive. Supports `v-model`. */
1005
- declare const Slider: vue.DefineComponent<vue.ExtractPropTypes<{
1006
- modelValue: {
1007
- type: (StringConstructor | NumberConstructor)[];
1008
- default: undefined;
1009
- };
1010
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1011
- [key: string]: any;
1012
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1013
- modelValue: {
1014
- type: (StringConstructor | NumberConstructor)[];
1015
- default: undefined;
1016
- };
1017
- }>> & Readonly<{
1018
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1019
- }>, {
1020
- modelValue: string | number;
1021
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1022
- /** Groups radios under `role="radiogroup"`. Supports `v-model`. */
1023
- declare const RadioGroup: vue.DefineComponent<vue.ExtractPropTypes<{
1024
- modelValue: {
1025
- type: StringConstructor;
1026
- default: undefined;
1027
- };
1028
- name: {
1029
- type: StringConstructor;
1030
- default: undefined;
1031
- };
1032
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1033
- [key: string]: any;
1034
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1035
- modelValue: {
1036
- type: StringConstructor;
1037
- default: undefined;
1038
- };
1039
- name: {
1040
- type: StringConstructor;
1041
- default: undefined;
1042
- };
1043
- }>> & Readonly<{
1044
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1045
- }>, {
1046
- name: string;
1047
- modelValue: string;
1048
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1049
- /** A single radio. Inside a `<RadioGroup>` it binds to the shared value. */
1050
- declare const Radio: vue.DefineComponent<vue.ExtractPropTypes<{
1051
- value: {
1052
- type: StringConstructor;
1053
- required: true;
1054
- };
1055
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1056
- [key: string]: any;
1057
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1058
- value: {
1059
- type: StringConstructor;
1060
- required: true;
1061
- };
1062
- }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1063
- /**
1064
- * Segmented control: a styled radiogroup. The selected value works
1065
- * uncontrolled (`defaultValue`) or with `v-model`.
1066
- */
1067
- declare const SegmentedControl: vue.DefineComponent<vue.ExtractPropTypes<{
1068
- modelValue: {
1069
- type: StringConstructor;
1070
- default: undefined;
1071
- };
1072
- /** Initially selected value for uncontrolled usage. */
1073
- defaultValue: {
1074
- type: StringConstructor;
1075
- default: undefined;
1076
- };
1077
- options: {
1078
- type: PropType<Array<{
1079
- label: string;
1080
- value: string;
1081
- disabled?: boolean;
1082
- }>>;
1083
- default: () => never[];
1084
- };
1085
- name: {
1086
- type: StringConstructor;
1087
- default: undefined;
1088
- };
1089
- size: {
1090
- type: PropType<Size>;
1091
- default: undefined;
1092
- };
1093
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1094
- [key: string]: any;
1095
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1096
- modelValue: {
1097
- type: StringConstructor;
1098
- default: undefined;
1099
- };
1100
- /** Initially selected value for uncontrolled usage. */
1101
- defaultValue: {
1102
- type: StringConstructor;
1103
- default: undefined;
1104
- };
1105
- options: {
1106
- type: PropType<Array<{
1107
- label: string;
1108
- value: string;
1109
- disabled?: boolean;
1110
- }>>;
1111
- default: () => never[];
1112
- };
1113
- name: {
1114
- type: StringConstructor;
1115
- default: undefined;
1116
- };
1117
- size: {
1118
- type: PropType<Size>;
1119
- default: undefined;
1120
- };
1121
- }>> & Readonly<{
1122
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1123
- }>, {
1124
- name: string;
1125
- modelValue: string;
1126
- defaultValue: string;
1127
- size: Size;
1128
- options: {
1129
- label: string;
1130
- value: string;
1131
- disabled?: boolean;
1132
- }[];
1133
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1134
2125
 
2126
+ declare const buttonProps: {
2127
+ readonly variant: {
2128
+ readonly type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
2129
+ readonly default: undefined;
2130
+ };
2131
+ readonly intent: {
2132
+ readonly type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
2133
+ readonly default: undefined;
2134
+ };
2135
+ readonly size: {
2136
+ readonly type: PropType<"sm" | "md" | "lg">;
2137
+ readonly default: undefined;
2138
+ };
2139
+ /** Stretch to the container's inline size. */
2140
+ readonly block: {
2141
+ readonly type: BooleanConstructor;
2142
+ readonly default: false;
2143
+ };
2144
+ /** Square icon-only button. */
2145
+ readonly icon: {
2146
+ readonly type: BooleanConstructor;
2147
+ readonly default: false;
2148
+ };
2149
+ /** Show the busy state and disable the button. */
2150
+ readonly loading: {
2151
+ readonly type: BooleanConstructor;
2152
+ readonly default: false;
2153
+ };
2154
+ };
2155
+ /** Props for {@link Button}. */
2156
+ type ButtonProps = ExtractPublicPropTypes<typeof buttonProps>;
1135
2157
  /** Button primitive: `hl-button` with intent/variant/size modifiers. */
1136
2158
  declare const Button: vue.DefineComponent<vue.ExtractPropTypes<{
1137
- variant: {
1138
- type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
1139
- default: undefined;
2159
+ readonly variant: {
2160
+ readonly type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
2161
+ readonly default: undefined;
1140
2162
  };
1141
- intent: {
1142
- type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
1143
- default: undefined;
2163
+ readonly intent: {
2164
+ readonly type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
2165
+ readonly default: undefined;
1144
2166
  };
1145
- size: {
1146
- type: PropType<"sm" | "md" | "lg">;
1147
- default: undefined;
2167
+ readonly size: {
2168
+ readonly type: PropType<"sm" | "md" | "lg">;
2169
+ readonly default: undefined;
1148
2170
  };
1149
- block: {
1150
- type: BooleanConstructor;
1151
- default: boolean;
2171
+ /** Stretch to the container's inline size. */
2172
+ readonly block: {
2173
+ readonly type: BooleanConstructor;
2174
+ readonly default: false;
1152
2175
  };
1153
- icon: {
1154
- type: BooleanConstructor;
1155
- default: boolean;
2176
+ /** Square icon-only button. */
2177
+ readonly icon: {
2178
+ readonly type: BooleanConstructor;
2179
+ readonly default: false;
1156
2180
  };
1157
- loading: {
1158
- type: BooleanConstructor;
1159
- default: boolean;
2181
+ /** Show the busy state and disable the button. */
2182
+ readonly loading: {
2183
+ readonly type: BooleanConstructor;
2184
+ readonly default: false;
1160
2185
  };
1161
2186
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1162
2187
  [key: string]: any;
1163
2188
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1164
- variant: {
1165
- type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
1166
- default: undefined;
2189
+ readonly variant: {
2190
+ readonly type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
2191
+ readonly default: undefined;
1167
2192
  };
1168
- intent: {
1169
- type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
1170
- default: undefined;
2193
+ readonly intent: {
2194
+ readonly type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
2195
+ readonly default: undefined;
1171
2196
  };
1172
- size: {
1173
- type: PropType<"sm" | "md" | "lg">;
1174
- default: undefined;
2197
+ readonly size: {
2198
+ readonly type: PropType<"sm" | "md" | "lg">;
2199
+ readonly default: undefined;
1175
2200
  };
1176
- block: {
1177
- type: BooleanConstructor;
1178
- default: boolean;
2201
+ /** Stretch to the container's inline size. */
2202
+ readonly block: {
2203
+ readonly type: BooleanConstructor;
2204
+ readonly default: false;
1179
2205
  };
1180
- icon: {
1181
- type: BooleanConstructor;
1182
- default: boolean;
2206
+ /** Square icon-only button. */
2207
+ readonly icon: {
2208
+ readonly type: BooleanConstructor;
2209
+ readonly default: false;
1183
2210
  };
1184
- loading: {
1185
- type: BooleanConstructor;
1186
- default: boolean;
2211
+ /** Show the busy state and disable the button. */
2212
+ readonly loading: {
2213
+ readonly type: BooleanConstructor;
2214
+ readonly default: false;
1187
2215
  };
1188
2216
  }>> & Readonly<{}>, {
1189
- icon: boolean;
1190
- size: "sm" | "md" | "lg";
1191
- variant: "link" | "solid" | "soft" | "outline" | "ghost";
1192
- intent: "neutral" | "primary" | "danger" | "success" | "warning" | "info";
1193
- block: boolean;
1194
- loading: boolean;
2217
+ readonly size: "sm" | "md" | "lg";
2218
+ readonly icon: boolean;
2219
+ readonly variant: "link" | "solid" | "soft" | "outline" | "ghost";
2220
+ readonly intent: "neutral" | "primary" | "danger" | "success" | "warning" | "info";
2221
+ readonly block: boolean;
2222
+ readonly loading: boolean;
1195
2223
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1196
2224
 
1197
2225
  type Intent = 'neutral' | 'primary' | 'danger' | 'success' | 'warning' | 'info';
2226
+ declare const alertProps: {
2227
+ readonly intent: {
2228
+ readonly type: PropType<Intent>;
2229
+ readonly default: undefined;
2230
+ };
2231
+ readonly title: {
2232
+ readonly type: StringConstructor;
2233
+ readonly default: undefined;
2234
+ };
2235
+ };
2236
+ /** Props for {@link Alert}. */
2237
+ type AlertProps = ExtractPublicPropTypes<typeof alertProps>;
1198
2238
  /** Alert primitive: `hl-alert` with intent, optional `icon` slot + `title`. */
1199
2239
  declare const Alert: vue.DefineComponent<vue.ExtractPropTypes<{
1200
- intent: {
1201
- type: PropType<Intent>;
1202
- default: undefined;
2240
+ readonly intent: {
2241
+ readonly type: PropType<Intent>;
2242
+ readonly default: undefined;
1203
2243
  };
1204
- title: {
1205
- type: StringConstructor;
1206
- default: undefined;
2244
+ readonly title: {
2245
+ readonly type: StringConstructor;
2246
+ readonly default: undefined;
1207
2247
  };
1208
2248
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1209
2249
  [key: string]: any;
1210
2250
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1211
- intent: {
1212
- type: PropType<Intent>;
1213
- default: undefined;
2251
+ readonly intent: {
2252
+ readonly type: PropType<Intent>;
2253
+ readonly default: undefined;
1214
2254
  };
1215
- title: {
1216
- type: StringConstructor;
1217
- default: undefined;
2255
+ readonly title: {
2256
+ readonly type: StringConstructor;
2257
+ readonly default: undefined;
1218
2258
  };
1219
2259
  }>> & Readonly<{}>, {
1220
- title: string;
1221
- intent: Intent;
2260
+ readonly title: string;
2261
+ readonly intent: Intent;
1222
2262
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2263
+ declare const badgeProps: {
2264
+ readonly intent: {
2265
+ readonly type: PropType<Intent>;
2266
+ readonly default: undefined;
2267
+ };
2268
+ readonly variant: {
2269
+ readonly type: PropType<"soft" | "solid" | "outline">;
2270
+ readonly default: undefined;
2271
+ };
2272
+ readonly size: {
2273
+ readonly type: PropType<"sm" | "md">;
2274
+ readonly default: undefined;
2275
+ };
2276
+ };
2277
+ /** Props for {@link Badge}. */
2278
+ type BadgeProps = ExtractPublicPropTypes<typeof badgeProps>;
1223
2279
  /** Badge primitive: `hl-badge` with intent/variant/size modifiers. */
1224
2280
  declare const Badge: vue.DefineComponent<vue.ExtractPropTypes<{
1225
- intent: {
1226
- type: PropType<Intent>;
1227
- default: undefined;
2281
+ readonly intent: {
2282
+ readonly type: PropType<Intent>;
2283
+ readonly default: undefined;
1228
2284
  };
1229
- variant: {
1230
- type: PropType<"soft" | "solid" | "outline">;
1231
- default: undefined;
2285
+ readonly variant: {
2286
+ readonly type: PropType<"soft" | "solid" | "outline">;
2287
+ readonly default: undefined;
1232
2288
  };
1233
- size: {
1234
- type: PropType<"sm" | "md">;
1235
- default: undefined;
2289
+ readonly size: {
2290
+ readonly type: PropType<"sm" | "md">;
2291
+ readonly default: undefined;
1236
2292
  };
1237
2293
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1238
2294
  [key: string]: any;
1239
2295
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1240
- intent: {
1241
- type: PropType<Intent>;
1242
- default: undefined;
2296
+ readonly intent: {
2297
+ readonly type: PropType<Intent>;
2298
+ readonly default: undefined;
1243
2299
  };
1244
- variant: {
1245
- type: PropType<"soft" | "solid" | "outline">;
1246
- default: undefined;
2300
+ readonly variant: {
2301
+ readonly type: PropType<"soft" | "solid" | "outline">;
2302
+ readonly default: undefined;
1247
2303
  };
1248
- size: {
1249
- type: PropType<"sm" | "md">;
1250
- default: undefined;
2304
+ readonly size: {
2305
+ readonly type: PropType<"sm" | "md">;
2306
+ readonly default: undefined;
1251
2307
  };
1252
2308
  }>> & Readonly<{}>, {
1253
- size: "sm" | "md";
1254
- variant: "solid" | "soft" | "outline";
1255
- intent: Intent;
2309
+ readonly size: "sm" | "md";
2310
+ readonly variant: "solid" | "soft" | "outline";
2311
+ readonly intent: Intent;
1256
2312
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2313
+ declare const progressProps: {
2314
+ readonly value: {
2315
+ readonly type: NumberConstructor;
2316
+ readonly default: undefined;
2317
+ };
2318
+ readonly max: {
2319
+ readonly type: NumberConstructor;
2320
+ readonly default: 100;
2321
+ };
2322
+ readonly intent: {
2323
+ readonly type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
2324
+ readonly default: undefined;
2325
+ };
2326
+ readonly size: {
2327
+ readonly type: PropType<"sm" | "md" | "lg">;
2328
+ readonly default: undefined;
2329
+ };
2330
+ };
2331
+ /** Props for {@link Progress}. */
2332
+ type ProgressProps = ExtractPublicPropTypes<typeof progressProps>;
1257
2333
  /** Progress primitive: native `<progress class="hl-progress">`. */
1258
2334
  declare const Progress: vue.DefineComponent<vue.ExtractPropTypes<{
1259
- value: {
1260
- type: NumberConstructor;
1261
- default: undefined;
2335
+ readonly value: {
2336
+ readonly type: NumberConstructor;
2337
+ readonly default: undefined;
1262
2338
  };
1263
- max: {
1264
- type: NumberConstructor;
1265
- default: number;
2339
+ readonly max: {
2340
+ readonly type: NumberConstructor;
2341
+ readonly default: 100;
1266
2342
  };
1267
- intent: {
1268
- type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
1269
- default: undefined;
2343
+ readonly intent: {
2344
+ readonly type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
2345
+ readonly default: undefined;
1270
2346
  };
1271
- size: {
1272
- type: PropType<"sm" | "md" | "lg">;
1273
- default: undefined;
2347
+ readonly size: {
2348
+ readonly type: PropType<"sm" | "md" | "lg">;
2349
+ readonly default: undefined;
1274
2350
  };
1275
2351
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1276
2352
  [key: string]: any;
1277
2353
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1278
- value: {
1279
- type: NumberConstructor;
1280
- default: undefined;
2354
+ readonly value: {
2355
+ readonly type: NumberConstructor;
2356
+ readonly default: undefined;
1281
2357
  };
1282
- max: {
1283
- type: NumberConstructor;
1284
- default: number;
2358
+ readonly max: {
2359
+ readonly type: NumberConstructor;
2360
+ readonly default: 100;
1285
2361
  };
1286
- intent: {
1287
- type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
1288
- default: undefined;
2362
+ readonly intent: {
2363
+ readonly type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
2364
+ readonly default: undefined;
1289
2365
  };
1290
- size: {
1291
- type: PropType<"sm" | "md" | "lg">;
1292
- default: undefined;
2366
+ readonly size: {
2367
+ readonly type: PropType<"sm" | "md" | "lg">;
2368
+ readonly default: undefined;
1293
2369
  };
1294
2370
  }>> & Readonly<{}>, {
1295
- value: number;
1296
- size: "sm" | "md" | "lg";
1297
- intent: "primary" | "danger" | "success" | "warning" | "info";
1298
- max: number;
2371
+ readonly value: number;
2372
+ readonly size: "sm" | "md" | "lg";
2373
+ readonly intent: "primary" | "danger" | "success" | "warning" | "info";
2374
+ readonly max: number;
1299
2375
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2376
+ declare const spinnerProps: {
2377
+ readonly size: {
2378
+ readonly type: PropType<"sm" | "md" | "lg" | "xl">;
2379
+ readonly default: undefined;
2380
+ };
2381
+ readonly label: {
2382
+ readonly type: StringConstructor;
2383
+ readonly default: "Loading";
2384
+ };
2385
+ };
2386
+ /** Props for {@link Spinner}. */
2387
+ type SpinnerProps = ExtractPublicPropTypes<typeof spinnerProps>;
1300
2388
  /** Spinner primitive: `hl-spinner`, announced via `role="status"`. */
1301
2389
  declare const Spinner: vue.DefineComponent<vue.ExtractPropTypes<{
1302
- size: {
1303
- type: PropType<"sm" | "md" | "lg" | "xl">;
1304
- default: undefined;
2390
+ readonly size: {
2391
+ readonly type: PropType<"sm" | "md" | "lg" | "xl">;
2392
+ readonly default: undefined;
1305
2393
  };
1306
- label: {
1307
- type: StringConstructor;
1308
- default: string;
2394
+ readonly label: {
2395
+ readonly type: StringConstructor;
2396
+ readonly default: "Loading";
1309
2397
  };
1310
2398
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1311
2399
  [key: string]: any;
1312
2400
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1313
- size: {
1314
- type: PropType<"sm" | "md" | "lg" | "xl">;
1315
- default: undefined;
2401
+ readonly size: {
2402
+ readonly type: PropType<"sm" | "md" | "lg" | "xl">;
2403
+ readonly default: undefined;
1316
2404
  };
1317
- label: {
1318
- type: StringConstructor;
1319
- default: string;
2405
+ readonly label: {
2406
+ readonly type: StringConstructor;
2407
+ readonly default: "Loading";
1320
2408
  };
1321
2409
  }>> & Readonly<{}>, {
1322
- label: string;
1323
- size: "sm" | "md" | "lg" | "xl";
2410
+ readonly label: string;
2411
+ readonly size: "sm" | "md" | "lg" | "xl";
1324
2412
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1325
- /** Skeleton placeholder primitive: `hl-skeleton`. */
2413
+ declare const skeletonProps: {
2414
+ readonly shape: {
2415
+ readonly type: PropType<"rect" | "text" | "circle">;
2416
+ readonly default: undefined;
2417
+ };
2418
+ /** Inline size (CSS length or px number). */
2419
+ readonly width: {
2420
+ readonly type: PropType<string | number>;
2421
+ readonly default: undefined;
2422
+ };
2423
+ /** Block size (CSS length or px number). */
2424
+ readonly height: {
2425
+ readonly type: PropType<string | number>;
2426
+ readonly default: undefined;
2427
+ };
2428
+ };
2429
+ /** Props for {@link Skeleton}. */
2430
+ type SkeletonProps = ExtractPublicPropTypes<typeof skeletonProps>;
2431
+ /** Skeleton placeholder primitive: `hl-skeleton` with a `shape`. */
1326
2432
  declare const Skeleton: vue.DefineComponent<vue.ExtractPropTypes<{
1327
- variant: {
1328
- type: PropType<"rect" | "text" | "circle">;
1329
- default: undefined;
2433
+ readonly shape: {
2434
+ readonly type: PropType<"rect" | "text" | "circle">;
2435
+ readonly default: undefined;
1330
2436
  };
1331
- width: {
1332
- type: (StringConstructor | NumberConstructor)[];
1333
- default: undefined;
2437
+ /** Inline size (CSS length or px number). */
2438
+ readonly width: {
2439
+ readonly type: PropType<string | number>;
2440
+ readonly default: undefined;
1334
2441
  };
1335
- height: {
1336
- type: (StringConstructor | NumberConstructor)[];
1337
- default: undefined;
2442
+ /** Block size (CSS length or px number). */
2443
+ readonly height: {
2444
+ readonly type: PropType<string | number>;
2445
+ readonly default: undefined;
1338
2446
  };
1339
2447
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1340
2448
  [key: string]: any;
1341
2449
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1342
- variant: {
1343
- type: PropType<"rect" | "text" | "circle">;
1344
- default: undefined;
2450
+ readonly shape: {
2451
+ readonly type: PropType<"rect" | "text" | "circle">;
2452
+ readonly default: undefined;
1345
2453
  };
1346
- width: {
1347
- type: (StringConstructor | NumberConstructor)[];
1348
- default: undefined;
2454
+ /** Inline size (CSS length or px number). */
2455
+ readonly width: {
2456
+ readonly type: PropType<string | number>;
2457
+ readonly default: undefined;
1349
2458
  };
1350
- height: {
1351
- type: (StringConstructor | NumberConstructor)[];
1352
- default: undefined;
2459
+ /** Block size (CSS length or px number). */
2460
+ readonly height: {
2461
+ readonly type: PropType<string | number>;
2462
+ readonly default: undefined;
1353
2463
  };
1354
2464
  }>> & Readonly<{}>, {
1355
- variant: "circle" | "rect" | "text";
1356
- width: string | number;
1357
- height: string | number;
2465
+ readonly shape: "rect" | "text" | "circle";
2466
+ readonly width: string | number;
2467
+ readonly height: string | number;
1358
2468
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1359
- /** A polite toast live region. Mount once near your app root. */
1360
- declare const ToastRegion: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
2469
+ declare const toastRegionProps: {
2470
+ /** Default auto-dismiss duration in ms for toasts shown into this region. */
2471
+ readonly duration: {
2472
+ readonly type: NumberConstructor;
2473
+ readonly default: undefined;
2474
+ };
2475
+ };
2476
+ /** Props for {@link ToastRegion}. */
2477
+ type ToastRegionProps = ExtractPublicPropTypes<typeof toastRegionProps>;
2478
+ /**
2479
+ * The polite live region toasts render into. Mount once near your app root;
2480
+ * it enhances itself on mount so `useToast()` and declarative
2481
+ * `data-hl-toast-trigger` buttons target it.
2482
+ */
2483
+ declare const ToastRegion: vue.DefineComponent<vue.ExtractPropTypes<{
2484
+ /** Default auto-dismiss duration in ms for toasts shown into this region. */
2485
+ readonly duration: {
2486
+ readonly type: NumberConstructor;
2487
+ readonly default: undefined;
2488
+ };
2489
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1361
2490
  [key: string]: any;
1362
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2491
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
2492
+ /** Default auto-dismiss duration in ms for toasts shown into this region. */
2493
+ readonly duration: {
2494
+ readonly type: NumberConstructor;
2495
+ readonly default: undefined;
2496
+ };
2497
+ }>> & Readonly<{}>, {
2498
+ readonly duration: number;
2499
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1363
2500
 
2501
+ declare const cardProps: {
2502
+ /** Hover/focus affordance for clickable cards. */
2503
+ readonly interactive: {
2504
+ readonly type: BooleanConstructor;
2505
+ readonly default: false;
2506
+ };
2507
+ };
2508
+ /** Props for {@link Card}. */
2509
+ type CardProps = ExtractPublicPropTypes<typeof cardProps>;
1364
2510
  /** Card container: `hl-card`. Compose with the Card* parts. */
1365
2511
  declare const Card: vue.DefineComponent<vue.ExtractPropTypes<{
1366
- interactive: {
1367
- type: BooleanConstructor;
1368
- default: boolean;
2512
+ /** Hover/focus affordance for clickable cards. */
2513
+ readonly interactive: {
2514
+ readonly type: BooleanConstructor;
2515
+ readonly default: false;
1369
2516
  };
1370
2517
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1371
2518
  [key: string]: any;
1372
2519
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1373
- interactive: {
1374
- type: BooleanConstructor;
1375
- default: boolean;
2520
+ /** Hover/focus affordance for clickable cards. */
2521
+ readonly interactive: {
2522
+ readonly type: BooleanConstructor;
2523
+ readonly default: false;
1376
2524
  };
1377
2525
  }>> & Readonly<{}>, {
1378
- interactive: boolean;
2526
+ readonly interactive: boolean;
1379
2527
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2528
+ /** Props for {@link CardHeader}. */
2529
+ type CardHeaderProps = Record<never, never>;
2530
+ /** Props for {@link CardBody}. */
2531
+ type CardBodyProps = Record<never, never>;
2532
+ /** Props for {@link CardFooter}. */
2533
+ type CardFooterProps = Record<never, never>;
2534
+ /** Props for {@link CardTitle}. */
2535
+ type CardTitleProps = Record<never, never>;
2536
+ /** Props for {@link CardDescription}. */
2537
+ type CardDescriptionProps = Record<never, never>;
2538
+ /** Props for {@link AvatarGroup}. */
2539
+ type AvatarGroupProps = Record<never, never>;
2540
+ /** Props for {@link Kbd}. */
2541
+ type KbdProps = Record<never, never>;
1380
2542
  /** Header region of a {@link Card}. */
1381
2543
  declare const CardHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1382
2544
  [key: string]: any;
@@ -1397,48 +2559,68 @@ declare const CardTitle: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNod
1397
2559
  declare const CardDescription: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1398
2560
  [key: string]: any;
1399
2561
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1400
- /** Avatar primitive: `hl-avatar` with image + graceful fallback. */
2562
+ declare const avatarProps: {
2563
+ readonly src: {
2564
+ readonly type: StringConstructor;
2565
+ readonly default: undefined;
2566
+ };
2567
+ readonly alt: {
2568
+ readonly type: StringConstructor;
2569
+ readonly default: "";
2570
+ };
2571
+ readonly size: {
2572
+ readonly type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
2573
+ readonly default: undefined;
2574
+ };
2575
+ readonly shape: {
2576
+ readonly type: PropType<"circle" | "square">;
2577
+ readonly default: undefined;
2578
+ };
2579
+ };
2580
+ /** Props for {@link Avatar}. */
2581
+ type AvatarProps = ExtractPublicPropTypes<typeof avatarProps>;
2582
+ /** Avatar primitive: `hl-avatar` with image + graceful fallback (default slot). */
1401
2583
  declare const Avatar: vue.DefineComponent<vue.ExtractPropTypes<{
1402
- src: {
1403
- type: StringConstructor;
1404
- default: undefined;
2584
+ readonly src: {
2585
+ readonly type: StringConstructor;
2586
+ readonly default: undefined;
1405
2587
  };
1406
- alt: {
1407
- type: StringConstructor;
1408
- default: string;
2588
+ readonly alt: {
2589
+ readonly type: StringConstructor;
2590
+ readonly default: "";
1409
2591
  };
1410
- size: {
1411
- type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
1412
- default: undefined;
2592
+ readonly size: {
2593
+ readonly type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
2594
+ readonly default: undefined;
1413
2595
  };
1414
- shape: {
1415
- type: PropType<"circle" | "square">;
1416
- default: undefined;
2596
+ readonly shape: {
2597
+ readonly type: PropType<"circle" | "square">;
2598
+ readonly default: undefined;
1417
2599
  };
1418
2600
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1419
2601
  [key: string]: any;
1420
2602
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1421
- src: {
1422
- type: StringConstructor;
1423
- default: undefined;
2603
+ readonly src: {
2604
+ readonly type: StringConstructor;
2605
+ readonly default: undefined;
1424
2606
  };
1425
- alt: {
1426
- type: StringConstructor;
1427
- default: string;
2607
+ readonly alt: {
2608
+ readonly type: StringConstructor;
2609
+ readonly default: "";
1428
2610
  };
1429
- size: {
1430
- type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
1431
- default: undefined;
2611
+ readonly size: {
2612
+ readonly type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
2613
+ readonly default: undefined;
1432
2614
  };
1433
- shape: {
1434
- type: PropType<"circle" | "square">;
1435
- default: undefined;
2615
+ readonly shape: {
2616
+ readonly type: PropType<"circle" | "square">;
2617
+ readonly default: undefined;
1436
2618
  };
1437
2619
  }>> & Readonly<{}>, {
1438
- size: "sm" | "md" | "lg" | "xl" | "xs";
1439
- src: string;
1440
- alt: string;
1441
- shape: "circle" | "square";
2620
+ readonly size: "sm" | "md" | "lg" | "xl" | "xs";
2621
+ readonly shape: "circle" | "square";
2622
+ readonly src: string;
2623
+ readonly alt: string;
1442
2624
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1443
2625
  /** Overlapping stack of avatars. */
1444
2626
  declare const AvatarGroup: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
@@ -1448,130 +2630,281 @@ declare const AvatarGroup: vue.DefineComponent<{}, () => vue.VNode<vue.RendererN
1448
2630
  declare const Kbd: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1449
2631
  [key: string]: any;
1450
2632
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2633
+ declare const separatorProps: {
2634
+ readonly orientation: {
2635
+ readonly type: PropType<"horizontal" | "vertical">;
2636
+ readonly default: "horizontal";
2637
+ };
2638
+ /** Purely visual: hides the separator from assistive technology. */
2639
+ readonly decorative: {
2640
+ readonly type: BooleanConstructor;
2641
+ readonly default: false;
2642
+ };
2643
+ };
2644
+ /** Props for {@link Separator}. */
2645
+ type SeparatorProps = ExtractPublicPropTypes<typeof separatorProps>;
1451
2646
  /** Separator primitive: `<hr class="hl-separator">`. */
1452
2647
  declare const Separator: vue.DefineComponent<vue.ExtractPropTypes<{
1453
- orientation: {
1454
- type: PropType<"horizontal" | "vertical">;
1455
- default: string;
2648
+ readonly orientation: {
2649
+ readonly type: PropType<"horizontal" | "vertical">;
2650
+ readonly default: "horizontal";
2651
+ };
2652
+ /** Purely visual: hides the separator from assistive technology. */
2653
+ readonly decorative: {
2654
+ readonly type: BooleanConstructor;
2655
+ readonly default: false;
2656
+ };
2657
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
2658
+ [key: string]: any;
2659
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
2660
+ readonly orientation: {
2661
+ readonly type: PropType<"horizontal" | "vertical">;
2662
+ readonly default: "horizontal";
2663
+ };
2664
+ /** Purely visual: hides the separator from assistive technology. */
2665
+ readonly decorative: {
2666
+ readonly type: BooleanConstructor;
2667
+ readonly default: false;
2668
+ };
2669
+ }>> & Readonly<{}>, {
2670
+ readonly orientation: "horizontal" | "vertical";
2671
+ readonly decorative: boolean;
2672
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2673
+ declare const tableProps: {
2674
+ /** Alternate row backgrounds. */
2675
+ readonly striped: {
2676
+ readonly type: BooleanConstructor;
2677
+ readonly default: false;
2678
+ };
2679
+ /** Highlight the hovered row. */
2680
+ readonly hover: {
2681
+ readonly type: BooleanConstructor;
2682
+ readonly default: false;
2683
+ };
2684
+ /** Cell text alignment. */
2685
+ readonly align: {
2686
+ readonly type: PropType<"start" | "center" | "end">;
2687
+ readonly default: undefined;
2688
+ };
2689
+ readonly size: {
2690
+ readonly type: PropType<"sm" | "md" | "lg">;
2691
+ readonly default: undefined;
1456
2692
  };
1457
- decorative: {
1458
- type: BooleanConstructor;
1459
- default: boolean;
2693
+ };
2694
+ /** Props for {@link Table}. */
2695
+ type TableProps = ExtractPublicPropTypes<typeof tableProps>;
2696
+ /**
2697
+ * Data table primitive: `<table class="hl-table">` with `striped`, `hover`,
2698
+ * `align`, and `size` modifiers. Author the rows yourself in the default slot.
2699
+ */
2700
+ declare const Table: vue.DefineComponent<vue.ExtractPropTypes<{
2701
+ /** Alternate row backgrounds. */
2702
+ readonly striped: {
2703
+ readonly type: BooleanConstructor;
2704
+ readonly default: false;
2705
+ };
2706
+ /** Highlight the hovered row. */
2707
+ readonly hover: {
2708
+ readonly type: BooleanConstructor;
2709
+ readonly default: false;
2710
+ };
2711
+ /** Cell text alignment. */
2712
+ readonly align: {
2713
+ readonly type: PropType<"start" | "center" | "end">;
2714
+ readonly default: undefined;
2715
+ };
2716
+ readonly size: {
2717
+ readonly type: PropType<"sm" | "md" | "lg">;
2718
+ readonly default: undefined;
1460
2719
  };
1461
2720
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1462
2721
  [key: string]: any;
1463
2722
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1464
- orientation: {
1465
- type: PropType<"horizontal" | "vertical">;
1466
- default: string;
2723
+ /** Alternate row backgrounds. */
2724
+ readonly striped: {
2725
+ readonly type: BooleanConstructor;
2726
+ readonly default: false;
1467
2727
  };
1468
- decorative: {
1469
- type: BooleanConstructor;
1470
- default: boolean;
2728
+ /** Highlight the hovered row. */
2729
+ readonly hover: {
2730
+ readonly type: BooleanConstructor;
2731
+ readonly default: false;
2732
+ };
2733
+ /** Cell text alignment. */
2734
+ readonly align: {
2735
+ readonly type: PropType<"start" | "center" | "end">;
2736
+ readonly default: undefined;
2737
+ };
2738
+ readonly size: {
2739
+ readonly type: PropType<"sm" | "md" | "lg">;
2740
+ readonly default: undefined;
1471
2741
  };
1472
2742
  }>> & Readonly<{}>, {
1473
- orientation: "horizontal" | "vertical";
1474
- decorative: boolean;
2743
+ readonly size: "sm" | "md" | "lg";
2744
+ readonly hover: boolean;
2745
+ readonly striped: boolean;
2746
+ readonly align: "start" | "center" | "end";
1475
2747
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1476
2748
 
2749
+ declare const paginationProps: {
2750
+ /** Current page (1-based); use `v-model:page`. */
2751
+ readonly page: {
2752
+ readonly type: NumberConstructor;
2753
+ readonly required: true;
2754
+ };
2755
+ /** Total number of pages. */
2756
+ readonly count: {
2757
+ readonly type: NumberConstructor;
2758
+ readonly required: true;
2759
+ };
2760
+ /** Pages shown on each side of the current one. */
2761
+ readonly siblingCount: {
2762
+ readonly type: NumberConstructor;
2763
+ readonly default: 1;
2764
+ };
2765
+ readonly showControls: {
2766
+ readonly type: BooleanConstructor;
2767
+ readonly default: true;
2768
+ };
2769
+ readonly prevLabel: {
2770
+ readonly type: StringConstructor;
2771
+ readonly default: "‹";
2772
+ };
2773
+ readonly nextLabel: {
2774
+ readonly type: StringConstructor;
2775
+ readonly default: "›";
2776
+ };
2777
+ };
2778
+ /** Props for {@link Pagination}. */
2779
+ type PaginationProps = ExtractPublicPropTypes<typeof paginationProps>;
1477
2780
  /** Pagination primitive: `hl-pagination` with smart ellipsis truncation. Emits `update:page`. */
1478
2781
  declare const Pagination: vue.DefineComponent<vue.ExtractPropTypes<{
1479
- page: {
1480
- type: NumberConstructor;
1481
- required: true;
2782
+ /** Current page (1-based); use `v-model:page`. */
2783
+ readonly page: {
2784
+ readonly type: NumberConstructor;
2785
+ readonly required: true;
1482
2786
  };
1483
- count: {
1484
- type: NumberConstructor;
1485
- required: true;
2787
+ /** Total number of pages. */
2788
+ readonly count: {
2789
+ readonly type: NumberConstructor;
2790
+ readonly required: true;
1486
2791
  };
1487
- siblingCount: {
1488
- type: NumberConstructor;
1489
- default: number;
2792
+ /** Pages shown on each side of the current one. */
2793
+ readonly siblingCount: {
2794
+ readonly type: NumberConstructor;
2795
+ readonly default: 1;
1490
2796
  };
1491
- showControls: {
1492
- type: BooleanConstructor;
1493
- default: boolean;
2797
+ readonly showControls: {
2798
+ readonly type: BooleanConstructor;
2799
+ readonly default: true;
1494
2800
  };
1495
- prevLabel: {
1496
- type: StringConstructor;
1497
- default: string;
2801
+ readonly prevLabel: {
2802
+ readonly type: StringConstructor;
2803
+ readonly default: "‹";
1498
2804
  };
1499
- nextLabel: {
1500
- type: StringConstructor;
1501
- default: string;
2805
+ readonly nextLabel: {
2806
+ readonly type: StringConstructor;
2807
+ readonly default: "›";
1502
2808
  };
1503
2809
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1504
2810
  [key: string]: any;
1505
2811
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:page"[], "update:page", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1506
- page: {
1507
- type: NumberConstructor;
1508
- required: true;
2812
+ /** Current page (1-based); use `v-model:page`. */
2813
+ readonly page: {
2814
+ readonly type: NumberConstructor;
2815
+ readonly required: true;
1509
2816
  };
1510
- count: {
1511
- type: NumberConstructor;
1512
- required: true;
2817
+ /** Total number of pages. */
2818
+ readonly count: {
2819
+ readonly type: NumberConstructor;
2820
+ readonly required: true;
1513
2821
  };
1514
- siblingCount: {
1515
- type: NumberConstructor;
1516
- default: number;
2822
+ /** Pages shown on each side of the current one. */
2823
+ readonly siblingCount: {
2824
+ readonly type: NumberConstructor;
2825
+ readonly default: 1;
1517
2826
  };
1518
- showControls: {
1519
- type: BooleanConstructor;
1520
- default: boolean;
2827
+ readonly showControls: {
2828
+ readonly type: BooleanConstructor;
2829
+ readonly default: true;
1521
2830
  };
1522
- prevLabel: {
1523
- type: StringConstructor;
1524
- default: string;
2831
+ readonly prevLabel: {
2832
+ readonly type: StringConstructor;
2833
+ readonly default: "‹";
1525
2834
  };
1526
- nextLabel: {
1527
- type: StringConstructor;
1528
- default: string;
2835
+ readonly nextLabel: {
2836
+ readonly type: StringConstructor;
2837
+ readonly default: "›";
1529
2838
  };
1530
2839
  }>> & Readonly<{
1531
2840
  "onUpdate:page"?: ((...args: any[]) => any) | undefined;
1532
2841
  }>, {
1533
- siblingCount: number;
1534
- showControls: boolean;
1535
- prevLabel: string;
1536
- nextLabel: string;
2842
+ readonly siblingCount: number;
2843
+ readonly showControls: boolean;
2844
+ readonly prevLabel: string;
2845
+ readonly nextLabel: string;
1537
2846
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2847
+ declare const tocProps: {
2848
+ /** Selector for the region whose headings populate the list. */
2849
+ readonly contentSelector: {
2850
+ readonly type: StringConstructor;
2851
+ readonly default: undefined;
2852
+ };
2853
+ /** Selector for which headings to include. */
2854
+ readonly headings: {
2855
+ readonly type: StringConstructor;
2856
+ readonly default: undefined;
2857
+ };
2858
+ readonly scrollSpy: {
2859
+ readonly type: PropType<boolean | undefined>;
2860
+ readonly default: undefined;
2861
+ };
2862
+ };
2863
+ /** Props for {@link Toc}. */
2864
+ type TocProps = ExtractPublicPropTypes<typeof tocProps>;
1538
2865
  /** Auto-generated table of contents with optional scroll-spy. */
1539
2866
  declare const Toc: vue.DefineComponent<vue.ExtractPropTypes<{
1540
- contentSelector: {
1541
- type: StringConstructor;
1542
- default: undefined;
2867
+ /** Selector for the region whose headings populate the list. */
2868
+ readonly contentSelector: {
2869
+ readonly type: StringConstructor;
2870
+ readonly default: undefined;
1543
2871
  };
1544
- headings: {
1545
- type: StringConstructor;
1546
- default: undefined;
2872
+ /** Selector for which headings to include. */
2873
+ readonly headings: {
2874
+ readonly type: StringConstructor;
2875
+ readonly default: undefined;
1547
2876
  };
1548
- scrollSpy: {
1549
- type: PropType<boolean | undefined>;
1550
- default: undefined;
2877
+ readonly scrollSpy: {
2878
+ readonly type: PropType<boolean | undefined>;
2879
+ readonly default: undefined;
1551
2880
  };
1552
2881
  }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1553
2882
  [key: string]: any;
1554
2883
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1555
- contentSelector: {
1556
- type: StringConstructor;
1557
- default: undefined;
2884
+ /** Selector for the region whose headings populate the list. */
2885
+ readonly contentSelector: {
2886
+ readonly type: StringConstructor;
2887
+ readonly default: undefined;
1558
2888
  };
1559
- headings: {
1560
- type: StringConstructor;
1561
- default: undefined;
2889
+ /** Selector for which headings to include. */
2890
+ readonly headings: {
2891
+ readonly type: StringConstructor;
2892
+ readonly default: undefined;
1562
2893
  };
1563
- scrollSpy: {
1564
- type: PropType<boolean | undefined>;
1565
- default: undefined;
2894
+ readonly scrollSpy: {
2895
+ readonly type: PropType<boolean | undefined>;
2896
+ readonly default: undefined;
1566
2897
  };
1567
2898
  }>> & Readonly<{}>, {
1568
- contentSelector: string;
1569
- headings: string;
1570
- scrollSpy: boolean | undefined;
2899
+ readonly contentSelector: string;
2900
+ readonly headings: string;
2901
+ readonly scrollSpy: boolean | undefined;
1571
2902
  }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
2903
+ /** Props for {@link SkipLink}. */
2904
+ type SkipLinkProps = Record<never, never>;
1572
2905
  /** Accessibility skip-navigation link, visually hidden until focused. */
1573
2906
  declare const SkipLink: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1574
2907
  [key: string]: any;
1575
2908
  }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1576
2909
 
1577
- export { Accordion, AccordionItem, Alert, Avatar, AvatarGroup, Badge, Breadcrumb, BreadcrumbItem, Button, Card, CardBody, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, Combobox, ComboboxInput, ComboboxList, ComboboxOption, Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, Disclosure, Drawer, DrawerBody, DrawerFooter, DrawerHeader, Dropdown, DropdownItem, DropdownMenu, DropdownSeparator, DropdownTrigger, Field, FieldError, FieldHelp, FieldLabel, Fieldset, HydratelessPlugin, Input, Kbd, Menu, MenuItem, Modal, ModalBody, ModalFooter, ModalHeader, Pagination, Popover, Progress, Radio, RadioGroup, SegmentedControl, Select, Separator, Skeleton, SkipLink, Slider, Spinner, Switch, Tab, TabList, TabPanel, Tabs, Textarea, ToastRegion, Toc, Tooltip, directives, useEnhancer, useFieldBindings, useToast, vHlAccordion, vHlCombobox, vHlCommand, vHlDisclosure, vHlDrawer, vHlDropdown, vHlMenu, vHlModal, vHlPopover, vHlTabs, vHlToc, vHlTooltip };
2910
+ export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, Alert, type AlertProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeProps, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, type BreadcrumbProps, Button, type ButtonProps, Card, CardBody, type CardBodyProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxProps, Combobox, ComboboxInput, type ComboboxInputProps, ComboboxList, type ComboboxListProps, ComboboxOption, type ComboboxOptionProps, type ComboboxProps, Command, CommandEmpty, type CommandEmptyProps, CommandGroup, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, type CommandProps, Disclosure, type DisclosureProps, Drawer, DrawerBody, type DrawerBodyProps, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerProps, Dropdown, DropdownGroup, type DropdownGroupProps, DropdownItem, type DropdownItemProps, DropdownMenu, type DropdownMenuProps, type DropdownProps, DropdownSeparator, type DropdownSeparatorProps, DropdownTrigger, type DropdownTriggerProps, Field, type FieldBindings, FieldError, type FieldErrorProps, FieldHelp, type FieldHelpProps, FieldLabel, type FieldLabelProps, type FieldProps, Fieldset, type FieldsetProps, Input, type InputProps, Kbd, type KbdProps, Menu, MenuItem, type MenuItemProps, type MenuProps, MenuSubmenu, type MenuSubmenuProps, Modal, ModalBody, type ModalBodyProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalProps, Pagination, type PaginationProps, Popover, type PopoverProps, Progress, type ProgressProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, SegmentedControl, type SegmentedControlProps, type SegmentedOption, Select, type SelectProps, Separator, type SeparatorProps, Skeleton, type SkeletonProps, SkipLink, type SkipLinkProps, Slider, type SliderProps, Spinner, type SpinnerProps, Switch, type SwitchProps, Tab, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, Table, type TableProps, Tabs, type TabsProps, Textarea, type TextareaProps, ToastRegion, type ToastRegionProps, Toc, type TocProps, Tooltip, type TooltipProps, useEnhancer, useField, useToast };