@opentiny/tiny-robot 0.2.14 → 0.2.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.ts CHANGED
@@ -1,6 +1,5 @@
1
1
  import { AllowedComponentProps } from 'vue';
2
2
  import { App } from 'vue';
3
- import { AutoSize as AutoSize_2 } from './index.type';
4
3
  import { BubblePalcement as BubblePalcement_2 } from './index.type';
5
4
  import { Component } from 'vue';
6
5
  import { ComponentCustomProperties } from 'vue';
@@ -14,24 +13,18 @@ import { ComputedRef } from 'vue';
14
13
  import { CreateComponentPublicInstanceWithMixins } from 'vue';
15
14
  import { CSSProperties } from 'vue';
16
15
  import { DebuggerEvent } from 'vue';
16
+ import { default as default_2 } from './index.vue';
17
17
  import { DefineComponent } from 'vue';
18
- import { ExtractPropTypes } from 'vue';
19
18
  import { GlobalComponents } from 'vue';
20
19
  import { GlobalDirectives } from 'vue';
21
- import { InputMode as InputMode_2 } from './index.type';
22
20
  import { MaybeElement } from '@vueuse/core';
23
21
  import { nextTick } from 'vue';
24
22
  import { OnCleanup } from '@vue/reactivity';
25
23
  import { Options } from 'markdown-it';
26
- import { PropType } from 'vue';
27
24
  import { PublicProps } from 'vue';
28
25
  import { Ref } from 'vue';
29
- import { RendererElement } from 'vue';
30
- import { RendererNode } from 'vue';
31
26
  import { ShallowUnwrapRef } from 'vue';
32
27
  import { Slot } from 'vue';
33
- import { SubmitTrigger as SubmitTrigger_2 } from './index.type';
34
- import { ThemeType as ThemeType_2 } from './index.type';
35
28
  import { TooltipContentProps } from './components/Tooltip.vue';
36
29
  import { TransitionProps } from 'vue';
37
30
  import { VNode } from 'vue';
@@ -155,9 +148,11 @@ popperRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
155
148
  $slots: Readonly<{
156
149
  trigger?: () => VNode[];
157
150
  content?: () => VNode[];
151
+ backdrop?: () => VNode[];
158
152
  }> & {
159
153
  trigger?: () => VNode[];
160
154
  content?: () => VNode[];
155
+ backdrop?: () => VNode[];
161
156
  };
162
157
  }) | null;
163
158
  }, any>;
@@ -168,529 +163,9 @@ declare const __VLS_component_4: DefineComponent<PromptsProps, {}, {}, {}, {}, C
168
163
  "onItem-click"?: ((ev: MouseEvent, item: PromptProps) => any) | undefined;
169
164
  }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
170
165
 
