@hydrateless/vue 0.4.0 → 0.6.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.
package/dist/index.d.ts CHANGED
@@ -1,27 +1,27 @@
1
- import { Ref, Plugin, Directive } from 'vue';
2
- import { Disposer, ToastOptions } from '@hydrateless/enhancers';
3
- export { Disposer } from '@hydrateless/enhancers';
1
+ import * as vue from 'vue';
2
+ import { Ref, ShallowRef, Plugin, Directive, PropType } from 'vue';
3
+ import { EnhancerHandle, EnhanceToastOptions, ToastApi, EnhanceTabsOptions, EnhanceDropdownOptions, EnhanceMenuOptions, EnhanceComboboxOptions } from '@hydrateless/enhancers';
4
+ export { AccordionApi, ComboboxApi, Disposer, DrawerApi, DropdownApi, EnhancerHandle, ModalApi, PopoverApi, TabsApi, ToastApi, TooltipApi } from '@hydrateless/enhancers';
4
5
 
5
6
  /**
6
7
  * Attach any Hydrateless enhancer to a template ref for the lifetime of a
7
- * component. The enhancer's disposer is called automatically on unmount.
8
+ * component. Returns a shallow ref to the enhancer's imperative API; the
9
+ * instance is destroyed automatically on unmount.
8
10
  *
9
11
  * ```ts
10
12
  * const el = ref<HTMLElement | null>(null);
11
- * useEnhancer(el, enhanceTabs);
13
+ * const tabs = useEnhancer(el, enhanceTabs);
14
+ * tabs.value?.setValue('install');
12
15
  * ```
13
16
  */
14
- declare function useEnhancer(target: Ref<HTMLElement | null | undefined>, enhance: (container: HTMLElement) => Disposer): void;
17
+ declare function useEnhancer<Api = null>(target: Ref<HTMLElement | null | undefined>, enhance: (container: HTMLElement) => EnhancerHandle<Api>): ShallowRef<Api | null>;
15
18
 
16
- interface UseToastReturn {
17
- show: (message: string, options?: ToastOptions) => HTMLElement;
18
- dismiss: (toast: HTMLElement) => void;
19
- }
20
19
  /**
21
- * Sets up a toast region for the current component tree and returns an
22
- * imperative API. The region is torn down automatically on unmount.
20
+ * Imperative toast API backed by a lazily-created document-level region (or a
21
+ * `[data-hl-toast-region]` you render yourself, e.g. via `<ToastRegion>`).
22
+ * Safe to call from any component — no provider required.
23
23
  */
24
- declare function useToast(): UseToastReturn;
24
+ declare function useToast(options?: EnhanceToastOptions): ToastApi;
25
25
 
26
26
  /**
27
27
  * Registers every Hydrateless directive globally:
@@ -50,4 +50,1388 @@ declare const vHlCommand: Directive<HTMLElement>;
50
50
  /** Map of directive names (without the `v-` prefix) to their definitions. */
51
51
  declare const directives: Record<string, Directive<HTMLElement>>;
52
52
 
