@hoci/components 0.8.1 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/index.d.ts +788 -774
  2. package/dist/index.js +831 -0
  3. package/package.json +12 -17
  4. package/dist/index.cjs +0 -2243
  5. package/dist/index.d.cts +0 -793
  6. package/dist/index.d.mts +0 -793
  7. package/dist/index.mjs +0 -2229
package/dist/index.d.ts CHANGED
@@ -1,793 +1,807 @@
1
- import * as vue from 'vue';
2
- import { PropType, KeepAliveProps, CSSProperties, App } from 'vue';
3
- import * as _hoci_core from '@hoci/core';
4
- import * as _hoci_shared from '@hoci/shared';
5
- import * as _tanstack_virtual_core from '@tanstack/virtual-core';
6
- import { PartialKeys, VirtualizerOptions as VirtualizerOptions$1 } from '@tanstack/virtual-core';
1
+ import * as _hoci_shared0 from "@hoci/shared";
2
+ import * as vue9 from "vue";
3
+ import { App, CSSProperties, KeepAliveProps, PropType } from "vue";
4
+ import * as _hoci_core0 from "@hoci/core";
5
+ import * as _tanstack_virtual_core0 from "@tanstack/virtual-core";
6
+ import { PartialKeys, Virtualizer, VirtualizerOptions } from "@tanstack/virtual-core";
7
7
 