171
- declare const __VLS_component_5: DefineComponent<SenderProps, {
172
- focus: () => void;
173
- blur: () => void;
174
- clear: () => void;
175
- submit: () => void;
176
- startSpeech: () => void;
177
- stopSpeech: () => void;
178
- activateTemplateFirstField: () => void;
179
- }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
180
- [x: string]: any;
181
- } & {
182
- [x: string]: any;
183
- }, string, PublicProps, Readonly<SenderProps> & Readonly<{
184
- [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
185
- }>, {
186
- loading: boolean;
187
- mode: InputMode_2;
188
- disabled: boolean;
189
- modelValue: string;
190
- autofocus: boolean;
191
- clearable: boolean;
192
- showWordLimit: boolean;
193
- allowSpeech: boolean;
194
- allowFiles: boolean;
195
- submitType: SubmitTrigger_2;
196
- stopText: string;
197
- autoSize: AutoSize_2;
198
- maxLength: number;
199
- placeholder: string;
200
- suggestions: string[];
201
- suggestionPopupWidth: string | number;
202
- theme: ThemeType_2;
203
- templateData: UserItem[];
204
- }, {}, {}, {}, string, ComponentProvideOptions, false, {
205
- senderRef: HTMLDivElement;
206
- inputWrapperRef: HTMLDivElement;
207
- templateEditorRef: CreateComponentPublicInstanceWithMixins<Readonly<{
208
- modelValue?: UserItem[];
209
- }> & Readonly<{
210
- "onUpdate:modelValue"?: ((value: UserItem[]) => any) | undefined;
211
- onSubmit?: (() => any) | undefined;
212
- }>, {
213
- clearHistory: () => void;
214
- activateFirstField: () => void;
215
- }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
216
- "update:modelValue": (value: UserItem[]) => any;
217
- } & {
218
- submit: () => any;
219
- }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
220
- editorRef: HTMLDivElement;
221
- }, HTMLDivElement, ComponentProvideOptions, {
222
- P: {};
223
- B: {};
224
- D: {};
225
- C: {};
226
- M: {};
227
- Defaults: {};
228
- }, Readonly<{
229
- modelValue?: UserItem[];
230
- }> & Readonly<{
231
- "onUpdate:modelValue"?: ((value: UserItem[]) => any) | undefined;
232
- onSubmit?: (() => any) | undefined;
233
- }>, {
234
- clearHistory: () => void;
235
- activateFirstField: () => void;
236
- }, {}, {}, {}, {}> | null;
237
- inputRef: CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes< {
238
- _constants: {
239
- type: ObjectConstructor;
240
- default: () => {
241
- INPUT_PC: string;
242
- INPUTGROUP_PC: string;
243
- INPUT_MOBILE: string;
244
- INPUTGROUP_MOBILE: string;
245
- Mode: string;
246
- inputMode(mode: any): string;
247
- inputGroupMode(mode: any): string;
248
- VALIDATE_ICON: {
249
- Validating: string;
250
- Success: string;
251
- Error: string;
252
- };
253
- COMPONENT_NAME: {
254
- FormItem: string;
255
- };
256
- MASKSYMBOL: string;
257
- TEXTAREA_HEIGHT_MOBILE: number;
258
- };
259
- };
260
- name: StringConstructor;
261
- size: StringConstructor;
262
- form: StringConstructor;
263
- label: StringConstructor;
264
- height: NumberConstructor;
265
- resize: StringConstructor;
266
- tabindex: {
267
- type: StringConstructor;
268
- default: string;
269
- };
270
- disabled: BooleanConstructor;
271
- readonly: BooleanConstructor;
272
- hoverExpand: BooleanConstructor;
273
- mask: BooleanConstructor;
274
- suffixIcon: (StringConstructor | ObjectConstructor)[];
275
- prefixIcon: (StringConstructor | ObjectConstructor)[];
276
- modelValue: PropType<string | number | null>;
277
- type: {
278
- type: StringConstructor;
279
- default: string;
280
- };
281
- memorySpace: {
282
- type: NumberConstructor;
283
- default: number;
284
- };
285
- vertical: {
286
- type: BooleanConstructor;
287
- default: boolean;
288
- };
289
- selectMenu: {
290
- type: {
291
- (arrayLength: number): {
292
- id: string;
293
- label: string;
294
- }[];
295
- (...items: {
296
- id: string;
297
- label: string;
298
- }[]): {
299
- id: string;
300
- label: string;
301
- }[];
302
- new (arrayLength: number): {
303
- id: string;
304
- label: string;
305
- }[];
306
- new (...items: {
307
- id: string;
308
- label: string;
309
- }[]): {
310
- id: string;
311
- label: string;
312
- }[];
313
- isArray(arg: any): arg is any[];
314
- readonly prototype: any[];
315
- from<T>(arrayLike: ArrayLike<T>): T[];
316
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
317
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
318
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
319
- of<T_4>(...items: T_4[]): T_4[];
320
- readonly [Symbol.species]: ArrayConstructor;
321
- };
322
- default: () => never[];
323
- };
324
- ellipsis: {
325
- type: BooleanConstructor;
326
- default: boolean;
327
- };
328
- contentStyle: {
329
- type: ObjectConstructor;
330
- default: () => {};
331
- };
332
- isSelect: {
333
- type: BooleanConstructor;
334
- default: boolean;
335
- };
336
- tips: StringConstructor;
337
- counter: {
338
- type: BooleanConstructor;
339
- default: boolean;
340
- };
341
- autosize: {
342
- type: (BooleanConstructor | ObjectConstructor)[];
343
- default: boolean;
344
- };
345
- clearable: {
346
- type: BooleanConstructor;
347
- default: boolean;
348
- };
349
- autocomplete: {
350
- type: StringConstructor;
351
- default: string;
352
- };
353
- showPassword: {
354
- type: BooleanConstructor;
355
- default: boolean;
356
- };
357
- showWordLimit: {
358
- type: BooleanConstructor;
359
- default: boolean;
360
- };
361
- showTitle: {
362
- type: BooleanConstructor;
363
- default: boolean;
364
- };
365
- validateEvent: {
366
- type: BooleanConstructor;
367
- default: boolean;
368
- };
369
- popupMore: {
370
- type: BooleanConstructor;
371
- default: boolean;
372
- };
373
- textareaTitle: {
374
- type: StringConstructor;
375
- default: string;
376
- };
377
- displayOnly: {
378
- type: BooleanConstructor;
379
- default: boolean;
380
- };
381
- displayOnlyContent: {
382
- type: StringConstructor;
383
- default: string;
384
- };
385
- customClass: {
386
- type: StringConstructor;
387
- default: string;
388
- };
389
- frontClearIcon: {
390
- type: BooleanConstructor;
391
- default: boolean;
392
- };
393
- showEmptyValue: {
394
- type: BooleanConstructor;
395
- default: undefined;
396
- };
397
- textAlign: {
398
- type: StringConstructor;
399
- default: string;
400
- };
401
- width: {
402
- type: PropType<string | number | null>;
403
- };
404
- showTooltip: {
405
- type: BooleanConstructor;
406
- default: boolean;
407
- };
408
- inputBoxType: {
409
- type: StringConstructor;
410
- default: string;
411
- validator: (value: string) => boolean;
412
- };
413
- tiny_mode: StringConstructor;
414
- tiny_mode_root: BooleanConstructor;
415
- tiny_template: (ObjectConstructor | FunctionConstructor)[];
416
- tiny_renderless: FunctionConstructor;
417
- tiny_theme: StringConstructor;
418
- tiny_mcp_config: ObjectConstructor;
419
- tiny_chart_theme: ObjectConstructor;
420
- }>>, () => VNode<RendererNode, RendererElement, {
421
- [key: string]: any;
422
- }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
423
- disabled: boolean;
424
- type: string;
425
- ellipsis: boolean;
426
- mask: boolean;
427
- vertical: boolean;
428
- customClass: string;
429
- tiny_mode_root: boolean;
430
- _constants: Record<string, any>;
431
- tabindex: string;
432
- showTitle: boolean;
433
- readonly: boolean;
434
- hoverExpand: boolean;
435
- memorySpace: number;
436
- selectMenu: {
437
- id: string;
438
- label: string;
439
- }[];
440
- contentStyle: Record<string, any>;
441
- isSelect: boolean;
442
- counter: boolean;
443
- autosize: boolean | Record<string, any>;
444
- clearable: boolean;
445
- autocomplete: string;
446
- showPassword: boolean;
447
- showWordLimit: boolean;
448
- validateEvent: boolean;
449
- popupMore: boolean;
450
- textareaTitle: string;
451
- displayOnly: boolean;
452
- displayOnlyContent: string;
453
- frontClearIcon: boolean;
454
- showEmptyValue: boolean;
455
- textAlign: string;
456
- showTooltip: boolean;
457
- inputBoxType: string;
458
- }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
459
- P: {};
460
- B: {};
461
- D: {};
462
- C: {};
463
- M: {};
464
- Defaults: {};
465
- }, Readonly<ExtractPropTypes< {
466
- _constants: {
467
- type: ObjectConstructor;
468
- default: () => {
469
- INPUT_PC: string;
470
- INPUTGROUP_PC: string;
471
- INPUT_MOBILE: string;
472
- INPUTGROUP_MOBILE: string;
473
- Mode: string;
474
- inputMode(mode: any): string;
475
- inputGroupMode(mode: any): string;
476
- VALIDATE_ICON: {
477
- Validating: string;
478
- Success: string;
479
- Error: string;
480
- };
481
- COMPONENT_NAME: {
482
- FormItem: string;
483
- };
484
- MASKSYMBOL: string;
485
- TEXTAREA_HEIGHT_MOBILE: number;
486
- };
487
- };
488
- name: StringConstructor;
489
- size: StringConstructor;
490
- form: StringConstructor;
491
- label: StringConstructor;
492
- height: NumberConstructor;
493
- resize: StringConstructor;
494
- tabindex: {
495
- type: StringConstructor;
496
- default: string;
497
- };
498
- disabled: BooleanConstructor;
499
- readonly: BooleanConstructor;
500
- hoverExpand: BooleanConstructor;
501
- mask: BooleanConstructor;
502
- suffixIcon: (StringConstructor | ObjectConstructor)[];
503
- prefixIcon: (StringConstructor | ObjectConstructor)[];
504
- modelValue: PropType<string | number | null>;
505
- type: {
506
- type: StringConstructor;
507
- default: string;
508
- };
509
- memorySpace: {
510
- type: NumberConstructor;
511
- default: number;
512
- };
513
- vertical: {
514
- type: BooleanConstructor;
515
- default: boolean;
516
- };
517
- selectMenu: {
518
- type: {
519
- (arrayLength: number): {
520
- id: string;
521
- label: string;
522
- }[];
523
- (...items: {
524
- id: string;
525
- label: string;
526
- }[]): {
527
- id: string;
528
- label: string;
529
- }[];
530
- new (arrayLength: number): {
531
- id: string;
532
- label: string;
533
- }[];
534
- new (...items: {
535
- id: string;
536
- label: string;
537
- }[]): {
538
- id: string;
539
- label: string;
540
- }[];
541
- isArray(arg: any): arg is any[];
542
- readonly prototype: any[];
543
- from<T>(arrayLike: ArrayLike<T>): T[];
544
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
545
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
546
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
547
- of<T_4>(...items: T_4[]): T_4[];
548
- readonly [Symbol.species]: ArrayConstructor;
549
- };
550
- default: () => never[];
551
- };
552
- ellipsis: {
553
- type: BooleanConstructor;
554
- default: boolean;
555
- };
556
- contentStyle: {
557
- type: ObjectConstructor;
558
- default: () => {};
559
- };
560
- isSelect: {
561
- type: BooleanConstructor;
562
- default: boolean;
563
- };
564
- tips: StringConstructor;
565
- counter: {
566
- type: BooleanConstructor;
567
- default: boolean;
568
- };
569
- autosize: {
570
- type: (BooleanConstructor | ObjectConstructor)[];
571
- default: boolean;
572
- };
573
- clearable: {
574
- type: BooleanConstructor;
575
- default: boolean;
576
- };
577
- autocomplete: {
578
- type: StringConstructor;
579
- default: string;
580
- };
581
- showPassword: {
582
- type: BooleanConstructor;
583
- default: boolean;
584
- };
585
- showWordLimit: {
586
- type: BooleanConstructor;
587
- default: boolean;
588
- };
589
- showTitle: {
590
- type: BooleanConstructor;
591
- default: boolean;
592
- };
593
- validateEvent: {
594
- type: BooleanConstructor;
595
- default: boolean;
596
- };
597
- popupMore: {
598
- type: BooleanConstructor;
599
- default: boolean;
600
- };
601
- textareaTitle: {
602
- type: StringConstructor;
603
- default: string;
604
- };
605
- displayOnly: {
606
- type: BooleanConstructor;
607
- default: boolean;
608
- };
609
- displayOnlyContent: {
610
- type: StringConstructor;
611
- default: string;
612
- };
613
- customClass: {
614
- type: StringConstructor;
615
- default: string;
616
- };
617
- frontClearIcon: {
618
- type: BooleanConstructor;
619
- default: boolean;
620
- };
621
- showEmptyValue: {
622
- type: BooleanConstructor;
623
- default: undefined;
624
- };
625
- textAlign: {
626
- type: StringConstructor;
627
- default: string;
628
- };
629
- width: {
630
- type: PropType<string | number | null>;
631
- };
632
- showTooltip: {
633
- type: BooleanConstructor;
634
- default: boolean;
635
- };
636
- inputBoxType: {
637
- type: StringConstructor;
638
- default: string;
639
- validator: (value: string) => boolean;
640
- };
641
- tiny_mode: StringConstructor;
642
- tiny_mode_root: BooleanConstructor;
643
- tiny_template: (ObjectConstructor | FunctionConstructor)[];
644
- tiny_renderless: FunctionConstructor;
645
- tiny_theme: StringConstructor;
646
- tiny_mcp_config: ObjectConstructor;
647
- tiny_chart_theme: ObjectConstructor;
648
- }>>, () => VNode<RendererNode, RendererElement, {
649
- [key: string]: any;
650
- }>, {}, {}, {}, {
651
- disabled: boolean;
652
- type: string;
653
- ellipsis: boolean;
654
- mask: boolean;
655
- vertical: boolean;
656
- customClass: string;
657
- tiny_mode_root: boolean;
658
- _constants: Record<string, any>;
659
- tabindex: string;
660
- showTitle: boolean;
661
- readonly: boolean;
662
- hoverExpand: boolean;
663
- memorySpace: number;
664
- selectMenu: {
665
- id: string;
666
- label: string;
667
- }[];
668
- contentStyle: Record<string, any>;
669
- isSelect: boolean;
670
- counter: boolean;
671
- autosize: boolean | Record<string, any>;
672
- clearable: boolean;
673
- autocomplete: string;
674
- showPassword: boolean;
675
- showWordLimit: boolean;
676
- validateEvent: boolean;
677
- popupMore: boolean;
678
- textareaTitle: string;
679
- displayOnly: boolean;
680
- displayOnlyContent: string;
681
- frontClearIcon: boolean;
682
- showEmptyValue: boolean;
683
- textAlign: string;
684
- showTooltip: boolean;
685
- inputBoxType: string;
686
- }> | null;
687
- buttonsContainerRef: HTMLDivElement;
688
- suggestionsListRef: HTMLDivElement;
689
- }, HTMLDivElement>;
690
-
691
- declare const __VLS_component_6: DefineComponent<SuggestionPillButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SuggestionPillButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
166
+ declare const __VLS_component_5: DefineComponent<SuggestionPillButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SuggestionPillButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
692
167
 