53
- export { HydratelessPlugin, type UseToastReturn, directives, useEnhancer, useToast, vHlAccordion, vHlCombobox, vHlCommand, vHlDisclosure, vHlDrawer, vHlDropdown, vHlMenu, vHlModal, vHlPopover, vHlTabs, vHlToc, vHlTooltip };
53
+ /**
54
+ * Accordion root of native `<details>` items. Compose with `<AccordionItem>`.
55
+ * Item values come from each `<AccordionItem value>`, defaulting to the index;
56
+ * open state works uncontrolled (`defaultValue` or `defaultOpen` on items) or
57
+ * with `v-model`.
58
+ */
59
+ declare const Accordion: vue.DefineComponent<vue.ExtractPropTypes<{
60
+ allowMultiple: {
61
+ type: BooleanConstructor;
62
+ default: boolean;
63
+ };
64
+ /** Controlled list of open item values (`v-model`). */
65
+ modelValue: {
66
+ type: PropType<string[]>;
67
+ default: undefined;
68
+ };
69
+ /** Initially open item values for uncontrolled usage. */
70
+ defaultValue: {
71
+ type: PropType<string[]>;
72
+ default: undefined;
73
+ };
74
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
75
+ [key: string]: any;
76
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
77
+ allowMultiple: {
78
+ type: BooleanConstructor;
79
+ default: boolean;
80
+ };
81
+ /** Controlled list of open item values (`v-model`). */
82
+ modelValue: {
83
+ type: PropType<string[]>;
84
+ default: undefined;
85
+ };
86
+ /** Initially open item values for uncontrolled usage. */
87
+ defaultValue: {
88
+ type: PropType<string[]>;
89
+ default: undefined;
90
+ };
91
+ }>> & Readonly<{
92
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
93
+ }>, {
94
+ allowMultiple: boolean;
95
+ modelValue: string[];
96
+ defaultValue: string[];
97
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
98
+ /** A `<details>`-based accordion section. Use the `summary` slot for the trigger. */
99
+ declare const AccordionItem: vue.DefineComponent<vue.ExtractPropTypes<{
100
+ /** Stable value identifying this item; defaults to its index. */
101
+ value: {
102
+ type: StringConstructor;
103
+ default: undefined;
104
+ };
105
+ defaultOpen: {
106
+ type: BooleanConstructor;
107
+ default: boolean;
108
+ };
109
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
110
+ [key: string]: any;
111
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
112
+ /** Stable value identifying this item; defaults to its index. */
113
+ value: {
114
+ type: StringConstructor;
115
+ default: undefined;
116
+ };
117
+ defaultOpen: {
118
+ type: BooleanConstructor;
119
+ default: boolean;
120
+ };
121
+ }>> & Readonly<{}>, {
122
+ value: string;
123
+ defaultOpen: boolean;
124
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
125
+ /**
126
+ * A single expandable section. Native `<details>` handles open/close; the
127
+ * enhancer only matters for a mutually-exclusive group.
128
+ */
129
+ declare const Disclosure: vue.DefineComponent<vue.ExtractPropTypes<{
130
+ defaultOpen: {
131
+ type: BooleanConstructor;
132
+ default: boolean;
133
+ };
134
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
135
+ [key: string]: any;
136
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
137
+ defaultOpen: {
138
+ type: BooleanConstructor;
139
+ default: boolean;
140
+ };
141
+ }>> & Readonly<{}>, {
142
+ defaultOpen: boolean;
143
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
144
+
145
+ /**
146
+ * Tabbed interface root. Compose with `<TabList>`, `<Tab>`, and `<TabPanel>`.
147
+ * Tab values come from each `<Tab value>`, defaulting to the index; selection
148
+ * works uncontrolled (`defaultValue`) or with `v-model`.
149
+ *
150
+ * ```vue
151
+ * <Tabs v-model="tab">
152
+ * <TabList>
153
+ * <Tab value="overview">Overview</Tab>
154
+ * <Tab value="install">Install</Tab>
155
+ * </TabList>
156
+ * <TabPanel>Zero runtime by default.</TabPanel>
157
+ * <TabPanel>npm install hydrateless</TabPanel>
158
+ * </Tabs>
159
+ * ```
160
+ */
161
+ declare const Tabs: vue.DefineComponent<vue.ExtractPropTypes<{
162
+ activation: {
163
+ type: PropType<EnhanceTabsOptions["activation"]>;
164
+ default: undefined;
165
+ };
166
+ orientation: {
167
+ type: PropType<EnhanceTabsOptions["orientation"]>;
168
+ default: undefined;
169
+ };
170
+ /** Controlled value of the selected tab (`v-model`). */
171
+ modelValue: {
172
+ type: StringConstructor;
173
+ default: undefined;
174
+ };
175
+ /** Initial value for uncontrolled usage. */
176
+ defaultValue: {
177
+ type: StringConstructor;
178
+ default: undefined;
179
+ };
180
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
181
+ [key: string]: any;
182
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
183
+ activation: {
184
+ type: PropType<EnhanceTabsOptions["activation"]>;
185
+ default: undefined;
186
+ };
187
+ orientation: {
188
+ type: PropType<EnhanceTabsOptions["orientation"]>;
189
+ default: undefined;
190
+ };
191
+ /** Controlled value of the selected tab (`v-model`). */
192
+ modelValue: {
193
+ type: StringConstructor;
194
+ default: undefined;
195
+ };
196
+ /** Initial value for uncontrolled usage. */
197
+ defaultValue: {
198
+ type: StringConstructor;
199
+ default: undefined;
200
+ };
201
+ }>> & Readonly<{
202
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
203
+ }>, {
204
+ modelValue: string;
205
+ defaultValue: string;
206
+ activation: "manual" | "automatic" | undefined;
207
+ orientation: "horizontal" | "vertical" | undefined;
208
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
209
+ /** The row of tab triggers (`role="tablist"`). */
210
+ declare const TabList: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
211
+ [key: string]: any;
212
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
213
+ /** A single tab trigger (`role="tab"`). */
214
+ declare const Tab: vue.DefineComponent<vue.ExtractPropTypes<{
215
+ /** Stable value identifying this tab; defaults to its index. */
216
+ value: {
217
+ type: StringConstructor;
218
+ default: undefined;
219
+ };
220
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
221
+ [key: string]: any;
222
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
223
+ /** Stable value identifying this tab; defaults to its index. */
224
+ value: {
225
+ type: StringConstructor;
226
+ default: undefined;
227
+ };
228
+ }>> & Readonly<{}>, {
229
+ value: string;
230
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
231
+ /** Content for the matching tab (`role="tabpanel"`). */
232
+ declare const TabPanel: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
233
+ [key: string]: any;
234
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
235
+
236
+ /**
237
+ * Button-triggered menu (WAI-ARIA menu-button pattern). Compose with
238
+ * `<DropdownTrigger>`, `<DropdownMenu>`, `<DropdownItem>`, and
239
+ * `<DropdownSeparator>`. Open state works uncontrolled or with
240
+ * `v-model:open`.
241
+ */
242
+ declare const Dropdown: vue.DefineComponent<vue.ExtractPropTypes<{
243
+ placement: {
244
+ type: PropType<EnhanceDropdownOptions["placement"]>;
245
+ default: undefined;
246
+ };
247
+ /** Controlled open state (`v-model:open`). */
248
+ open: {
249
+ type: PropType<boolean | undefined>;
250
+ default: undefined;
251
+ };
252
+ /** Open the menu initially for uncontrolled usage. */
253
+ defaultOpen: {
254
+ type: BooleanConstructor;
255
+ default: boolean;
256
+ };
257
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
258
+ [key: string]: any;
259
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
260
+ placement: {
261
+ type: PropType<EnhanceDropdownOptions["placement"]>;
262
+ default: undefined;
263
+ };
264
+ /** Controlled open state (`v-model:open`). */
265
+ open: {
266
+ type: PropType<boolean | undefined>;
267
+ default: undefined;
268
+ };
269
+ /** Open the menu initially for uncontrolled usage. */
270
+ defaultOpen: {
271
+ type: BooleanConstructor;
272
+ default: boolean;
273
+ };
274
+ }>> & Readonly<{
275
+ "onUpdate:open"?: ((...args: any[]) => any) | undefined;
276
+ }>, {
277
+ defaultOpen: boolean;
278
+ placement: "bottom" | "top" | undefined;
279
+ open: boolean | undefined;
280
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
281
+ /** The button that opens the menu. */
282
+ declare const DropdownTrigger: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
283
+ [key: string]: any;
284
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
285
+ /** The menu surface. */
286
+ declare const DropdownMenu: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
287
+ [key: string]: any;
288
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
289
+ /** A selectable menu item (`role="menuitem"`). Emits `select` on click. */
290
+ declare const DropdownItem: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
291
+ [key: string]: any;
292
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<{}> & Readonly<{
293
+ onSelect?: ((...args: any[]) => any) | undefined;
294
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
295
+ /** A visual divider between groups of items. */
296
+ declare const DropdownSeparator: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
297
+ [key: string]: any;
298
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
299
+
300
+ /**
301
+ * Menubar / navigation menu with single-level submenus. Compose with
302
+ * `<MenuItem>`; nest a flyout via the `submenu` slot.
303
+ */
304
+ declare const Menu: vue.DefineComponent<vue.ExtractPropTypes<{
305
+ orientation: {
306
+ type: PropType<EnhanceMenuOptions["orientation"]>;
307
+ default: string;
308
+ };
309
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
310
+ [key: string]: any;
311
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
312
+ orientation: {
313
+ type: PropType<EnhanceMenuOptions["orientation"]>;
314
+ default: string;
315
+ };
316
+ }>> & Readonly<{}>, {
317
+ orientation: "horizontal" | "vertical" | undefined;
318
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
319
+ /**
320
+ * A menu entry. Default slot is the label; the `submenu` slot nests a flyout.
321
+ * With `href` it renders an anchor, otherwise a button. Emits `select`.
322
+ */
323
+ declare const MenuItem: vue.DefineComponent<vue.ExtractPropTypes<{
324
+ href: {
325
+ type: StringConstructor;
326
+ default: undefined;
327
+ };
328
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
329
+ [key: string]: any;
330
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
331
+ href: {
332
+ type: StringConstructor;
333
+ default: undefined;
334
+ };
335
+ }>> & Readonly<{
336
+ onSelect?: ((...args: any[]) => any) | undefined;
337
+ }>, {
338
+ href: string;
339
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
340
+
341
+ /**
342
+ * Controlled dialog overlay on the native `<dialog>` plus the modal enhancer
343
+ * (focus trap, scroll-lock, background `inert`). Drive with `v-model:open`;
344
+ * Escape and backdrop clicks emit `update:open`. Compose with `<ModalHeader>`,
345
+ * `<ModalBody>`, `<ModalFooter>`.
346
+ */
347
+ declare const Modal: vue.DefineComponent<vue.ExtractPropTypes<{
348
+ open: {
349
+ type: BooleanConstructor;
350
+ required: true;
351
+ };
352
+ closeOnBackdrop: {
353
+ type: BooleanConstructor;
354
+ default: boolean;
355
+ };
356
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
357
+ [key: string]: any;
358
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
359
+ open: {
360
+ type: BooleanConstructor;
361
+ required: true;
362
+ };
363
+ closeOnBackdrop: {
364
+ type: BooleanConstructor;
365
+ default: boolean;
366
+ };
367
+ }>> & Readonly<{
368
+ "onUpdate:open"?: ((...args: any[]) => any) | undefined;
369
+ }>, {
370
+ closeOnBackdrop: boolean;
371
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
372
+ /**
373
+ * Controlled off-canvas panel on the native `<dialog>` plus the drawer
374
+ * enhancer. Drive with `v-model:open`; choose a `side`. Compose with
375
+ * `<DrawerHeader>`, `<DrawerBody>`, `<DrawerFooter>`.
376
+ */
377
+ declare const Drawer: vue.DefineComponent<vue.ExtractPropTypes<{
378
+ open: {
379
+ type: BooleanConstructor;
380
+ required: true;
381
+ };
382
+ side: {
383
+ type: PropType<"left" | "right">;
384
+ default: string;
385
+ };
386
+ closeOnBackdrop: {
387
+ type: BooleanConstructor;
388
+ default: boolean;
389
+ };
390
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
391
+ [key: string]: any;
392
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
393
+ open: {
394
+ type: BooleanConstructor;
395
+ required: true;
396
+ };
397
+ side: {
398
+ type: PropType<"left" | "right">;
399
+ default: string;
400
+ };
401
+ closeOnBackdrop: {
402
+ type: BooleanConstructor;
403
+ default: boolean;
404
+ };
405
+ }>> & Readonly<{
406
+ "onUpdate:open"?: ((...args: any[]) => any) | undefined;
407
+ }>, {
408
+ closeOnBackdrop: boolean;
409
+ side: "left" | "right";
410
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
411
+ declare const ModalHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
412
+ [key: string]: any;
413
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
414
+ declare const ModalBody: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
415
+ [key: string]: any;
416
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
417
+ declare const ModalFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
418
+ [key: string]: any;
419
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
420
+ declare const DrawerHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
421
+ [key: string]: any;
422
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
423
+ declare const DrawerBody: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
424
+ [key: string]: any;
425
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
426
+ declare const DrawerFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
427
+ [key: string]: any;
428
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
429
+ /**
430
+ * Controlled floating content. Visibility follows `open`; Escape and outside
431
+ * clicks emit `update:open` so `v-model:open` can dismiss it. Pair with your
432
+ * own trigger.
433
+ */
434
+ declare const Popover: vue.DefineComponent<vue.ExtractPropTypes<{
435
+ open: {
436
+ type: BooleanConstructor;
437
+ default: boolean;
438
+ };
439
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
440
+ [key: string]: any;
441
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
442
+ open: {
443
+ type: BooleanConstructor;
444
+ default: boolean;
445
+ };
446
+ }>> & Readonly<{
447
+ "onUpdate:open"?: ((...args: any[]) => any) | undefined;
448
+ }>, {
449
+ open: boolean;
450
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
451
+ /**
452
+ * Accessible tooltip wrapping a single focusable trigger (the default slot).
453
+ * The hint text comes from the `label` prop or `label` slot.
454
+ */
455
+ declare const Tooltip: vue.DefineComponent<vue.ExtractPropTypes<{
456
+ label: {
457
+ type: StringConstructor;
458
+ default: undefined;
459
+ };
460
+ id: {
461
+ type: StringConstructor;
462
+ default: undefined;
463
+ };
464
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
465
+ [key: string]: any;
466
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
467
+ label: {
468
+ type: StringConstructor;
469
+ default: undefined;
470
+ };
471
+ id: {
472
+ type: StringConstructor;
473
+ default: undefined;
474
+ };
475
+ }>> & Readonly<{}>, {
476
+ label: string;
477
+ id: string;
478
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
479
+
480
+ /**
481
+ * Semantic breadcrumb navigation (`<nav> > <ol>`). CSS-only. Compose with
482
+ * `<BreadcrumbItem>`.
483
+ */
484
+ declare const Breadcrumb: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
485
+ [key: string]: any;
486
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
487
+ /** A single crumb. Renders a link unless `current` (or no `href`) is set. */
488
+ declare const BreadcrumbItem: vue.DefineComponent<vue.ExtractPropTypes<{
489
+ href: {
490
+ type: StringConstructor;
491
+ default: undefined;
492
+ };
493
+ current: {
494
+ type: BooleanConstructor;
495
+ default: boolean;
496
+ };
497
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
498
+ [key: string]: any;
499
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
500
+ href: {
501
+ type: StringConstructor;
502
+ default: undefined;
503
+ };
504
+ current: {
505
+ type: BooleanConstructor;
506
+ default: boolean;
507
+ };
508
+ }>> & Readonly<{}>, {
509
+ href: string;
510
+ current: boolean;
511
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
512
+
513
+ /**
514
+ * Editable combobox (input + listbox), APG pattern. Compose with
515
+ * `<ComboboxInput>`, `<ComboboxList>`, `<ComboboxOption>`. The committed
516
+ * value works uncontrolled (`defaultValue`) or with `v-model`; selection also
517
+ * emits `select`.
518
+ */
519
+ declare const Combobox: vue.DefineComponent<vue.ExtractPropTypes<{
520
+ filter: {
521
+ type: PropType<EnhanceComboboxOptions["filter"]>;
522
+ default: undefined;
523
+ };
524
+ autoHighlight: {
525
+ type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
526
+ default: undefined;
527
+ };
528
+ /** Controlled committed value (`v-model`). */
529
+ modelValue: {
530
+ type: StringConstructor;
531
+ default: undefined;
532
+ };
533
+ /** Initial committed value for uncontrolled usage. */
534
+ defaultValue: {
535
+ type: StringConstructor;
536
+ default: undefined;
537
+ };
538
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
539
+ [key: string]: any;
540
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "select")[], "update:modelValue" | "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
541
+ filter: {
542
+ type: PropType<EnhanceComboboxOptions["filter"]>;
543
+ default: undefined;
544
+ };
545
+ autoHighlight: {
546
+ type: PropType<EnhanceComboboxOptions["autoHighlight"]>;
547
+ default: undefined;
548
+ };
549
+ /** Controlled committed value (`v-model`). */
550
+ modelValue: {
551
+ type: StringConstructor;
552
+ default: undefined;
553
+ };
554
+ /** Initial committed value for uncontrolled usage. */
555
+ defaultValue: {
556
+ type: StringConstructor;
557
+ default: undefined;
558
+ };
559
+ }>> & Readonly<{
560
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
561
+ onSelect?: ((...args: any[]) => any) | undefined;
562
+ }>, {
563
+ modelValue: string;
564
+ defaultValue: string;
565
+ filter: boolean | undefined;
566
+ autoHighlight: boolean | undefined;
567
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
568
+ /** The combobox text field. */
569
+ declare const ComboboxInput: vue.DefineComponent<vue.ExtractPropTypes<{
570
+ styled: {
571
+ type: BooleanConstructor;
572
+ default: boolean;
573
+ };
574
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
575
+ [key: string]: any;
576
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
577
+ styled: {
578
+ type: BooleanConstructor;
579
+ default: boolean;
580
+ };
581
+ }>> & Readonly<{}>, {
582
+ styled: boolean;
583
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
584
+ /** The option popup (`role="listbox"`). */
585
+ declare const ComboboxList: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
586
+ [key: string]: any;
587
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
588
+ /** A selectable option. The `value` is committed on selection. */
589
+ declare const ComboboxOption: vue.DefineComponent<vue.ExtractPropTypes<{
590
+ value: {
591
+ type: StringConstructor;
592
+ required: true;
593
+ };
594
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
595
+ [key: string]: any;
596
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
597
+ value: {
598
+ type: StringConstructor;
599
+ required: true;
600
+ };
601
+ }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
602
+
603
+ /**
604
+ * Command palette. Compose with `<CommandInput>`, `<CommandList>`,
605
+ * `<CommandGroup>`, `<CommandItem>`, `<CommandEmpty>`. Emits `select` with the
606
+ * chosen value. Place inside a `<dialog>` to use `hotkey`.
607
+ */
608
+ declare const Command: vue.DefineComponent<vue.ExtractPropTypes<{
609
+ hotkey: {
610
+ type: StringConstructor;
611
+ default: undefined;
612
+ };
613
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
614
+ [key: string]: any;
615
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
616
+ hotkey: {
617
+ type: StringConstructor;
618
+ default: undefined;
619
+ };
620
+ }>> & Readonly<{
621
+ onSelect?: ((...args: any[]) => any) | undefined;
622
+ }>, {
623
+ hotkey: string;
624
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
625
+ /** The palette search field. */
626
+ declare const CommandInput: vue.DefineComponent<vue.ExtractPropTypes<{
627
+ styled: {
628
+ type: BooleanConstructor;
629
+ default: boolean;
630
+ };
631
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
632
+ [key: string]: any;
633
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
634
+ styled: {
635
+ type: BooleanConstructor;
636
+ default: boolean;
637
+ };
638
+ }>> & Readonly<{}>, {
639
+ styled: boolean;
640
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
641
+ /** The scrollable list of commands (`role="listbox"`). */
642
+ declare const CommandList: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
643
+ [key: string]: any;
644
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
645
+ /** A labelled group of commands. The optional heading uses the `label` slot. */
646
+ declare const CommandGroup: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
647
+ [key: string]: any;
648
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
649
+ /** A runnable command (`role="option"`). */
650
+ declare const CommandItem: vue.DefineComponent<vue.ExtractPropTypes<{
651
+ value: {
652
+ type: StringConstructor;
653
+ required: true;
654
+ };
655
+ keywords: {
656
+ type: StringConstructor;
657
+ default: undefined;
658
+ };
659
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
660
+ [key: string]: any;
661
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
662
+ value: {
663
+ type: StringConstructor;
664
+ required: true;
665
+ };
666
+ keywords: {
667
+ type: StringConstructor;
668
+ default: undefined;
669
+ };
670
+ }>> & Readonly<{}>, {
671
+ keywords: string;
672
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
673
+ /** Shown when no commands match the query. */
674
+ declare const CommandEmpty: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
675
+ [key: string]: any;
676
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
677
+
678
+ type Size = 'sm' | 'md' | 'lg';
679
+ /**
680
+ * Layout + accessibility wrapper for a control. Provides a shared id so
681
+ * `<FieldLabel>`, `<FieldHelp>`, and `<FieldError>` wire up automatically.
682
+ * Bind the control with `v-bind="useField()"` or place an `<Input>` inside.
683
+ */
684
+ declare const Field: vue.DefineComponent<vue.ExtractPropTypes<{
685
+ id: {
686
+ type: StringConstructor;
687
+ default: undefined;
688
+ };
689
+ invalid: {
690
+ type: BooleanConstructor;
691
+ default: boolean;
692
+ };
693
+ required: {
694
+ type: BooleanConstructor;
695
+ default: boolean;
696
+ };
697
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
698
+ [key: string]: any;
699
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
700
+ id: {
701
+ type: StringConstructor;
702
+ default: undefined;
703
+ };
704
+ invalid: {
705
+ type: BooleanConstructor;
706
+ default: boolean;
707
+ };
708
+ required: {
709
+ type: BooleanConstructor;
710
+ default: boolean;
711
+ };
712
+ }>> & Readonly<{}>, {
713
+ invalid: boolean;
714
+ required: boolean;
715
+ id: string;
716
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
717
+ /** Returns props (`id`, `aria-describedby`, `aria-invalid`) to bind onto a control. */
718
+ declare function useFieldBindings(): {
719
+ id?: undefined;
720
+ 'aria-describedby'?: undefined;
721
+ 'aria-invalid'?: undefined;
722
+ } | {
723
+ id: string;
724
+ 'aria-describedby': string | undefined;
725
+ 'aria-invalid': true | undefined;
726
+ };
727
+ declare const FieldLabel: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
728
+ [key: string]: any;
729
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
730
+ declare const FieldHelp: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
731
+ [key: string]: any;
732
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
733
+ declare const FieldError: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
734
+ [key: string]: any;
735
+ }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
736
+ declare const Fieldset: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
737
+ [key: string]: any;
738
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
739
+ /** Text input styled with the `hl-input` primitive. Supports `v-model`. */
740
+ declare const Input: vue.DefineComponent<vue.ExtractPropTypes<{
741
+ modelValue: {
742
+ type: (StringConstructor | NumberConstructor)[];
743
+ default: undefined;
744
+ };
745
+ size: {
746
+ type: PropType<Size>;
747
+ default: undefined;
748
+ };
749
+ invalid: {
750
+ type: BooleanConstructor;
751
+ default: boolean;
752
+ };
753
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
754
+ [key: string]: any;
755
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
756
+ modelValue: {
757
+ type: (StringConstructor | NumberConstructor)[];
758
+ default: undefined;
759
+ };
760
+ size: {
761
+ type: PropType<Size>;
762
+ default: undefined;
763
+ };
764
+ invalid: {
765
+ type: BooleanConstructor;
766
+ default: boolean;
767
+ };
768
+ }>> & Readonly<{
769
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
770
+ }>, {
771
+ modelValue: string | number;
772
+ invalid: boolean;
773
+ size: Size;
774
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
775
+ /** Multi-line text input. Supports `v-model`. */
776
+ declare const Textarea: vue.DefineComponent<vue.ExtractPropTypes<{
777
+ modelValue: {
778
+ type: StringConstructor;
779
+ default: undefined;
780
+ };
781
+ size: {
782
+ type: PropType<Size>;
783
+ default: undefined;
784
+ };
785
+ invalid: {
786
+ type: BooleanConstructor;
787
+ default: boolean;
788
+ };
789
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
790
+ [key: string]: any;
791
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
792
+ modelValue: {
793
+ type: StringConstructor;
794
+ default: undefined;
795
+ };
796
+ size: {
797
+ type: PropType<Size>;
798
+ default: undefined;
799
+ };
800
+ invalid: {
801
+ type: BooleanConstructor;
802
+ default: boolean;
803
+ };
804
+ }>> & Readonly<{
805
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
806
+ }>, {
807
+ modelValue: string;
808
+ invalid: boolean;
809
+ size: Size;
810
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
811
+ /** Native `<select>` styled with `hl-select`. Supports `v-model`. */
812
+ declare const Select: vue.DefineComponent<vue.ExtractPropTypes<{
813
+ modelValue: {
814
+ type: StringConstructor;
815
+ default: undefined;
816
+ };
817
+ size: {
818
+ type: PropType<Size>;
819
+ default: undefined;
820
+ };
821
+ invalid: {
822
+ type: BooleanConstructor;
823
+ default: boolean;
824
+ };
825
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
826
+ [key: string]: any;
827
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
828
+ modelValue: {
829
+ type: StringConstructor;
830
+ default: undefined;
831
+ };
832
+ size: {
833
+ type: PropType<Size>;
834
+ default: undefined;
835
+ };
836
+ invalid: {
837
+ type: BooleanConstructor;
838
+ default: boolean;
839
+ };
840
+ }>> & Readonly<{
841
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
842
+ }>, {
843
+ modelValue: string;
844
+ invalid: boolean;
845
+ size: Size;
846
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
847
+ /** Checkbox built on a native input, label-wrapped. Supports `v-model`. */
848
+ declare const Checkbox: vue.DefineComponent<vue.ExtractPropTypes<{
849
+ modelValue: {
850
+ type: BooleanConstructor;
851
+ default: undefined;
852
+ };
853
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
854
+ [key: string]: any;
855
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
856
+ modelValue: {
857
+ type: BooleanConstructor;
858
+ default: undefined;
859
+ };
860
+ }>> & Readonly<{
861
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
862
+ }>, {
863
+ modelValue: boolean;
864
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
865
+ /** Toggle switch built on a native checkbox. Supports `v-model`. */
866
+ declare const Switch: vue.DefineComponent<vue.ExtractPropTypes<{
867
+ modelValue: {
868
+ type: BooleanConstructor;
869
+ default: undefined;
870
+ };
871
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
872
+ [key: string]: any;
873
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
874
+ modelValue: {
875
+ type: BooleanConstructor;
876
+ default: undefined;
877
+ };
878
+ }>> & Readonly<{
879
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
880
+ }>, {
881
+ modelValue: boolean;
882
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
883
+ /** Range slider primitive. Supports `v-model`. */
884
+ declare const Slider: vue.DefineComponent<vue.ExtractPropTypes<{
885
+ modelValue: {
886
+ type: (StringConstructor | NumberConstructor)[];
887
+ default: undefined;
888
+ };
889
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
890
+ [key: string]: any;
891
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
892
+ modelValue: {
893
+ type: (StringConstructor | NumberConstructor)[];
894
+ default: undefined;
895
+ };
896
+ }>> & Readonly<{
897
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
898
+ }>, {
899
+ modelValue: string | number;
900
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
901
+ /** Groups radios under `role="radiogroup"`. Supports `v-model`. */
902
+ declare const RadioGroup: vue.DefineComponent<vue.ExtractPropTypes<{
903
+ modelValue: {
904
+ type: StringConstructor;
905
+ default: undefined;
906
+ };
907
+ name: {
908
+ type: StringConstructor;
909
+ default: undefined;
910
+ };
911
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
912
+ [key: string]: any;
913
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
914
+ modelValue: {
915
+ type: StringConstructor;
916
+ default: undefined;
917
+ };
918
+ name: {
919
+ type: StringConstructor;
920
+ default: undefined;
921
+ };
922
+ }>> & Readonly<{
923
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
924
+ }>, {
925
+ name: string;
926
+ modelValue: string;
927
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
928
+ /** A single radio. Inside a `<RadioGroup>` it binds to the shared value. */
929
+ declare const Radio: vue.DefineComponent<vue.ExtractPropTypes<{
930
+ value: {
931
+ type: StringConstructor;
932
+ required: true;
933
+ };
934
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
935
+ [key: string]: any;
936
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
937
+ value: {
938
+ type: StringConstructor;
939
+ required: true;
940
+ };
941
+ }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
942
+ /** Segmented control — a styled radiogroup. Supports `v-model`. */
943
+ declare const SegmentedControl: vue.DefineComponent<vue.ExtractPropTypes<{
944
+ modelValue: {
945
+ type: StringConstructor;
946
+ default: undefined;
947
+ };
948
+ options: {
949
+ type: PropType<Array<{
950
+ label: string;
951
+ value: string;
952
+ disabled?: boolean;
953
+ }>>;
954
+ default: () => never[];
955
+ };
956
+ name: {
957
+ type: StringConstructor;
958
+ default: undefined;
959
+ };
960
+ size: {
961
+ type: PropType<Size>;
962
+ default: undefined;
963
+ };
964
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
965
+ [key: string]: any;
966
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
967
+ modelValue: {
968
+ type: StringConstructor;
969
+ default: undefined;
970
+ };
971
+ options: {
972
+ type: PropType<Array<{
973
+ label: string;
974
+ value: string;
975
+ disabled?: boolean;
976
+ }>>;
977
+ default: () => never[];
978
+ };
979
+ name: {
980
+ type: StringConstructor;
981
+ default: undefined;
982
+ };
983
+ size: {
984
+ type: PropType<Size>;
985
+ default: undefined;
986
+ };
987
+ }>> & Readonly<{
988
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
989
+ }>, {
990
+ name: string;
991
+ modelValue: string;
992
+ size: Size;
993
+ options: {
994
+ label: string;
995
+ value: string;
996
+ disabled?: boolean;
997
+ }[];
998
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
999
+
1000
+ /** Button primitive — `hl-button` with intent/variant/size modifiers. */
1001
+ declare const Button: vue.DefineComponent<vue.ExtractPropTypes<{
1002
+ variant: {
1003
+ type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
1004
+ default: undefined;
1005
+ };
1006
+ intent: {
1007
+ type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
1008
+ default: undefined;
1009
+ };
1010
+ size: {
1011
+ type: PropType<"sm" | "md" | "lg">;
1012
+ default: undefined;
1013
+ };
1014
+ block: {
1015
+ type: BooleanConstructor;
1016
+ default: boolean;
1017
+ };
1018
+ icon: {
1019
+ type: BooleanConstructor;
1020
+ default: boolean;
1021
+ };
1022
+ loading: {
1023
+ type: BooleanConstructor;
1024
+ default: boolean;
1025
+ };
1026
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1027
+ [key: string]: any;
1028
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1029
+ variant: {
1030
+ type: PropType<"solid" | "soft" | "outline" | "ghost" | "link">;
1031
+ default: undefined;
1032
+ };
1033
+ intent: {
1034
+ type: PropType<"neutral" | "primary" | "danger" | "success" | "warning" | "info">;
1035
+ default: undefined;
1036
+ };
1037
+ size: {
1038
+ type: PropType<"sm" | "md" | "lg">;
1039
+ default: undefined;
1040
+ };
1041
+ block: {
1042
+ type: BooleanConstructor;
1043
+ default: boolean;
1044
+ };
1045
+ icon: {
1046
+ type: BooleanConstructor;
1047
+ default: boolean;
1048
+ };
1049
+ loading: {
1050
+ type: BooleanConstructor;
1051
+ default: boolean;
1052
+ };
1053
+ }>> & Readonly<{}>, {
1054
+ icon: boolean;
1055
+ size: "sm" | "md" | "lg";
1056
+ variant: "link" | "solid" | "soft" | "outline" | "ghost";
1057
+ intent: "neutral" | "primary" | "danger" | "success" | "warning" | "info";
1058
+ block: boolean;
1059
+ loading: boolean;
1060
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1061
+
1062
+ type Intent = 'neutral' | 'primary' | 'danger' | 'success' | 'warning' | 'info';
1063
+ /** Alert primitive — `hl-alert` with intent, optional `icon` slot + `title`. */
1064
+ declare const Alert: vue.DefineComponent<vue.ExtractPropTypes<{
1065
+ intent: {
1066
+ type: PropType<Intent>;
1067
+ default: undefined;
1068
+ };
1069
+ title: {
1070
+ type: StringConstructor;
1071
+ default: undefined;
1072
+ };
1073
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1074
+ [key: string]: any;
1075
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1076
+ intent: {
1077
+ type: PropType<Intent>;
1078
+ default: undefined;
1079
+ };
1080
+ title: {
1081
+ type: StringConstructor;
1082
+ default: undefined;
1083
+ };
1084
+ }>> & Readonly<{}>, {
1085
+ title: string;
1086
+ intent: Intent;
1087
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1088
+ /** Badge primitive — `hl-badge` with intent/variant/size modifiers. */
1089
+ declare const Badge: vue.DefineComponent<vue.ExtractPropTypes<{
1090
+ intent: {
1091
+ type: PropType<Intent>;
1092
+ default: undefined;
1093
+ };
1094
+ variant: {
1095
+ type: PropType<"soft" | "solid" | "outline">;
1096
+ default: undefined;
1097
+ };
1098
+ size: {
1099
+ type: PropType<"sm" | "md">;
1100
+ default: undefined;
1101
+ };
1102
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1103
+ [key: string]: any;
1104
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1105
+ intent: {
1106
+ type: PropType<Intent>;
1107
+ default: undefined;
1108
+ };
1109
+ variant: {
1110
+ type: PropType<"soft" | "solid" | "outline">;
1111
+ default: undefined;
1112
+ };
1113
+ size: {
1114
+ type: PropType<"sm" | "md">;
1115
+ default: undefined;
1116
+ };
1117
+ }>> & Readonly<{}>, {
1118
+ size: "sm" | "md";
1119
+ variant: "solid" | "soft" | "outline";
1120
+ intent: Intent;
1121
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1122
+ /** Progress primitive — native `<progress class="hl-progress">`. */
1123
+ declare const Progress: vue.DefineComponent<vue.ExtractPropTypes<{
1124
+ value: {
1125
+ type: NumberConstructor;
1126
+ default: undefined;
1127
+ };
1128
+ max: {
1129
+ type: NumberConstructor;
1130
+ default: number;
1131
+ };
1132
+ intent: {
1133
+ type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
1134
+ default: undefined;
1135
+ };
1136
+ size: {
1137
+ type: PropType<"sm" | "md" | "lg">;
1138
+ default: undefined;
1139
+ };
1140
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1141
+ [key: string]: any;
1142
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1143
+ value: {
1144
+ type: NumberConstructor;
1145
+ default: undefined;
1146
+ };
1147
+ max: {
1148
+ type: NumberConstructor;
1149
+ default: number;
1150
+ };
1151
+ intent: {
1152
+ type: PropType<"primary" | "success" | "warning" | "danger" | "info">;
1153
+ default: undefined;
1154
+ };
1155
+ size: {
1156
+ type: PropType<"sm" | "md" | "lg">;
1157
+ default: undefined;
1158
+ };
1159
+ }>> & Readonly<{}>, {
1160
+ value: number;
1161
+ size: "sm" | "md" | "lg";
1162
+ intent: "primary" | "danger" | "success" | "warning" | "info";
1163
+ max: number;
1164
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1165
+ /** Spinner primitive — `hl-spinner`, announced via `role="status"`. */
1166
+ declare const Spinner: vue.DefineComponent<vue.ExtractPropTypes<{
1167
+ size: {
1168
+ type: PropType<"sm" | "md" | "lg" | "xl">;
1169
+ default: undefined;
1170
+ };
1171
+ label: {
1172
+ type: StringConstructor;
1173
+ default: string;
1174
+ };
1175
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1176
+ [key: string]: any;
1177
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1178
+ size: {
1179
+ type: PropType<"sm" | "md" | "lg" | "xl">;
1180
+ default: undefined;
1181
+ };
1182
+ label: {
1183
+ type: StringConstructor;
1184
+ default: string;
1185
+ };
1186
+ }>> & Readonly<{}>, {
1187
+ label: string;
1188
+ size: "sm" | "md" | "lg" | "xl";
1189
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1190
+ /** Skeleton placeholder primitive — `hl-skeleton`. */
1191
+ declare const Skeleton: vue.DefineComponent<vue.ExtractPropTypes<{
1192
+ variant: {
1193
+ type: PropType<"rect" | "text" | "circle">;
1194
+ default: undefined;
1195
+ };
1196
+ width: {
1197
+ type: (StringConstructor | NumberConstructor)[];
1198
+ default: undefined;
1199
+ };
1200
+ height: {
1201
+ type: (StringConstructor | NumberConstructor)[];
1202
+ default: undefined;
1203
+ };
1204
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1205
+ [key: string]: any;
1206
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1207
+ variant: {
1208
+ type: PropType<"rect" | "text" | "circle">;
1209
+ default: undefined;
1210
+ };
1211
+ width: {
1212
+ type: (StringConstructor | NumberConstructor)[];
1213
+ default: undefined;
1214
+ };
1215
+ height: {
1216
+ type: (StringConstructor | NumberConstructor)[];
1217
+ default: undefined;
1218
+ };
1219
+ }>> & Readonly<{}>, {
1220
+ variant: "circle" | "rect" | "text";
1221
+ width: string | number;
1222
+ height: string | number;
1223
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1224
+ /** A polite toast live region. Mount once near your app root. */
1225
+ declare const ToastRegion: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1226
+ [key: string]: any;
1227
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1228
+
1229
+ /** Card container — `hl-card`. Compose with the Card* parts. */
1230
+ declare const Card: vue.DefineComponent<vue.ExtractPropTypes<{
1231
+ interactive: {
1232
+ type: BooleanConstructor;
1233
+ default: boolean;
1234
+ };
1235
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1236
+ [key: string]: any;
1237
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1238
+ interactive: {
1239
+ type: BooleanConstructor;
1240
+ default: boolean;
1241
+ };
1242
+ }>> & Readonly<{}>, {
1243
+ interactive: boolean;
1244
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1245
+ declare const CardHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1246
+ [key: string]: any;
1247
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1248
+ declare const CardBody: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1249
+ [key: string]: any;
1250
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1251
+ declare const CardFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1252
+ [key: string]: any;
1253
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1254
+ declare const CardTitle: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1255
+ [key: string]: any;
1256
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1257
+ declare const CardDescription: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1258
+ [key: string]: any;
1259
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1260
+ /** Avatar primitive — `hl-avatar` with image + graceful fallback. */
1261
+ declare const Avatar: vue.DefineComponent<vue.ExtractPropTypes<{
1262
+ src: {
1263
+ type: StringConstructor;
1264
+ default: undefined;
1265
+ };
1266
+ alt: {
1267
+ type: StringConstructor;
1268
+ default: string;
1269
+ };
1270
+ size: {
1271
+ type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
1272
+ default: undefined;
1273
+ };
1274
+ shape: {
1275
+ type: PropType<"circle" | "square">;
1276
+ default: undefined;
1277
+ };
1278
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1279
+ [key: string]: any;
1280
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1281
+ src: {
1282
+ type: StringConstructor;
1283
+ default: undefined;
1284
+ };
1285
+ alt: {
1286
+ type: StringConstructor;
1287
+ default: string;
1288
+ };
1289
+ size: {
1290
+ type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
1291
+ default: undefined;
1292
+ };
1293
+ shape: {
1294
+ type: PropType<"circle" | "square">;
1295
+ default: undefined;
1296
+ };
1297
+ }>> & Readonly<{}>, {
1298
+ size: "sm" | "md" | "lg" | "xl" | "xs";
1299
+ src: string;
1300
+ alt: string;
1301
+ shape: "circle" | "square";
1302
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1303
+ /** Overlapping stack of avatars. */
1304
+ declare const AvatarGroup: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1305
+ [key: string]: any;
1306
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1307
+ /** Keyboard key primitive — `<kbd class="hl-kbd">`. */
1308
+ declare const Kbd: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1309
+ [key: string]: any;
1310
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1311
+ /** Separator primitive — `<hr class="hl-separator">`. */
1312
+ declare const Separator: vue.DefineComponent<vue.ExtractPropTypes<{
1313
+ orientation: {
1314
+ type: PropType<"horizontal" | "vertical">;
1315
+ default: string;
1316
+ };
1317
+ decorative: {
1318
+ type: BooleanConstructor;
1319
+ default: boolean;
1320
+ };
1321
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1322
+ [key: string]: any;
1323
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1324
+ orientation: {
1325
+ type: PropType<"horizontal" | "vertical">;
1326
+ default: string;
1327
+ };
1328
+ decorative: {
1329
+ type: BooleanConstructor;
1330
+ default: boolean;
1331
+ };
1332
+ }>> & Readonly<{}>, {
1333
+ orientation: "horizontal" | "vertical";
1334
+ decorative: boolean;
1335
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1336
+
1337
+ /** Pagination primitive — `hl-pagination` with smart ellipsis truncation. Emits `update:page`. */
1338
+ declare const Pagination: vue.DefineComponent<vue.ExtractPropTypes<{
1339
+ page: {
1340
+ type: NumberConstructor;
1341
+ required: true;
1342
+ };
1343
+ count: {
1344
+ type: NumberConstructor;
1345
+ required: true;
1346
+ };
1347
+ siblingCount: {
1348
+ type: NumberConstructor;
1349
+ default: number;
1350
+ };
1351
+ showControls: {
1352
+ type: BooleanConstructor;
1353
+ default: boolean;
1354
+ };
1355
+ prevLabel: {
1356
+ type: StringConstructor;
1357
+ default: string;
1358
+ };
1359
+ nextLabel: {
1360
+ type: StringConstructor;
1361
+ default: string;
1362
+ };
1363
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1364
+ [key: string]: any;
1365
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:page"[], "update:page", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1366
+ page: {
1367
+ type: NumberConstructor;
1368
+ required: true;
1369
+ };
1370
+ count: {
1371
+ type: NumberConstructor;
1372
+ required: true;
1373
+ };
1374
+ siblingCount: {
1375
+ type: NumberConstructor;
1376
+ default: number;
1377
+ };
1378
+ showControls: {
1379
+ type: BooleanConstructor;
1380
+ default: boolean;
1381
+ };
1382
+ prevLabel: {
1383
+ type: StringConstructor;
1384
+ default: string;
1385
+ };
1386
+ nextLabel: {
1387
+ type: StringConstructor;
1388
+ default: string;
1389
+ };
1390
+ }>> & Readonly<{
1391
+ "onUpdate:page"?: ((...args: any[]) => any) | undefined;
1392
+ }>, {
1393
+ siblingCount: number;
1394
+ showControls: boolean;
1395
+ prevLabel: string;
1396
+ nextLabel: string;
1397
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1398
+ /** Auto-generated table of contents with optional scroll-spy. */
1399
+ declare const Toc: vue.DefineComponent<vue.ExtractPropTypes<{
1400
+ contentSelector: {
1401
+ type: StringConstructor;
1402
+ default: undefined;
1403
+ };
1404
+ headings: {
1405
+ type: StringConstructor;
1406
+ default: undefined;
1407
+ };
1408
+ scrollSpy: {
1409
+ type: PropType<boolean | undefined>;
1410
+ default: undefined;
1411
+ };
1412
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1413
+ [key: string]: any;
1414
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
1415
+ contentSelector: {
1416
+ type: StringConstructor;
1417
+ default: undefined;
1418
+ };
1419
+ headings: {
1420
+ type: StringConstructor;
1421
+ default: undefined;
1422
+ };
1423
+ scrollSpy: {
1424
+ type: PropType<boolean | undefined>;
1425
+ default: undefined;
1426
+ };
1427
+ }>> & Readonly<{}>, {
1428
+ contentSelector: string;
1429
+ headings: string;
1430
+ scrollSpy: boolean | undefined;
1431
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1432
+ /** Accessibility skip-navigation link, visually hidden until focused. */
1433
+ declare const SkipLink: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
1434
+ [key: string]: any;
1435
+ }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
1436
+
1437
+ 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 };