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