693
- declare const __VLS_component_7: DefineComponent<__VLS_PublicProps_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
168
+ declare const __VLS_component_6: DefineComponent<__VLS_PublicProps_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
694
169
  "update:showAll": (value: boolean | undefined) => any;
695
170
  } & {
696
171
  "item-click": (item: SuggestionPillItem<Record<string, unknown>>) => any;
@@ -708,7 +183,7 @@ containerRef: HTMLDivElement;
708
183
  floatingItemsRef: HTMLDivElement;
709
184
  }, HTMLDivElement>;
710
185
 
711
- declare const __VLS_component_8: DefineComponent<__VLS_PublicProps_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
186
+ declare const __VLS_component_7: DefineComponent<__VLS_PublicProps_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
712
187
  "update:selectedGroup": (value: string) => any;
713
188
  } & {
714
189
  close: () => any;
@@ -727,12 +202,107 @@ onOpen?: (() => any) | undefined;
727
202
  title: string;
728
203
  trigger: "click" | "manual";
729
204
  groupShowMoreTrigger: "click" | "hover";
730
- popoverWidth: string | number;
731
- popoverHeight: string | number;
732
- topOffset: string | number;
205
+ topOffset: number;
733
206
  }, {}, {}, {}, string, ComponentProvideOptions, false, {
734
- popoverTriggerRef: HTMLDivElement;
735
- popoverRef: HTMLDivElement;
207
+ basePopperRef: ({
208
+ $: ComponentInternalInstance;
209
+ $data: {};
210
+ $props: {
211
+ readonly appendTo?: (string | HTMLElement) | undefined;
212
+ readonly offset?: number | {
213
+ mainAxis?: number;
214
+ crossAxis?: number;
215
+ } | undefined;
216
+ readonly placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | undefined;
217
+ readonly preventOverflow?: boolean | undefined;
218
+ readonly renderAllTriggers?: boolean | undefined;
219
+ readonly show?: boolean | undefined;
220
+ readonly transitionProps?: TransitionProps | undefined;
221
+ readonly triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>> | undefined;
222
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
223
+ $attrs: {
224
+ [x: string]: unknown;
225
+ };
226
+ $refs: {
227
+ [x: string]: unknown;
228
+ } & {
229
+ popperRef: HTMLDivElement;
230
+ };
231
+ $slots: Readonly<{
232
+ [name: string]: Slot<any> | undefined;
233
+ }>;
234
+ $root: ComponentPublicInstance | null;
235
+ $parent: ComponentPublicInstance | null;
236
+ $host: Element | null;
237
+ $emit: (event: string, ...args: any[]) => void;
238
+ $el: any;
239
+ $options: ComponentOptionsBase<Readonly<{
240
+ appendTo?: string | HTMLElement;
241
+ offset?: number | {
242
+ mainAxis?: number;
243
+ crossAxis?: number;
244
+ };
245
+ placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
246
+ preventOverflow?: boolean;
247
+ renderAllTriggers?: boolean;
248
+ show?: boolean;
249
+ transitionProps?: TransitionProps;
250
+ triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
251
+ }> & Readonly<{}>, {
252
+ triggerRef: ComputedRef<MaybeElement>;
253
+ triggerRefs: Ref<MaybeElement[], MaybeElement[]>;
254
+ popperRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
255
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
256
+ placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
257
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
258
+ beforeCreate?: (() => void) | (() => void)[];
259
+ created?: (() => void) | (() => void)[];
260
+ beforeMount?: (() => void) | (() => void)[];
261
+ mounted?: (() => void) | (() => void)[];
262
+ beforeUpdate?: (() => void) | (() => void)[];
263
+ updated?: (() => void) | (() => void)[];
264
+ activated?: (() => void) | (() => void)[];
265
+ deactivated?: (() => void) | (() => void)[];
266
+ beforeDestroy?: (() => void) | (() => void)[];
267
+ beforeUnmount?: (() => void) | (() => void)[];
268
+ destroyed?: (() => void) | (() => void)[];
269
+ unmounted?: (() => void) | (() => void)[];
270
+ renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
271
+ renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
272
+ errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
273
+ };
274
+ $forceUpdate: () => void;
275
+ $nextTick: nextTick;
276
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
277
+ } & Readonly<{
278
+ placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
279
+ }> & Omit<Readonly<{
280
+ appendTo?: string | HTMLElement;
281
+ offset?: number | {
282
+ mainAxis?: number;
283
+ crossAxis?: number;
284
+ };
285
+ placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
286
+ preventOverflow?: boolean;
287
+ renderAllTriggers?: boolean;
288
+ show?: boolean;
289
+ transitionProps?: TransitionProps;
290
+ triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
291
+ }> & Readonly<{}>, "placement" | "triggerRef" | "triggerRefs" | "popperRef"> & ShallowUnwrapRef< {
292
+ triggerRef: ComputedRef<MaybeElement>;
293
+ triggerRefs: Ref<MaybeElement[], MaybeElement[]>;
294
+ popperRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
295
+ }> & {} & ComponentCustomProperties & {} & {
296
+ $slots: Readonly<{
297
+ trigger?: () => VNode[];
298
+ content?: () => VNode[];
299
+ backdrop?: () => VNode[];
300
+ }> & {
301
+ trigger?: () => VNode[];
302
+ content?: () => VNode[];
303
+ backdrop?: () => VNode[];
304
+ };
305
+ }) | null;
736
306
  listRef: HTMLUListElement;
737
307
  tooltipRef: CreateComponentPublicInstanceWithMixins<Readonly<{
738
308
  show?: TooltipContentProps["show"];
@@ -754,7 +324,7 @@ show?: TooltipContentProps["show"];
754
324
  }>, {}, {}, {}, {}, {}> | null;
755
325
  }, any>;
756
326
 
757
- declare const __VLS_component_9: DefineComponent<WelcomeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<WelcomeProps> & Readonly<{}>, {
327
+ declare const __VLS_component_8: DefineComponent<WelcomeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<WelcomeProps> & Readonly<{}>, {
758
328
  align: "left" | "center" | "right" | string;
759
329
  }, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
760
330
 
@@ -887,9 +457,11 @@ declare function __VLS_template_3(): {
887
457
  $slots: Readonly<{
888
458
  trigger?: () => VNode[];
889
459
  content?: () => VNode[];
460
+ backdrop?: () => VNode[];
890
461
  }> & {
891
462
  trigger?: () => VNode[];
892
463
  content?: () => VNode[];
464
+ backdrop?: () => VNode[];
893
465
  };
894
466
  }) | null;
895
467
  };