8
- declare const HiAffixTarget: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
9
- [key: string]: any;
10
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
11
-
12
- declare const HiAffix: vue.DefineComponent<vue.ExtractPropTypes<{
13
- as: {
14
- type: StringConstructor;
15
- default: string;
16
- };
17
- fixedClass: {
18
- type: StringConstructor;
19
- default: string;
20
- };
21
- offset: {
22
- type: NumberConstructor;
23
- default: number;
24
- };
25
- position: {
26
- type: vue.PropType<"top" | "bottom">;
27
- default: string;
28
- };
29
- target: {
30
- type: vue.PropType<string | Element | (() => Element | null | undefined)>;
31
- };
32
- zIndex: {
33
- type: NumberConstructor;
34
- default: number;
35
- };
36
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
37
- [key: string]: any;
38
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
39
- as: {
40
- type: StringConstructor;
41
- default: string;
42
- };
43
- fixedClass: {
44
- type: StringConstructor;
45
- default: string;
46
- };
47
- offset: {
48
- type: NumberConstructor;
49
- default: number;
50
- };
51
- position: {
52
- type: vue.PropType<"top" | "bottom">;
53
- default: string;
54
- };
55
- target: {
56
- type: vue.PropType<string | Element | (() => Element | null | undefined)>;
57
- };
58
- zIndex: {
59
- type: NumberConstructor;
60
- default: number;
61
- };
8
+ //#region ../core/src/affix-target/component.d.ts
9
+ declare const HiAffixTarget: vue9.DefineComponent<{}, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
10
+ [key: string]: any;
11
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
12
+ //#endregion
13
+ //#region ../core/src/affix/component.d.ts
14
+ declare const HiAffix: vue9.DefineComponent<vue9.ExtractPropTypes<{
15
+ as: {
16
+ type: StringConstructor;
17
+ default: string;
18
+ };
19
+ fixedClass: {
20
+ type: StringConstructor;
21
+ default: string;
22
+ };
23
+ offset: {
24
+ type: NumberConstructor;
25
+ default: number;
26
+ };
27
+ position: {
28
+ type: vue9.PropType<"top" | "bottom">;
29
+ default: string;
30
+ };
31
+ target: {
32
+ type: vue9.PropType<string | Element | (() => Element | null | undefined)>;
33
+ };
34
+ zIndex: {
35
+ type: NumberConstructor;
36
+ default: number;
37
+ };
38
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
39
+ [key: string]: any;
40
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
41
+ as: {
42
+ type: StringConstructor;
43
+ default: string;
44
+ };
45
+ fixedClass: {
46
+ type: StringConstructor;
47
+ default: string;
48
+ };
49
+ offset: {
50
+ type: NumberConstructor;
51
+ default: number;
52
+ };
53
+ position: {
54
+ type: vue9.PropType<"top" | "bottom">;
55
+ default: string;
56
+ };
57
+ target: {
58
+ type: vue9.PropType<string | Element | (() => Element | null | undefined)>;
59
+ };
60
+ zIndex: {
61
+ type: NumberConstructor;
62
+ default: number;
63
+ };
62
64
  }>> & Readonly<{}>, {
63
- as: string;
64
- fixedClass: string;
65
- offset: number;
66
- position: "top" | "bottom";
67
- zIndex: number;
68
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
69
-
70
- declare const HiConfigProvider: vue.DefineComponent<vue.ExtractPropTypes<{
71
- as: {
72
- type: StringConstructor;
73
- };
74
- icon: {
75
- type: vue.PropType<Partial<_hoci_core.SharedConfig["icon"]>>;
76
- };
77
- activateEvent: {
78
- type: vue.PropType<Partial<_hoci_core.SharedConfig["activateEvent"]>>;
79
- };
80
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
81
- [key: string]: any;
82
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
83
- as: {
84
- type: StringConstructor;
85
- };
86
- icon: {
87
- type: vue.PropType<Partial<_hoci_core.SharedConfig["icon"]>>;
88
- };
89
- activateEvent: {
90
- type: vue.PropType<Partial<_hoci_core.SharedConfig["activateEvent"]>>;
91
- };
92
- }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
93
-
94
- declare const HiFileUpload: vue.DefineComponent<vue.ExtractPropTypes<{
95
- accept: {
96
- type: StringConstructor;
97
- default: string;
98
- };
99
- as: {
100
- type: StringConstructor;
101
- default: string;
102
- };
103
- modelValue: {
104
- type: vue.PropType<File | File[]>;
105
- default: () => never[];
106
- };
107
- multiple: {
108
- type: BooleanConstructor;
109
- default: boolean;
110
- };
111
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
112
- [key: string]: any;
113
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
114
- accept: {
115
- type: StringConstructor;
116
- default: string;
117
- };
118
- as: {
119
- type: StringConstructor;
120
- default: string;
121
- };
122
- modelValue: {
123
- type: vue.PropType<File | File[]>;
124
- default: () => never[];
125
- };
126
- multiple: {
127
- type: BooleanConstructor;
128
- default: boolean;
129
- };
65
+ as: string;
66
+ position: "bottom" | "top";
67
+ fixedClass: string;
68
+ offset: number;
69
+ zIndex: number;
70
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
71
+ //#endregion
72
+ //#region ../core/src/config-provider/component.d.ts
73
+ declare const HiConfigProvider: vue9.DefineComponent<vue9.ExtractPropTypes<{
74
+ as: {
75
+ type: StringConstructor;
76
+ };
77
+ icon: {
78
+ type: vue9.PropType<Partial<_hoci_core0.SharedConfig["icon"]>>;
79
+ };
80
+ activateEvent: {
81
+ type: vue9.PropType<Partial<_hoci_core0.SharedConfig["activateEvent"]>>;
82
+ };
83
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
84
+ [key: string]: any;
85
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
86
+ as: {
87
+ type: StringConstructor;
88
+ };
89
+ icon: {
90
+ type: vue9.PropType<Partial<_hoci_core0.SharedConfig["icon"]>>;
91
+ };
92
+ activateEvent: {
93
+ type: vue9.PropType<Partial<_hoci_core0.SharedConfig["activateEvent"]>>;
94
+ };
95
+ }>> & Readonly<{}>, {}, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
96
+ //#endregion
97
+ //#region ../core/src/file-upload/component.d.ts
98
+ declare const HiFileUpload: vue9.DefineComponent<vue9.ExtractPropTypes<{
99
+ accept: {
100
+ type: StringConstructor;
101
+ default: string;
102
+ };
103
+ as: {
104
+ type: StringConstructor;
105
+ default: string;
106
+ };
107
+ modelValue: {
108
+ type: vue9.PropType<File | File[]>;
109
+ default: () => never[];
110
+ };
111
+ multiple: {
112
+ type: BooleanConstructor;
113
+ default: boolean;
114
+ };
115
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
116
+ [key: string]: any;
117
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
118
+ accept: {
119
+ type: StringConstructor;
120
+ default: string;
121
+ };
122
+ as: {
123
+ type: StringConstructor;
124
+ default: string;
125
+ };
126
+ modelValue: {
127
+ type: vue9.PropType<File | File[]>;
128
+ default: () => never[];
129
+ };
130
+ multiple: {
131
+ type: BooleanConstructor;
132
+ default: boolean;
133
+ };
130
134
  }>> & Readonly<{
131
- onChange?: ((...args: any[]) => any) | undefined;
132
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
135
+ onChange?: ((...args: any[]) => any) | undefined;
136
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
133
137
  }>, {
134
- as: string;
135
- modelValue: File | File[];
136
- multiple: boolean;
137
- accept: string;
138
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
139
-
140
- declare const HiIcon: vue.DefineComponent<vue.ExtractPropTypes<{
141
- as: {
142
- type: StringConstructor;
143
- default: string;
144
- };
145
- src: {
146
- type: StringConstructor;
147
- required: true;
148
- };
149
- size: {
150
- type: (StringConstructor | NumberConstructor)[];
151
- };
152
- width: {
153
- type: (StringConstructor | NumberConstructor)[];
154
- };
155
- height: {
156
- type: (StringConstructor | NumberConstructor)[];
157
- };
158
- color: {
159
- type: StringConstructor;
160
- default: string;
161
- };
162
- mask: {
163
- type: vue.PropType<boolean | "auto">;
164
- default: () => "auto";
165
- };
166
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
167
- [key: string]: any;
168
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
169
- as: {
170
- type: StringConstructor;
171
- default: string;
172
- };
173
- src: {
174
- type: StringConstructor;
175
- required: true;
176
- };
177
- size: {
178
- type: (StringConstructor | NumberConstructor)[];
179
- };
180
- width: {
181
- type: (StringConstructor | NumberConstructor)[];
182
- };
183
- height: {
184
- type: (StringConstructor | NumberConstructor)[];
185
- };
186
- color: {
187
- type: StringConstructor;
188
- default: string;
189
- };
190
- mask: {
191
- type: vue.PropType<boolean | "auto">;
192
- default: () => "auto";
193
- };
138
+ as: string;
139
+ multiple: boolean;
140
+ modelValue: File | File[];
141
+ accept: string;
142
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
143
+ //#endregion
144
+ //#region ../core/src/icon/component.d.ts
145
+ declare const HiIcon: vue9.DefineComponent<vue9.ExtractPropTypes<{
146
+ as: {
147
+ type: StringConstructor;
148
+ default: string;
149
+ };
150
+ src: {
151
+ type: StringConstructor;
152
+ required: true;
153
+ };
154
+ size: {
155
+ type: (NumberConstructor | StringConstructor)[];
156
+ };
157
+ width: {
158
+ type: (NumberConstructor | StringConstructor)[];
159
+ };
160
+ height: {
161
+ type: (NumberConstructor | StringConstructor)[];
162
+ };
163
+ color: {
164
+ type: StringConstructor;
165
+ default: string;
166
+ };
167
+ mask: {
168
+ type: vue9.PropType<boolean | "auto">;
169
+ default: () => "auto";
170
+ };
171
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
172
+ [key: string]: any;
173
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
174
+ as: {
175
+ type: StringConstructor;
176
+ default: string;
177
+ };
178
+ src: {
179
+ type: StringConstructor;
180
+ required: true;
181
+ };
182
+ size: {
183
+ type: (NumberConstructor | StringConstructor)[];
184
+ };
185
+ width: {
186
+ type: (NumberConstructor | StringConstructor)[];
187
+ };
188
+ height: {
189
+ type: (NumberConstructor | StringConstructor)[];
190
+ };
191
+ color: {
192
+ type: StringConstructor;
193
+ default: string;
194
+ };
195
+ mask: {
196
+ type: vue9.PropType<boolean | "auto">;
197
+ default: () => "auto";
198
+ };
194
199
  }>> & Readonly<{}>, {
195
- as: string;
196
- color: string;
197
- mask: boolean | "auto";
198
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
199
-
200
- declare const HiItem: vue.DefineComponent<vue.ExtractPropTypes<{
201
- as: {
202
- type: StringConstructor;
203
- default: string;
204
- };
205
- value: {
206
- type: vue.PropType<any>;
207
- default(): string;
208
- };
209
- label: {
210
- type: vue.PropType<string | ((val: any) => string) | _hoci_core.ElementLike | null>;
211
- };
212
- keepAlive: {
213
- type: BooleanConstructor;
214
- default: () => true;
215
- };
216
- activateEvent: {
217
- type: vue.PropType<_hoci_core.ActivateEvent>;
218
- };
219
- disabled: {
220
- type: BooleanConstructor;
221
- default: boolean;
222
- };
223
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
224
- [key: string]: any;
225
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "reject"[], "reject", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
226
- as: {
227
- type: StringConstructor;
228
- default: string;
229
- };
230
- value: {
231
- type: vue.PropType<any>;
232
- default(): string;
233
- };
234
- label: {
235
- type: vue.PropType<string | ((val: any) => string) | _hoci_core.ElementLike | null>;
236
- };
237
- keepAlive: {
238
- type: BooleanConstructor;
239
- default: () => true;
240
- };
241
- activateEvent: {
242
- type: vue.PropType<_hoci_core.ActivateEvent>;
243
- };
244
- disabled: {
245
- type: BooleanConstructor;
246
- default: boolean;
247
- };
200
+ as: string;
201
+ color: string;
202
+ mask: boolean | "auto";
203
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
204
+ //#endregion
205
+ //#region ../core/src/item/component.d.ts
206
+ declare const HiItem: vue9.DefineComponent<vue9.ExtractPropTypes<{
207
+ as: {
208
+ type: StringConstructor;
209
+ default: string;
210
+ };
211
+ value: {
212
+ type: vue9.PropType<any>;
213
+ default(): string;
214
+ };
215
+ label: {
216
+ type: vue9.PropType<string | ((val: any) => string) | _hoci_core0.ElementLike | null>;
217
+ };
218
+ keepAlive: {
219
+ type: BooleanConstructor;
220
+ default: () => true;
221
+ };
222
+ activateEvent: {
223
+ type: vue9.PropType<_hoci_core0.ActivateEvent>;
224
+ };
225
+ disabled: {
226
+ type: BooleanConstructor;
227
+ default: boolean;
228
+ };
229
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
230
+ [key: string]: any;
231
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, "reject"[], "reject", vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
232
+ as: {
233
+ type: StringConstructor;
234
+ default: string;
235
+ };
236
+ value: {
237
+ type: vue9.PropType<any>;
238
+ default(): string;
239
+ };
240
+ label: {
241
+ type: vue9.PropType<string | ((val: any) => string) | _hoci_core0.ElementLike | null>;
242
+ };
243
+ keepAlive: {
244
+ type: BooleanConstructor;
245
+ default: () => true;
246
+ };
247
+ activateEvent: {
248
+ type: vue9.PropType<_hoci_core0.ActivateEvent>;
249
+ };
250
+ disabled: {
251
+ type: BooleanConstructor;
252
+ default: boolean;
253
+ };
248
254
  }>> & Readonly<{
249
- onReject?: ((...args: any[]) => any) | undefined;
255
+ onReject?: ((...args: any[]) => any) | undefined;
250
256
  }>, {
251
- as: string;
252
- value: any;
253
- disabled: boolean;
254
- keepAlive: boolean;
255
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
256
-
257
- declare const HiPopover: vue.DefineComponent<vue.ExtractPropTypes<{
258
- as: {
259
- type: StringConstructor;
260
- default: string;
261
- };
262
- popupClass: {
263
- type: StringConstructor;
264
- };
265
- placement: {
266
- type: vue.PropType<_hoci_core.Placement>;
267
- default: () => "auto";
268
- };
269
- triggerEvent: {
270
- type: vue.PropType<_hoci_core.TriggerEvent>;
271
- default: () => "hover";
272
- };
273
- offset: {
274
- type: NumberConstructor;
275
- default: () => 8;
276
- };
277
- lazy: {
278
- type: BooleanConstructor;
279
- default: () => false;
280
- };
281
- visible: {
282
- type: BooleanConstructor;
283
- default: () => false;
284
- };
285
- disabled: {
286
- type: BooleanConstructor;
287
- default: () => false;
288
- };
289
- teleport: {
290
- type: vue.PropType<string | HTMLElement | boolean>;
291
- default: () => true;
292
- };
293
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
294
- [key: string]: any;
295
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:visible")[], "change" | "update:visible", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
296
- as: {
297
- type: StringConstructor;
298
- default: string;
299
- };
300
- popupClass: {
301
- type: StringConstructor;
302
- };
303
- placement: {
304
- type: vue.PropType<_hoci_core.Placement>;
305
- default: () => "auto";
306
- };
307
- triggerEvent: {
308
- type: vue.PropType<_hoci_core.TriggerEvent>;
309
- default: () => "hover";
310
- };
311
- offset: {
312
- type: NumberConstructor;
313
- default: () => 8;
314
- };
315
- lazy: {
316
- type: BooleanConstructor;
317
- default: () => false;
318
- };
319
- visible: {
320
- type: BooleanConstructor;
321
- default: () => false;
322
- };
323
- disabled: {
324
- type: BooleanConstructor;
325
- default: () => false;
326
- };
327
- teleport: {
328
- type: vue.PropType<string | HTMLElement | boolean>;
329
- default: () => true;
330
- };
257
+ as: string;
258
+ disabled: boolean;
259
+ value: any;
260
+ keepAlive: boolean;
261
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
262
+ //#endregion
263
+ //#region ../core/src/popover/component.d.ts
264
+ declare const HiPopover: vue9.DefineComponent<vue9.ExtractPropTypes<{
265
+ as: {
266
+ type: StringConstructor;
267
+ default: string;
268
+ };
269
+ popupClass: {
270
+ type: StringConstructor;
271
+ };
272
+ placement: {
273
+ type: vue9.PropType<_hoci_core0.Placement>;
274
+ default: () => "auto";
275
+ };
276
+ triggerEvent: {
277
+ type: vue9.PropType<_hoci_core0.TriggerEvent>;
278
+ default: () => "hover";
279
+ };
280
+ offset: {
281
+ type: NumberConstructor;
282
+ default: () => 8;
283
+ };
284
+ lazy: {
285
+ type: BooleanConstructor;
286
+ default: () => false;
287
+ };
288
+ visible: {
289
+ type: BooleanConstructor;
290
+ default: () => false;
291
+ };
292
+ disabled: {
293
+ type: BooleanConstructor;
294
+ default: () => false;
295
+ };
296
+ teleport: {
297
+ type: vue9.PropType<string | HTMLElement | boolean>;
298
+ default: () => true;
299
+ };
300
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
301
+ [key: string]: any;
302
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, ("change" | "update:visible")[], "change" | "update:visible", vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
303
+ as: {
304
+ type: StringConstructor;
305
+ default: string;
306
+ };
307
+ popupClass: {
308
+ type: StringConstructor;
309
+ };
310
+ placement: {
311
+ type: vue9.PropType<_hoci_core0.Placement>;
312
+ default: () => "auto";
313
+ };
314
+ triggerEvent: {
315
+ type: vue9.PropType<_hoci_core0.TriggerEvent>;
316
+ default: () => "hover";
317
+ };
318
+ offset: {
319
+ type: NumberConstructor;
320
+ default: () => 8;
321
+ };
322
+ lazy: {
323
+ type: BooleanConstructor;
324
+ default: () => false;
325
+ };
326
+ visible: {
327
+ type: BooleanConstructor;
328
+ default: () => false;
329
+ };
330
+ disabled: {
331
+ type: BooleanConstructor;
332
+ default: () => false;
333
+ };
334
+ teleport: {
335
+ type: vue9.PropType<string | HTMLElement | boolean>;
336
+ default: () => true;
337
+ };
331
338
  }>> & Readonly<{
332
- onChange?: ((...args: any[]) => any) | undefined;
333
- "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
339
+ onChange?: ((...args: any[]) => any) | undefined;
340
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
334
341
  }>, {
335
- as: string;
336
- offset: number;
337
- disabled: boolean;
338
- visible: boolean;
339
- placement: _hoci_core.Placement;
340
- triggerEvent: _hoci_core.TriggerEvent;
341
- lazy: boolean;
342
- teleport: string | boolean | HTMLElement;
343
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
344
-
345
- declare const HiSelection: vue.DefineComponent<vue.ExtractPropTypes<{
346
- as: {
347
- type: StringConstructor;
348
- default: string;
349
- };
350
- modelValue: {
351
- type: vue.PropType<any>;
352
- default: () => null;
353
- };
354
- activeClass: {
355
- type: vue.PropType<string | string[] | Record<string, boolean>>;
356
- default: string;
357
- };
358
- itemClass: {
359
- type: vue.PropType<string | string[] | Record<string, boolean>>;
360
- default: string;
361
- };
362
- disabledClass: {
363
- type: vue.PropType<string | string[] | Record<string, boolean>>;
364
- default: string;
365
- };
366
- unactiveClass: {
367
- type: vue.PropType<string | string[] | Record<string, boolean>>;
368
- default: string;
369
- };
370
- label: {
371
- type: vue.PropType<string | ((val?: any) => string) | null>;
372
- };
373
- multiple: {
374
- type: vue.PropType<boolean | number | [number, number?]>;
375
- default: () => false;
376
- };
377
- clearable: {
378
- type: BooleanConstructor;
379
- };
380
- defaultValue: {
381
- type: vue.PropType<any>;
382
- default: () => null;
383
- };
384
- activateEvent: {
385
- type: vue.PropType<_hoci_core.ActivateEvent>;
386
- };
387
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
388
- [key: string]: any;
389
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "load" | "update:modelValue" | "unload" | "reject")[], "change" | "load" | "update:modelValue" | "unload" | "reject", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
390
- as: {
391
- type: StringConstructor;
392
- default: string;
393
- };
394
- modelValue: {
395
- type: vue.PropType<any>;
396
- default: () => null;
397
- };
398
- activeClass: {
399
- type: vue.PropType<string | string[] | Record<string, boolean>>;
400
- default: string;
401
- };
402
- itemClass: {
403
- type: vue.PropType<string | string[] | Record<string, boolean>>;
404
- default: string;
405
- };
406
- disabledClass: {
407
- type: vue.PropType<string | string[] | Record<string, boolean>>;
408
- default: string;
409
- };
410
- unactiveClass: {
411
- type: vue.PropType<string | string[] | Record<string, boolean>>;
412
- default: string;
413
- };
414
- label: {
415
- type: vue.PropType<string | ((val?: any) => string) | null>;
416
- };
417
- multiple: {
418
- type: vue.PropType<boolean | number | [number, number?]>;
419
- default: () => false;
420
- };
421
- clearable: {
422
- type: BooleanConstructor;
423
- };
424
- defaultValue: {
425
- type: vue.PropType<any>;
426
- default: () => null;
427
- };
428
- activateEvent: {
429
- type: vue.PropType<_hoci_core.ActivateEvent>;
430
- };
342
+ as: string;
343
+ visible: boolean;
344
+ disabled: boolean;
345
+ offset: number;
346
+ placement: _hoci_core0.Placement;
347
+ triggerEvent: _hoci_core0.TriggerEvent;
348
+ lazy: boolean;
349
+ teleport: string | boolean | HTMLElement;
350
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
351
+ //#endregion
352
+ //#region ../core/src/selection/component.d.ts
353
+ declare const HiSelection: vue9.DefineComponent<vue9.ExtractPropTypes<{
354
+ as: {
355
+ type: StringConstructor;
356
+ default: string;
357
+ };
358
+ modelValue: {
359
+ type: vue9.PropType<any>;
360
+ default: () => null;
361
+ };
362
+ activeClass: {
363
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
364
+ default: string;
365
+ };
366
+ itemClass: {
367
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
368
+ default: string;
369
+ };
370
+ disabledClass: {
371
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
372
+ default: string;
373
+ };
374
+ unactiveClass: {
375
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
376
+ default: string;
377
+ };
378
+ label: {
379
+ type: vue9.PropType<string | ((val?: any) => string) | null>;
380
+ };
381
+ multiple: {
382
+ type: vue9.PropType<boolean | number | [number, number?]>;
383
+ default: () => false;
384
+ };
385
+ clearable: {
386
+ type: BooleanConstructor;
387
+ };
388
+ defaultValue: {
389
+ type: vue9.PropType<any>;
390
+ default: () => null;
391
+ };
392
+ activateEvent: {
393
+ type: vue9.PropType<_hoci_core0.ActivateEvent>;
394
+ };
395
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
396
+ [key: string]: any;
397
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, ("change" | "load" | "update:modelValue" | "reject" | "unload")[], "change" | "load" | "update:modelValue" | "reject" | "unload", vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
398
+ as: {
399
+ type: StringConstructor;
400
+ default: string;
401
+ };
402
+ modelValue: {
403
+ type: vue9.PropType<any>;
404
+ default: () => null;
405
+ };
406
+ activeClass: {
407
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
408
+ default: string;
409
+ };
410
+ itemClass: {
411
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
412
+ default: string;
413
+ };
414
+ disabledClass: {
415
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
416
+ default: string;
417
+ };
418
+ unactiveClass: {
419
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
420
+ default: string;
421
+ };
422
+ label: {
423
+ type: vue9.PropType<string | ((val?: any) => string) | null>;
424
+ };
425
+ multiple: {
426
+ type: vue9.PropType<boolean | number | [number, number?]>;
427
+ default: () => false;
428
+ };
429
+ clearable: {
430
+ type: BooleanConstructor;
431
+ };
432
+ defaultValue: {
433
+ type: vue9.PropType<any>;
434
+ default: () => null;
435
+ };
436
+ activateEvent: {
437
+ type: vue9.PropType<_hoci_core0.ActivateEvent>;
438
+ };
431
439
  }>> & Readonly<{
432
- onChange?: ((...args: any[]) => any) | undefined;
433
- onLoad?: ((...args: any[]) => any) | undefined;
434
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
435
- onUnload?: ((...args: any[]) => any) | undefined;
436
- onReject?: ((...args: any[]) => any) | undefined;
440
+ onChange?: ((...args: any[]) => any) | undefined;
441
+ onLoad?: ((...args: any[]) => any) | undefined;
442
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
443
+ onReject?: ((...args: any[]) => any) | undefined;
444
+ onUnload?: ((...args: any[]) => any) | undefined;
437
445
  }>, {
438
- as: string;
439
- modelValue: any;
440
- multiple: number | boolean | [number, (number | undefined)?];
441
- activeClass: string | string[] | Record<string, boolean>;
442
- itemClass: string | string[] | Record<string, boolean>;
443
- disabledClass: string | string[] | Record<string, boolean>;
444
- unactiveClass: string | string[] | Record<string, boolean>;
445
- clearable: boolean;
446
- defaultValue: any;
447
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
448
-
449
- declare const HiSwitch: vue.DefineComponent<vue.ExtractPropTypes<{
450
- as: {
451
- type: StringConstructor;
452
- default: string;
453
- };
454
- modelValue: {
455
- type: BooleanConstructor;
456
- default: () => false;
457
- };
458
- class: {
459
- type: vue.PropType<string | string[] | Record<string, boolean>>;
460
- };
461
- activeClass: {
462
- type: vue.PropType<string | string[] | Record<string, boolean>>;
463
- };
464
- unactiveClass: {
465
- type: vue.PropType<string | string[] | Record<string, boolean>>;
466
- };
467
- activateEvent: {
468
- type: vue.PropType<_hoci_core.ActivateEvent>;
469
- };
470
- disabled: {
471
- type: BooleanConstructor;
472
- default: () => false;
473
- };
474
- disabledClass: {
475
- type: vue.PropType<string | string[] | Record<string, boolean>>;
476
- };
477
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
478
- [key: string]: any;
479
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:modelValue" | "reject")[], "change" | "update:modelValue" | "reject", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
480
- as: {
481
- type: StringConstructor;
482
- default: string;
483
- };
484
- modelValue: {
485
- type: BooleanConstructor;
486
- default: () => false;
487
- };
488
- class: {
489
- type: vue.PropType<string | string[] | Record<string, boolean>>;
490
- };
491
- activeClass: {
492
- type: vue.PropType<string | string[] | Record<string, boolean>>;
493
- };
494
- unactiveClass: {
495
- type: vue.PropType<string | string[] | Record<string, boolean>>;
496
- };
497
- activateEvent: {
498
- type: vue.PropType<_hoci_core.ActivateEvent>;
499
- };
500
- disabled: {
501
- type: BooleanConstructor;
502
- default: () => false;
503
- };
504
- disabledClass: {
505
- type: vue.PropType<string | string[] | Record<string, boolean>>;
506
- };
446
+ as: string;
447
+ multiple: number | boolean | [number, (number | undefined)?];
448
+ modelValue: any;
449
+ activeClass: string | string[] | Record<string, boolean>;
450
+ itemClass: string | string[] | Record<string, boolean>;
451
+ disabledClass: string | string[] | Record<string, boolean>;
452
+ unactiveClass: string | string[] | Record<string, boolean>;
453
+ clearable: boolean;
454
+ defaultValue: any;
455
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
456
+ //#endregion
457
+ //#region ../core/src/switch/component.d.ts
458
+ declare const HiSwitch: vue9.DefineComponent<vue9.ExtractPropTypes<{
459
+ as: {
460
+ type: StringConstructor;
461
+ default: string;
462
+ };
463
+ modelValue: {
464
+ type: BooleanConstructor;
465
+ default: () => false;
466
+ };
467
+ class: {
468
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
469
+ };
470
+ activeClass: {
471
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
472
+ };
473
+ unactiveClass: {
474
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
475
+ };
476
+ activateEvent: {
477
+ type: vue9.PropType<_hoci_core0.ActivateEvent>;
478
+ };
479
+ disabled: {
480
+ type: BooleanConstructor;
481
+ default: () => false;
482
+ };
483
+ disabledClass: {
484
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
485
+ };
486
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
487
+ [key: string]: any;
488
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, ("change" | "update:modelValue" | "reject")[], "change" | "update:modelValue" | "reject", vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
489
+ as: {
490
+ type: StringConstructor;
491
+ default: string;
492
+ };
493
+ modelValue: {
494
+ type: BooleanConstructor;
495
+ default: () => false;
496
+ };
497
+ class: {
498
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
499
+ };
500
+ activeClass: {
501
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
502
+ };
503
+ unactiveClass: {
504
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
505
+ };
506
+ activateEvent: {
507
+ type: vue9.PropType<_hoci_core0.ActivateEvent>;
508
+ };
509
+ disabled: {
510
+ type: BooleanConstructor;
511
+ default: () => false;
512
+ };
513
+ disabledClass: {
514
+ type: vue9.PropType<string | string[] | Record<string, boolean>>;
515
+ };
507
516
  }>> & Readonly<{
508
- onChange?: ((...args: any[]) => any) | undefined;
509
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
510
- onReject?: ((...args: any[]) => any) | undefined;
517
+ onChange?: ((...args: any[]) => any) | undefined;
518
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
519
+ onReject?: ((...args: any[]) => any) | undefined;
511
520
  }>, {
512
- as: string;
513
- modelValue: boolean;
514
- disabled: boolean;
515
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
516
-
517
- declare const HiTabPane: vue.DefineComponent<vue.ExtractPropTypes<{
518
- value: {
519
- type: vue.PropType<any>;
520
- default(): string;
521
- };
522
- label: {
523
- type: vue.PropType<string | ((val: any) => string) | _hoci_shared.ElementLike | null>;
524
- };
525
- keepAlive: {
526
- type: BooleanConstructor;
527
- default: () => true;
528
- };
529
- activateEvent: {
530
- type: vue.PropType<_hoci_shared.ActivateEvent>;
531
- };
532
- disabled: {
533
- type: BooleanConstructor;
534
- default: boolean;
535
- };
536
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
537
- [key: string]: any;
538
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "reject"[], "reject", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
539
- value: {
540
- type: vue.PropType<any>;
541
- default(): string;
542
- };
543
- label: {
544
- type: vue.PropType<string | ((val: any) => string) | _hoci_shared.ElementLike | null>;
545
- };
546
- keepAlive: {
547
- type: BooleanConstructor;
548
- default: () => true;
549
- };
550
- activateEvent: {
551
- type: vue.PropType<_hoci_shared.ActivateEvent>;
552
- };
553
- disabled: {
554
- type: BooleanConstructor;
555
- default: boolean;
556
- };
521
+ as: string;
522
+ disabled: boolean;
523
+ modelValue: boolean;
524
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
525
+ //#endregion
526
+ //#region ../core/src/tab-pane/component.d.ts
527
+ declare const HiTabPane: vue9.DefineComponent<vue9.ExtractPropTypes<{
528
+ value: {
529
+ type: vue9.PropType<any>;
530
+ default(): string;
531
+ };
532
+ label: {
533
+ type: vue9.PropType<string | ((val: any) => string) | _hoci_shared0.ElementLike | null>;
534
+ };
535
+ keepAlive: {
536
+ type: BooleanConstructor;
537
+ default: () => true;
538
+ };
539
+ activateEvent: {
540
+ type: vue9.PropType<_hoci_shared0.ActivateEvent>;
541
+ };
542
+ disabled: {
543
+ type: BooleanConstructor;
544
+ default: boolean;
545
+ };
546
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
547
+ [key: string]: any;
548
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, "reject"[], "reject", vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
549
+ value: {
550
+ type: vue9.PropType<any>;
551
+ default(): string;
552
+ };
553
+ label: {
554
+ type: vue9.PropType<string | ((val: any) => string) | _hoci_shared0.ElementLike | null>;
555
+ };
556
+ keepAlive: {
557
+ type: BooleanConstructor;
558
+ default: () => true;
559
+ };
560
+ activateEvent: {
561
+ type: vue9.PropType<_hoci_shared0.ActivateEvent>;
562
+ };
563
+ disabled: {
564
+ type: BooleanConstructor;
565
+ default: boolean;
566
+ };
557
567
  }>> & Readonly<{
558
- onReject?: ((...args: any[]) => any) | undefined;
568
+ onReject?: ((...args: any[]) => any) | undefined;
559
569
  }>, {
560
- value: any;
561
- disabled: boolean;
562
- keepAlive: boolean;
563
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
564
-
565
- declare const HiTabs: vue.DefineComponent<vue.ExtractPropTypes<{
566
- headerClass: {
567
- type: PropType<string | string[] | Record<string, boolean>>;
568
- };
569
- as: {
570
- type: StringConstructor;
571
- default: string;
572
- };
573
- headerAs: {
574
- type: StringConstructor;
575
- default: string;
576
- };
577
- contentAs: {
578
- type: StringConstructor;
579
- default: string;
580
- };
581
- contentClass: {
582
- type: PropType<string | string[] | Record<string, boolean>>;
583
- };
584
- keepAlive: {
585
- type: PropType<boolean | KeepAliveProps>;
586
- default: boolean;
587
- };
588
- modelValue: {
589
- type: PropType<any>;
590
- default: () => null;
591
- };
592
- activeClass: {
593
- type: PropType<string | string[] | Record<string, boolean>>;
594
- default: string;
595
- };
596
- itemClass: {
597
- type: PropType<string | string[] | Record<string, boolean>>;
598
- default: string;
599
- };
600
- disabledClass: {
601
- type: PropType<string | string[] | Record<string, boolean>>;
602
- default: string;
603
- };
604
- unactiveClass: {
605
- type: PropType<string | string[] | Record<string, boolean>>;
606
- default: string;
607
- };
608
- label: {
609
- type: PropType<string | ((val?: any) => string) | null>;
610
- };
611
- multiple: {
612
- type: PropType<boolean | number | [number, number?]>;
613
- default: () => false;
614
- };
615
- clearable: {
616
- type: BooleanConstructor;
617
- };
618
- defaultValue: {
619
- type: PropType<any>;
620
- default: () => null;
621
- };
622
- activateEvent: {
623
- type: PropType<_hoci_shared.ActivateEvent>;
624
- };
625
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
626
- [key: string]: any;
627
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
628
- headerClass: {
629
- type: PropType<string | string[] | Record<string, boolean>>;
630
- };
631
- as: {
632
- type: StringConstructor;
633
- default: string;
634
- };
635
- headerAs: {
636
- type: StringConstructor;
637
- default: string;
638
- };
639
- contentAs: {
640
- type: StringConstructor;
641
- default: string;
642
- };
643
- contentClass: {
644
- type: PropType<string | string[] | Record<string, boolean>>;
645
- };
646
- keepAlive: {
647
- type: PropType<boolean | KeepAliveProps>;
648
- default: boolean;
649
- };
650
- modelValue: {
651
- type: PropType<any>;
652
- default: () => null;
653
- };
654
- activeClass: {
655
- type: PropType<string | string[] | Record<string, boolean>>;
656
- default: string;
657
- };
658
- itemClass: {
659
- type: PropType<string | string[] | Record<string, boolean>>;
660
- default: string;
661
- };
662
- disabledClass: {
663
- type: PropType<string | string[] | Record<string, boolean>>;
664
- default: string;
665
- };
666
- unactiveClass: {
667
- type: PropType<string | string[] | Record<string, boolean>>;
668
- default: string;
669
- };
670
- label: {
671
- type: PropType<string | ((val?: any) => string) | null>;
672
- };
673
- multiple: {
674
- type: PropType<boolean | number | [number, number?]>;
675
- default: () => false;
676
- };
677
- clearable: {
678
- type: BooleanConstructor;
679
- };
680
- defaultValue: {
681
- type: PropType<any>;
682
- default: () => null;
683
- };
684
- activateEvent: {
685
- type: PropType<_hoci_shared.ActivateEvent>;
686
- };
570
+ disabled: boolean;
571
+ value: any;
572
+ keepAlive: boolean;
573
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
574
+ //#endregion
575
+ //#region ../core/src/tabs/component.d.ts
576
+ declare const HiTabs: vue9.DefineComponent<vue9.ExtractPropTypes<{
577
+ headerClass: {
578
+ type: PropType<string | string[] | Record<string, boolean>>;
579
+ };
580
+ as: {
581
+ type: StringConstructor;
582
+ default: string;
583
+ };
584
+ headerAs: {
585
+ type: StringConstructor;
586
+ default: string;
587
+ };
588
+ contentAs: {
589
+ type: StringConstructor;
590
+ default: string;
591
+ };
592
+ contentClass: {
593
+ type: PropType<string | string[] | Record<string, boolean>>;
594
+ };
595
+ keepAlive: {
596
+ type: PropType<boolean | KeepAliveProps>;
597
+ default: boolean;
598
+ };
599
+ modelValue: {
600
+ type: PropType<any>;
601
+ default: () => null;
602
+ };
603
+ activeClass: {
604
+ type: PropType<string | string[] | Record<string, boolean>>;
605
+ default: string;
606
+ };
607
+ itemClass: {
608
+ type: PropType<string | string[] | Record<string, boolean>>;
609
+ default: string;
610
+ };
611
+ disabledClass: {
612
+ type: PropType<string | string[] | Record<string, boolean>>;
613
+ default: string;
614
+ };
615
+ unactiveClass: {
616
+ type: PropType<string | string[] | Record<string, boolean>>;
617
+ default: string;
618
+ };
619
+ label: {
620
+ type: PropType<string | ((val?: any) => string) | null>;
621
+ };
622
+ multiple: {
623
+ type: PropType<boolean | number | [number, number?]>;
624
+ default: () => false;
625
+ };
626
+ clearable: {
627
+ type: BooleanConstructor;
628
+ };
629
+ defaultValue: {
630
+ type: PropType<any>;
631
+ default: () => null;
632
+ };
633
+ activateEvent: {
634
+ type: PropType<_hoci_shared0.ActivateEvent>;
635
+ };
636
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
637
+ [key: string]: any;
638
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {}, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
639
+ headerClass: {
640
+ type: PropType<string | string[] | Record<string, boolean>>;
641
+ };
642
+ as: {
643
+ type: StringConstructor;
644
+ default: string;
645
+ };
646
+ headerAs: {
647
+ type: StringConstructor;
648
+ default: string;
649
+ };
650
+ contentAs: {
651
+ type: StringConstructor;
652
+ default: string;
653
+ };
654
+ contentClass: {
655
+ type: PropType<string | string[] | Record<string, boolean>>;
656
+ };
657
+ keepAlive: {
658
+ type: PropType<boolean | KeepAliveProps>;
659
+ default: boolean;
660
+ };
661
+ modelValue: {
662
+ type: PropType<any>;
663
+ default: () => null;
664
+ };
665
+ activeClass: {
666
+ type: PropType<string | string[] | Record<string, boolean>>;
667
+ default: string;
668
+ };
669
+ itemClass: {
670
+ type: PropType<string | string[] | Record<string, boolean>>;
671
+ default: string;
672
+ };
673
+ disabledClass: {
674
+ type: PropType<string | string[] | Record<string, boolean>>;
675
+ default: string;
676
+ };
677
+ unactiveClass: {
678
+ type: PropType<string | string[] | Record<string, boolean>>;
679
+ default: string;
680
+ };
681
+ label: {
682
+ type: PropType<string | ((val?: any) => string) | null>;
683
+ };
684
+ multiple: {
685
+ type: PropType<boolean | number | [number, number?]>;
686
+ default: () => false;
687
+ };
688
+ clearable: {
689
+ type: BooleanConstructor;
690
+ };
691
+ defaultValue: {
692
+ type: PropType<any>;
693
+ default: () => null;
694
+ };
695
+ activateEvent: {
696
+ type: PropType<_hoci_shared0.ActivateEvent>;
697
+ };
687
698
  }>> & Readonly<{}>, {
688
- as: string;
689
- modelValue: any;
690
- multiple: number | boolean | [number, (number | undefined)?];
691
- activeClass: string | string[] | Record<string, boolean>;
692
- itemClass: string | string[] | Record<string, boolean>;
693
- disabledClass: string | string[] | Record<string, boolean>;
694
- unactiveClass: string | string[] | Record<string, boolean>;
695
- clearable: boolean;
696
- defaultValue: any;
697
- keepAlive: boolean | KeepAliveProps;
698
- headerAs: string;
699
- contentAs: string;
700
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
701
-
702
- type VirtualizerOptions<TScrollElement extends Element, TItemElement extends Element = Element> = PartialKeys<VirtualizerOptions$1<TScrollElement, TItemElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement" | "initialOffset">;
703
-
704
- declare const HiVirtualList: vue.DefineComponent<vue.ExtractPropTypes<{
705
- as: {
706
- type: StringConstructor;
707
- default: () => string;
708
- };
709
- wrapperAs: {
710
- type: StringConstructor;
711
- default: () => string;
712
- };
713
- wrapperStyle: {
714
- type: PropType<CSSProperties>;
715
- default: () => {};
716
- };
717
- wrapperClass: {
718
- type: PropType<string | string[] | Record<string, boolean>>;
719
- default: () => string;
720
- };
721
- options: {
722
- type: PropType<_tanstack_virtual_core.PartialKeys<VirtualizerOptions<HTMLElement, HTMLElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement">>;
723
- default: () => {};
724
- };
725
- count: {
726
- type: NumberConstructor;
727
- default: () => 0;
728
- };
729
- estimateSize: {
730
- type: PropType<((index: number) => number) | number>;
731
- default: () => 50;
732
- };
733
- horizontal: {
734
- type: BooleanConstructor;
735
- default: () => false;
736
- };
737
- }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
738
- [key: string]: any;
739
- }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
740
- scrollEnd: () => boolean;
741
- scrollStart: () => boolean;
742
- scroll: (_: number[]) => boolean;
743
- }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
744
- as: {
745
- type: StringConstructor;
746
- default: () => string;
747
- };
748
- wrapperAs: {
749
- type: StringConstructor;
750
- default: () => string;
751
- };
752
- wrapperStyle: {
753
- type: PropType<CSSProperties>;
754
- default: () => {};
755
- };
756
- wrapperClass: {
757
- type: PropType<string | string[] | Record<string, boolean>>;
758
- default: () => string;
759
- };
760
- options: {
761
- type: PropType<_tanstack_virtual_core.PartialKeys<VirtualizerOptions<HTMLElement, HTMLElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement">>;
762
- default: () => {};
763
- };
764
- count: {
765
- type: NumberConstructor;
766
- default: () => 0;
767
- };
768
- estimateSize: {
769
- type: PropType<((index: number) => number) | number>;
770
- default: () => 50;
771
- };
772
- horizontal: {
773
- type: BooleanConstructor;
774
- default: () => false;
775
- };
699
+ as: string;
700
+ multiple: number | boolean | [number, (number | undefined)?];
701
+ modelValue: any;
702
+ keepAlive: boolean | KeepAliveProps;
703
+ activeClass: string | string[] | Record<string, boolean>;
704
+ itemClass: string | string[] | Record<string, boolean>;
705
+ disabledClass: string | string[] | Record<string, boolean>;
706
+ unactiveClass: string | string[] | Record<string, boolean>;
707
+ clearable: boolean;
708
+ defaultValue: any;
709
+ headerAs: string;
710
+ contentAs: string;
711
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
712
+ //#endregion
713
+ //#region ../core/src/virtual-list/index.d.ts
714
+ type VirtualizerOptions$1<TScrollElement extends Element, TItemElement extends Element = Element> = PartialKeys<VirtualizerOptions<TScrollElement, TItemElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement" | "initialOffset">;
715
+ //#endregion
716
+ //#region ../core/src/virtual-list/component.d.ts
717
+ declare const HiVirtualList: vue9.DefineComponent<vue9.ExtractPropTypes<{
718
+ as: {
719
+ type: StringConstructor;
720
+ default: () => string;
721
+ };
722
+ wrapperAs: {
723
+ type: StringConstructor;
724
+ default: () => string;
725
+ };
726
+ wrapperStyle: {
727
+ type: PropType<CSSProperties>;
728
+ default: () => {};
729
+ };
730
+ wrapperClass: {
731
+ type: PropType<string | string[] | Record<string, boolean>>;
732
+ default: () => string;
733
+ };
734
+ options: {
735
+ type: PropType<_tanstack_virtual_core0.PartialKeys<VirtualizerOptions$1<HTMLElement, HTMLElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement">>;
736
+ default: () => {};
737
+ };
738
+ count: {
739
+ type: NumberConstructor;
740
+ default: () => 0;
741
+ };
742
+ estimateSize: {
743
+ type: PropType<((index: number) => number) | number>;
744
+ default: () => 50;
745
+ };
746
+ horizontal: {
747
+ type: BooleanConstructor;
748
+ default: () => false;
749
+ };
750
+ }>, () => vue9.VNode<vue9.RendererNode, vue9.RendererElement, {
751
+ [key: string]: any;
752
+ }>, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {
753
+ scrollEnd: () => boolean;
754
+ scrollStart: () => boolean;
755
+ scroll: (_: number[]) => boolean;
756
+ }, string, vue9.PublicProps, Readonly<vue9.ExtractPropTypes<{
757
+ as: {
758
+ type: StringConstructor;
759
+ default: () => string;
760
+ };
761
+ wrapperAs: {
762
+ type: StringConstructor;
763
+ default: () => string;
764
+ };
765
+ wrapperStyle: {
766
+ type: PropType<CSSProperties>;
767
+ default: () => {};
768
+ };
769
+ wrapperClass: {
770
+ type: PropType<string | string[] | Record<string, boolean>>;
771
+ default: () => string;
772
+ };
773
+ options: {
774
+ type: PropType<_tanstack_virtual_core0.PartialKeys<VirtualizerOptions$1<HTMLElement, HTMLElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement">>;
775
+ default: () => {};
776
+ };
777
+ count: {
778
+ type: NumberConstructor;
779
+ default: () => 0;
780
+ };
781
+ estimateSize: {
782
+ type: PropType<((index: number) => number) | number>;
783
+ default: () => 50;
784
+ };
785
+ horizontal: {
786
+ type: BooleanConstructor;
787
+ default: () => false;
788
+ };
776
789
  }>> & Readonly<{
777
- onScroll?: ((_: number[]) => any) | undefined;
778
- onScrollEnd?: (() => any) | undefined;
779
- onScrollStart?: (() => any) | undefined;
790
+ onScrollEnd?: (() => any) | undefined;
791
+ onScrollStart?: (() => any) | undefined;
792
+ onScroll?: ((_: number[]) => any) | undefined;
780
793
  }>, {
781
- as: string;
782
- horizontal: boolean;
783
- options: _tanstack_virtual_core.PartialKeys<VirtualizerOptions<HTMLElement, HTMLElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement">;
784
- count: number;
785
- estimateSize: number | ((index: number) => number);
786
- wrapperAs: string;
787
- wrapperStyle: CSSProperties;
788
- wrapperClass: string | string[] | Record<string, boolean>;
789
- }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
790
-
794
+ options: _tanstack_virtual_core0.PartialKeys<VirtualizerOptions$1<HTMLElement, HTMLElement>, "observeElementRect" | "observeElementOffset" | "scrollToFn" | "getScrollElement">;
795
+ count: number;
796
+ estimateSize: number | ((index: number) => number);
797
+ horizontal: boolean;
798
+ as: string;
799
+ wrapperAs: string;
800
+ wrapperStyle: CSSProperties;
801
+ wrapperClass: string | string[] | Record<string, boolean>;
802
+ }, {}, {}, {}, string, vue9.ComponentProvideOptions, true, {}, any>;
803
+ //#endregion
804
+ //#region install.d.ts
791
805
  declare function install(app: App): void;
792
-
793
- export { HiAffix, HiAffixTarget, HiConfigProvider, HiFileUpload, HiIcon, HiItem, HiPopover, HiSelection, HiSwitch, HiTabPane, HiTabs, HiVirtualList, install };
806
+ //#endregion
807
+ export { HiAffix, HiAffixTarget, HiConfigProvider, HiFileUpload, HiIcon, HiItem, HiPopover, HiSelection, HiSwitch, HiTabPane, HiTabs, HiVirtualList, install };