@@ -904,513 +476,13 @@ declare function __VLS_template_4(): {
904
476
  };
905
477
 
906
478
  declare function __VLS_template_5(): {
907
- attrs: Partial<{}>;
908
- slots: {
909
- header?(_: {}): any;
910
- prefix?(_: {}): any;
911
- decorativeContent?(_: {}): any;
912
- actions?(_: {}): any;
913
- 'footer-left'?(_: {}): any;
914
- 'footer-right'?(_: {}): any;
915
- footer?(_: {}): any;
916
- };
917
- refs: {
918
- senderRef: HTMLDivElement;
919
- inputWrapperRef: HTMLDivElement;
920
- templateEditorRef: CreateComponentPublicInstanceWithMixins<Readonly<{
921
- modelValue?: UserItem[];
922
- }> & Readonly<{
923
- "onUpdate:modelValue"?: ((value: UserItem[]) => any) | undefined;
924
- onSubmit?: (() => any) | undefined;
925
- }>, {
926
- clearHistory: () => void;
927
- activateFirstField: () => void;
928
- }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
929
- "update:modelValue": (value: UserItem[]) => any;
930
- } & {
931
- submit: () => any;
932
- }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
933
- editorRef: HTMLDivElement;
934
- }, HTMLDivElement, ComponentProvideOptions, {
935
- P: {};
936
- B: {};
937
- D: {};
938
- C: {};
939
- M: {};
940
- Defaults: {};
941
- }, Readonly<{
942
- modelValue?: UserItem[];
943
- }> & Readonly<{
944
- "onUpdate:modelValue"?: ((value: UserItem[]) => any) | undefined;
945
- onSubmit?: (() => any) | undefined;
946
- }>, {
947
- clearHistory: () => void;
948
- activateFirstField: () => void;
949
- }, {}, {}, {}, {}> | null;
950
- inputRef: CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes< {
951
- _constants: {
952
- type: ObjectConstructor;
953
- default: () => {
954
- INPUT_PC: string;
955
- INPUTGROUP_PC: string;
956
- INPUT_MOBILE: string;
957
- INPUTGROUP_MOBILE: string;
958
- Mode: string;
959
- inputMode(mode: any): string;
960
- inputGroupMode(mode: any): string;
961
- VALIDATE_ICON: {
962
- Validating: string;
963
- Success: string;
964
- Error: string;
965
- };
966
- COMPONENT_NAME: {
967
- FormItem: string;
968
- };
969
- MASKSYMBOL: string;
970
- TEXTAREA_HEIGHT_MOBILE: number;
971
- };
972
- };
973
- name: StringConstructor;
974
- size: StringConstructor;
975
- form: StringConstructor;
976
- label: StringConstructor;
977
- height: NumberConstructor;
978
- resize: StringConstructor;
979
- tabindex: {
980
- type: StringConstructor;
981
- default: string;
982
- };
983
- disabled: BooleanConstructor;
984
- readonly: BooleanConstructor;
985
- hoverExpand: BooleanConstructor;
986
- mask: BooleanConstructor;
987
- suffixIcon: (StringConstructor | ObjectConstructor)[];
988
- prefixIcon: (StringConstructor | ObjectConstructor)[];
989
- modelValue: PropType<string | number | null>;
990
- type: {
991
- type: StringConstructor;
992
- default: string;
993
- };
994
- memorySpace: {
995
- type: NumberConstructor;
996
- default: number;
997
- };
998
- vertical: {
999
- type: BooleanConstructor;
1000
- default: boolean;
1001
- };
1002
- selectMenu: {
1003
- type: {
1004
- (arrayLength: number): {
1005
- id: string;
1006
- label: string;
1007
- }[];
1008
- (...items: {
1009
- id: string;
1010
- label: string;
1011
- }[]): {
1012
- id: string;
1013
- label: string;
1014
- }[];
1015
- new (arrayLength: number): {
1016
- id: string;
1017
- label: string;
1018
- }[];
1019
- new (...items: {
1020
- id: string;
1021
- label: string;
1022
- }[]): {
1023
- id: string;
1024
- label: string;
1025
- }[];
1026
- isArray(arg: any): arg is any[];
1027
- readonly prototype: any[];
1028
- from<T>(arrayLike: ArrayLike<T>): T[];
1029
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
1030
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
1031
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
1032
- of<T_4>(...items: T_4[]): T_4[];
1033
- readonly [Symbol.species]: ArrayConstructor;
1034
- };
1035
- default: () => never[];
1036
- };
1037
- ellipsis: {
1038
- type: BooleanConstructor;
1039
- default: boolean;
1040
- };
1041
- contentStyle: {
1042
- type: ObjectConstructor;
1043
- default: () => {};
1044
- };
1045
- isSelect: {
1046
- type: BooleanConstructor;
1047
- default: boolean;
1048
- };
1049
- tips: StringConstructor;
1050
- counter: {
1051
- type: BooleanConstructor;
1052
- default: boolean;
1053
- };
1054
- autosize: {
1055
- type: (BooleanConstructor | ObjectConstructor)[];
1056
- default: boolean;
1057
- };
1058
- clearable: {
1059
- type: BooleanConstructor;
1060
- default: boolean;
1061
- };
1062
- autocomplete: {
1063
- type: StringConstructor;
1064
- default: string;
1065
- };
1066
- showPassword: {
1067
- type: BooleanConstructor;
1068
- default: boolean;
1069
- };
1070
- showWordLimit: {
1071
- type: BooleanConstructor;
1072
- default: boolean;
1073
- };
1074
- showTitle: {
1075
- type: BooleanConstructor;
1076
- default: boolean;
1077
- };
1078
- validateEvent: {
1079
- type: BooleanConstructor;
1080
- default: boolean;
1081
- };
1082
- popupMore: {
1083
- type: BooleanConstructor;
1084
- default: boolean;
1085
- };
1086
- textareaTitle: {
1087
- type: StringConstructor;
1088
- default: string;
1089
- };
1090
- displayOnly: {
1091
- type: BooleanConstructor;
1092
- default: boolean;
1093
- };
1094
- displayOnlyContent: {
1095
- type: StringConstructor;
1096
- default: string;
1097
- };
1098
- customClass: {
1099
- type: StringConstructor;
1100
- default: string;
1101
- };
1102
- frontClearIcon: {
1103
- type: BooleanConstructor;
1104
- default: boolean;
1105
- };
1106
- showEmptyValue: {
1107
- type: BooleanConstructor;
1108
- default: undefined;
1109
- };
1110
- textAlign: {
1111
- type: StringConstructor;
1112
- default: string;
1113
- };
1114
- width: {
1115
- type: PropType<string | number | null>;
1116
- };
1117
- showTooltip: {
1118
- type: BooleanConstructor;
1119
- default: boolean;
1120
- };
1121
- inputBoxType: {
1122
- type: StringConstructor;
1123
- default: string;
1124
- validator: (value: string) => boolean;
1125
- };
1126
- tiny_mode: StringConstructor;
1127
- tiny_mode_root: BooleanConstructor;
1128
- tiny_template: (ObjectConstructor | FunctionConstructor)[];
1129
- tiny_renderless: FunctionConstructor;
1130
- tiny_theme: StringConstructor;
1131
- tiny_mcp_config: ObjectConstructor;
1132
- tiny_chart_theme: ObjectConstructor;
1133
- }>>, () => VNode<RendererNode, RendererElement, {
1134
- [key: string]: any;
1135
- }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
1136
- disabled: boolean;
1137
- type: string;
1138
- ellipsis: boolean;
1139
- mask: boolean;
1140
- vertical: boolean;
1141
- customClass: string;
1142
- tiny_mode_root: boolean;
1143
- _constants: Record<string, any>;
1144
- tabindex: string;
1145
- showTitle: boolean;
1146
- readonly: boolean;
1147
- hoverExpand: boolean;
1148
- memorySpace: number;
1149
- selectMenu: {
1150
- id: string;
1151
- label: string;
1152
- }[];
1153
- contentStyle: Record<string, any>;
1154
- isSelect: boolean;
1155
- counter: boolean;
1156
- autosize: boolean | Record<string, any>;
1157
- clearable: boolean;
1158
- autocomplete: string;
1159
- showPassword: boolean;
1160
- showWordLimit: boolean;
1161
- validateEvent: boolean;
1162
- popupMore: boolean;
1163
- textareaTitle: string;
1164
- displayOnly: boolean;
1165
- displayOnlyContent: string;
1166
- frontClearIcon: boolean;
1167
- showEmptyValue: boolean;
1168
- textAlign: string;
1169
- showTooltip: boolean;
1170
- inputBoxType: string;
1171
- }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
1172
- P: {};
1173
- B: {};
1174
- D: {};
1175
- C: {};
1176
- M: {};
1177
- Defaults: {};
1178
- }, Readonly<ExtractPropTypes< {
1179
- _constants: {
1180
- type: ObjectConstructor;
1181
- default: () => {
1182
- INPUT_PC: string;
1183
- INPUTGROUP_PC: string;
1184
- INPUT_MOBILE: string;
1185
- INPUTGROUP_MOBILE: string;
1186
- Mode: string;
1187
- inputMode(mode: any): string;
1188
- inputGroupMode(mode: any): string;
1189
- VALIDATE_ICON: {
1190
- Validating: string;
1191
- Success: string;
1192
- Error: string;
1193
- };
1194
- COMPONENT_NAME: {
1195
- FormItem: string;
1196
- };
1197
- MASKSYMBOL: string;
1198
- TEXTAREA_HEIGHT_MOBILE: number;
1199
- };
1200
- };
1201
- name: StringConstructor;
1202
- size: StringConstructor;
1203
- form: StringConstructor;
1204
- label: StringConstructor;
1205
- height: NumberConstructor;
1206
- resize: StringConstructor;
1207
- tabindex: {
1208
- type: StringConstructor;
1209
- default: string;
1210
- };
1211
- disabled: BooleanConstructor;
1212
- readonly: BooleanConstructor;
1213
- hoverExpand: BooleanConstructor;
1214
- mask: BooleanConstructor;
1215
- suffixIcon: (StringConstructor | ObjectConstructor)[];
1216
- prefixIcon: (StringConstructor | ObjectConstructor)[];
1217
- modelValue: PropType<string | number | null>;
1218
- type: {
1219
- type: StringConstructor;
1220
- default: string;
1221
- };
1222
- memorySpace: {
1223
- type: NumberConstructor;
1224
- default: number;
1225
- };
1226
- vertical: {
1227
- type: BooleanConstructor;
1228
- default: boolean;
1229
- };
1230
- selectMenu: {
1231
- type: {
1232
- (arrayLength: number): {
1233
- id: string;
1234
- label: string;
1235
- }[];
1236
- (...items: {
1237
- id: string;
1238
- label: string;
1239
- }[]): {
1240
- id: string;
1241
- label: string;
1242
- }[];
1243
- new (arrayLength: number): {
1244
- id: string;
1245
- label: string;
1246
- }[];
1247
- new (...items: {
1248
- id: string;
1249
- label: string;
1250
- }[]): {
1251
- id: string;
1252
- label: string;
1253
- }[];
1254
- isArray(arg: any): arg is any[];
1255
- readonly prototype: any[];
1256
- from<T>(arrayLike: ArrayLike<T>): T[];
1257
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
1258
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
1259
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
1260
- of<T_4>(...items: T_4[]): T_4[];
1261
- readonly [Symbol.species]: ArrayConstructor;
1262
- };
1263
- default: () => never[];
1264
- };
1265
- ellipsis: {
1266
- type: BooleanConstructor;
1267
- default: boolean;
1268
- };
1269
- contentStyle: {
1270
- type: ObjectConstructor;
1271
- default: () => {};
1272
- };
1273
- isSelect: {
1274
- type: BooleanConstructor;
1275
- default: boolean;
1276
- };
1277
- tips: StringConstructor;
1278
- counter: {
1279
- type: BooleanConstructor;
1280
- default: boolean;
1281
- };
1282
- autosize: {
1283
- type: (BooleanConstructor | ObjectConstructor)[];
1284
- default: boolean;
1285
- };
1286
- clearable: {
1287
- type: BooleanConstructor;
1288
- default: boolean;
1289
- };
1290
- autocomplete: {
1291
- type: StringConstructor;
1292
- default: string;
1293
- };
1294
- showPassword: {
1295
- type: BooleanConstructor;
1296
- default: boolean;
1297
- };
1298
- showWordLimit: {
1299
- type: BooleanConstructor;
1300
- default: boolean;
1301
- };
1302
- showTitle: {
1303
- type: BooleanConstructor;
1304
- default: boolean;
1305
- };
1306
- validateEvent: {
1307
- type: BooleanConstructor;
1308
- default: boolean;
1309
- };
1310
- popupMore: {
1311
- type: BooleanConstructor;
1312
- default: boolean;
1313
- };
1314
- textareaTitle: {
1315
- type: StringConstructor;
1316
- default: string;
1317
- };
1318
- displayOnly: {
1319
- type: BooleanConstructor;
1320
- default: boolean;
1321
- };
1322
- displayOnlyContent: {
1323
- type: StringConstructor;
1324
- default: string;
1325
- };
1326
- customClass: {
1327
- type: StringConstructor;
1328
- default: string;
1329
- };
1330
- frontClearIcon: {
1331
- type: BooleanConstructor;
1332
- default: boolean;
1333
- };
1334
- showEmptyValue: {
1335
- type: BooleanConstructor;
1336
- default: undefined;
1337
- };
1338
- textAlign: {
1339
- type: StringConstructor;
1340
- default: string;
1341
- };
1342
- width: {
1343
- type: PropType<string | number | null>;
1344
- };
1345
- showTooltip: {
1346
- type: BooleanConstructor;
1347
- default: boolean;
1348
- };
1349
- inputBoxType: {
1350
- type: StringConstructor;
1351
- default: string;
1352
- validator: (value: string) => boolean;
1353
- };
1354
- tiny_mode: StringConstructor;
1355
- tiny_mode_root: BooleanConstructor;
1356
- tiny_template: (ObjectConstructor | FunctionConstructor)[];
1357
- tiny_renderless: FunctionConstructor;
1358
- tiny_theme: StringConstructor;
1359
- tiny_mcp_config: ObjectConstructor;
1360
- tiny_chart_theme: ObjectConstructor;
1361
- }>>, () => VNode<RendererNode, RendererElement, {
1362
- [key: string]: any;
1363
- }>, {}, {}, {}, {
1364
- disabled: boolean;
1365
- type: string;
1366
- ellipsis: boolean;
1367
- mask: boolean;
1368
- vertical: boolean;
1369
- customClass: string;
1370
- tiny_mode_root: boolean;
1371
- _constants: Record<string, any>;
1372
- tabindex: string;
1373
- showTitle: boolean;
1374
- readonly: boolean;
1375
- hoverExpand: boolean;
1376
- memorySpace: number;
1377
- selectMenu: {
1378
- id: string;
1379
- label: string;
1380
- }[];
1381
- contentStyle: Record<string, any>;
1382
- isSelect: boolean;
1383
- counter: boolean;
1384
- autosize: boolean | Record<string, any>;
1385
- clearable: boolean;
1386
- autocomplete: string;
1387
- showPassword: boolean;
1388
- showWordLimit: boolean;
1389
- validateEvent: boolean;
1390
- popupMore: boolean;
1391
- textareaTitle: string;
1392
- displayOnly: boolean;
1393
- displayOnlyContent: string;
1394
- frontClearIcon: boolean;
1395
- showEmptyValue: boolean;
1396
- textAlign: string;
1397
- showTooltip: boolean;
1398
- inputBoxType: string;
1399
- }> | null;
1400
- buttonsContainerRef: HTMLDivElement;
1401
- suggestionsListRef: HTMLDivElement;
1402
- };
1403
- rootEl: HTMLDivElement;
1404
- };
1405
-
1406
- declare function __VLS_template_6(): {
1407
479
  attrs: Partial<{}>;
1408
480
  slots: Readonly<SuggestionPillButtonSlots> & SuggestionPillButtonSlots;
1409
481
  refs: {};
1410
482
  rootEl: HTMLButtonElement;
1411
483
  };
1412
484
 
1413
- declare function __VLS_template_7(): {
485
+ declare function __VLS_template_6(): {
1414
486
  attrs: Partial<{}>;
1415
487
  slots: Readonly<SuggestionPillsSlots> & SuggestionPillsSlots;
1416
488
  refs: {
@@ -1421,12 +493,109 @@ declare function __VLS_template_7(): {
1421
493
  rootEl: HTMLDivElement;
1422
494
  };
1423
495
 
1424
- declare function __VLS_template_8(): {
496
+ declare function __VLS_template_7(): {
1425
497
  attrs: Partial<{}>;
1426
498
  slots: Readonly<SuggestionPopoverSlots> & SuggestionPopoverSlots;
1427
499
  refs: {
1428
- popoverTriggerRef: HTMLDivElement;
1429
- popoverRef: HTMLDivElement;
500
+ basePopperRef: ({
501
+ $: ComponentInternalInstance;
502
+ $data: {};
503
+ $props: {
504
+ readonly appendTo?: (string | HTMLElement) | undefined;
505
+ readonly offset?: number | {
506
+ mainAxis?: number;
507
+ crossAxis?: number;
508
+ } | undefined;
509
+ readonly placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | undefined;
510
+ readonly preventOverflow?: boolean | undefined;
511
+ readonly renderAllTriggers?: boolean | undefined;
512
+ readonly show?: boolean | undefined;
513
+ readonly transitionProps?: TransitionProps | undefined;
514
+ readonly triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>> | undefined;
515
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
516
+ $attrs: {
517
+ [x: string]: unknown;
518
+ };
519
+ $refs: {
520
+ [x: string]: unknown;
521
+ } & {
522
+ popperRef: HTMLDivElement;
523
+ };
524
+ $slots: Readonly<{
525
+ [name: string]: Slot<any> | undefined;
526
+ }>;
527
+ $root: ComponentPublicInstance | null;
528
+ $parent: ComponentPublicInstance | null;
529
+ $host: Element | null;
530
+ $emit: (event: string, ...args: any[]) => void;
531
+ $el: any;
532
+ $options: ComponentOptionsBase<Readonly<{
533
+ appendTo?: string | HTMLElement;
534
+ offset?: number | {
535
+ mainAxis?: number;
536
+ crossAxis?: number;
537
+ };
538
+ placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
539
+ preventOverflow?: boolean;
540
+ renderAllTriggers?: boolean;
541
+ show?: boolean;
542
+ transitionProps?: TransitionProps;
543
+ triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
544
+ }> & Readonly<{}>, {
545
+ triggerRef: ComputedRef<MaybeElement>;
546
+ triggerRefs: Ref<MaybeElement[], MaybeElement[]>;
547
+ popperRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
548
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
549
+ placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
550
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
551
+ beforeCreate?: (() => void) | (() => void)[];
552
+ created?: (() => void) | (() => void)[];
553
+ beforeMount?: (() => void) | (() => void)[];
554
+ mounted?: (() => void) | (() => void)[];
555
+ beforeUpdate?: (() => void) | (() => void)[];
556
+ updated?: (() => void) | (() => void)[];
557
+ activated?: (() => void) | (() => void)[];
558
+ deactivated?: (() => void) | (() => void)[];
559
+ beforeDestroy?: (() => void) | (() => void)[];
560
+ beforeUnmount?: (() => void) | (() => void)[];
561
+ destroyed?: (() => void) | (() => void)[];
562
+ unmounted?: (() => void) | (() => void)[];
563
+ renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
564
+ renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
565
+ errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
566
+ };
567
+ $forceUpdate: () => void;
568
+ $nextTick: nextTick;
569
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
570
+ } & Readonly<{
571
+ placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
572
+ }> & Omit<Readonly<{
573
+ appendTo?: string | HTMLElement;
574
+ offset?: number | {
575
+ mainAxis?: number;
576
+ crossAxis?: number;
577
+ };
578
+ placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
579
+ preventOverflow?: boolean;
580
+ renderAllTriggers?: boolean;
581
+ show?: boolean;
582
+ transitionProps?: TransitionProps;
583
+ triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
584
+ }> & Readonly<{}>, "placement" | "triggerRef" | "triggerRefs" | "popperRef"> & ShallowUnwrapRef< {
585
+ triggerRef: ComputedRef<MaybeElement>;
586
+ triggerRefs: Ref<MaybeElement[], MaybeElement[]>;
587
+ popperRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
588
+ }> & {} & ComponentCustomProperties & {} & {
589
+ $slots: Readonly<{
590
+ trigger?: () => VNode[];
591
+ content?: () => VNode[];
592
+ backdrop?: () => VNode[];
593
+ }> & {
594
+ trigger?: () => VNode[];
595
+ content?: () => VNode[];
596
+ backdrop?: () => VNode[];
597
+ };
598
+ }) | null;
1430
599
  listRef: HTMLUListElement;
1431
600
  tooltipRef: CreateComponentPublicInstanceWithMixins<Readonly<{
1432
601
  show?: TooltipContentProps["show"];
@@ -1450,7 +619,7 @@ declare function __VLS_template_8(): {
1450
619
  rootEl: any;
1451
620
  };
1452
621
 
1453
- declare function __VLS_template_9(): {
622
+ declare function __VLS_template_8(): {
1454
623
  attrs: Partial<{}>;
1455
624
  slots: Readonly<WelcomeSlots> & WelcomeSlots;
1456
625
  refs: {};
@@ -1473,8 +642,6 @@ declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;
1473
642
 
1474
643
  declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;
1475
644
 
1476
- declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;
1477
-
1478
645
  declare type __VLS_WithTemplateSlots<T, S> = T & {
1479
646
  new (): {
1480
647
  $slots: S;
@@ -1523,12 +690,6 @@ declare type __VLS_WithTemplateSlots_8<T, S> = T & {
1523
690
  };
1524
691
  };
1525
692
 
1526
- declare type __VLS_WithTemplateSlots_9<T, S> = T & {
1527
- new (): {
1528
- $slots: S;
1529
- };
1530
- };
1531
-
1532
693
  export declare interface ActionButtonsProps {
1533
694
  loading?: boolean;
1534
695
  disabled?: boolean;
@@ -1659,13 +820,13 @@ declare const _default: {
1659
820
  };
1660
821
  export default _default;
1661
822
 
1662
- declare const _default_10: typeof _default_24 & {
823
+ declare const _default_10: typeof _default_23 & {
1663
824
  install: typeof install_8;
1664
825
  };
1665
826
  export { _default_10 as SuggestionPopover }
1666
827
  export { _default_10 as TrSuggestionPopover }
1667
828
 
1668
- declare const _default_11: typeof _default_25 & {
829
+ declare const _default_11: typeof _default_24 & {
1669
830
  install: typeof install_9;
1670
831
  };
1671
832
  export { _default_11 as TrWelcome }
@@ -1718,8 +879,6 @@ declare const _default_23: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, _
1718
879
 
1719
880
  declare const _default_24: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
1720
881
 
1721
- declare const _default_25: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;
1722
-
1723
882
  declare const _default_3: typeof _default_15 & {
1724
883
  install: typeof install_2;
1725
884
  };
@@ -1751,13 +910,13 @@ declare const _default_7: typeof _default_18 & {
1751
910
  export { _default_7 as IconButton }
1752
911
  export { _default_7 as TrIconButton }
1753
912
 
1754
- declare const _default_8: typeof _default_21 & {
913
+ declare const _default_8: typeof default_2 & {
1755
914
  install: typeof install_6;
1756
915
  };
1757
916
  export { _default_8 as Sender }
1758
917
  export { _default_8 as TrSender }
1759
918
 
1760
- declare const _default_9: typeof _default_23 & {
919
+ declare const _default_9: typeof _default_22 & {
1761
920
  install: typeof install_7;
1762
921
  };
1763
922
  export { _default_9 as SuggestionPills }
@@ -2083,7 +1242,7 @@ export declare type SuggestionPillBaseItem<T> = {
2083
1242
  action?: SuggestionPillAction;
2084
1243
  } & T;
2085
1244
 
2086
- declare const SuggestionPillButton: typeof _default_22 & {
1245
+ declare const SuggestionPillButton: typeof _default_21 & {
2087
1246
  install: typeof installPillButton;
2088
1247
  };
2089
1248
  export { SuggestionPillButton }
@@ -2204,6 +1363,7 @@ export declare interface SuggestionPopoverEvents {
2204
1363
  }
2205
1364
 
2206
1365
  export declare interface SuggestionPopoverProps<T = Record<string, unknown>> {
1366
+ appendTo?: string | HTMLElement;
2207
1367
  data: SuggestionData<T>;
2208
1368
  title?: string;
2209
1369
  icon?: VNode | Component;
@@ -2221,9 +1381,7 @@ export declare interface SuggestionPopoverProps<T = Record<string, unknown>> {
2221
1381
  selectedGroup?: string;
2222
1382
  groupShowMoreTrigger?: 'click' | 'hover';
2223
1383
  loading?: boolean;
2224
- popoverWidth?: string | number;
2225
- popoverHeight?: string | number;
2226
- topOffset?: string | number;
1384
+ topOffset?: number;
2227
1385
  }
2228
1386
 
2229
1387
  export declare interface SuggestionPopoverSlots {
@@ -2232,6 +1390,11 @@ export declare interface SuggestionPopoverSlots {
2232
1390
  empty?: () => unknown;
2233
1391
  }
2234
1392
 
1393
+ export declare interface SuggestionTextPart {
1394
+ text: string;
1395
+ isMatch: boolean;
1396
+ }
1397
+
2235
1398
  declare interface TemplateItem extends BaseTextItem {
2236
1399
  type: 'template';
2237
1400
  prefix: string;