@fkui/vue 5.43.0 → 5.45.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.
@@ -96,6 +96,15 @@ wrapper: HTMLDivElement;
96
96
  content: HTMLDivElement;
97
97
  }, any>;
98
98
 
99
+ declare type __VLS_Props = {
100
+ id: string;
101
+ isOpen: boolean;
102
+ options: string[];
103
+ activeOption: string | null;
104
+ activeOptionId: string;
105
+ inputNode: HTMLInputElement;
106
+ };
107
+
99
108
  declare function __VLS_template(): {
100
109
  attrs: Partial<{}>;
101
110
  slots: {
@@ -284,6 +293,230 @@ export declare function createFFormProvideOptions(vm: {
284
293
 
285
294
  declare const _default: DefineComponent<ExtractPropTypes< {
286
295
  /**
296
+ * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
297
+ */
298
+ disabled: {
299
+ type: BooleanConstructor;
300
+ required: false;
301
+ default: boolean;
302
+ };
303
+ /**
304
+ * The id for the input id attribute.
305
+ * The id for the label for attribute.
306
+ * If the prop is not set a random value will be generated.
307
+ */
308
+ id: {
309
+ type: StringConstructor;
310
+ required: false;
311
+ default: () => string;
312
+ };
313
+ /**
314
+ * The value for the input checked attribute.
315
+ * @model
316
+ */
317
+ modelValue: {
318
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
319
+ required: false;
320
+ };
321
+ /**
322
+ * The value for the input.
323
+ */
324
+ value: {
325
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
326
+ required: true;
327
+ };
328
+ }>, {
329
+ showDetails: "always" | "never" | "when-selected";
330
+ getFieldsetLabelText: () => string | undefined;
331
+ }, {
332
+ expanded: boolean;
333
+ height: number;
334
+ initialStyle: {
335
+ overflow: string;
336
+ transition: string;
337
+ };
338
+ hiddenStyle: {
339
+ height: string;
340
+ position: string;
341
+ visibility: string;
342
+ };
343
+ visibleStyle: {
344
+ width: string;
345
+ position: string;
346
+ visibility: string;
347
+ height: string;
348
+ };
349
+ openedStyle: {
350
+ height: string;
351
+ };
352
+ }, {
353
+ attrs(): Record<string, unknown>;
354
+ disabledClass(): string;
355
+ injected(): any;
356
+ }, {
357
+ updateExpandedFlag(): void;
358
+ emitVModelEvent(event: Event): void;
359
+ onKeydown(event: Event): void;
360
+ onValidity({ detail }: CustomEvent<ValidityEvent>): void;
361
+ enter(element: Element): void;
362
+ afterEnter(element: Element): void;
363
+ leave(element: Element): void;
364
+ }, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes< {
365
+ /**
366
+ * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
367
+ */
368
+ disabled: {
369
+ type: BooleanConstructor;
370
+ required: false;
371
+ default: boolean;
372
+ };
373
+ /**
374
+ * The id for the input id attribute.
375
+ * The id for the label for attribute.
376
+ * If the prop is not set a random value will be generated.
377
+ */
378
+ id: {
379
+ type: StringConstructor;
380
+ required: false;
381
+ default: () => string;
382
+ };
383
+ /**
384
+ * The value for the input checked attribute.
385
+ * @model
386
+ */
387
+ modelValue: {
388
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
389
+ required: false;
390
+ };
391
+ /**
392
+ * The value for the input.
393
+ */
394
+ value: {
395
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
396
+ required: true;
397
+ };
398
+ }>> & Readonly<{
399
+ onChange?: ((...args: any[]) => any) | undefined;
400
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
401
+ }>, {
402
+ id: string;
403
+ disabled: boolean;
404
+ }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
405
+ export { _default as FCheckboxField }
406
+ export { _default as FCheckboxGroupField }
407
+
408
+ declare const _default_2: DefineComponent<ExtractPropTypes< {
409
+ /**
410
+ * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
411
+ */
412
+ disabled: {
413
+ type: BooleanConstructor;
414
+ required: false;
415
+ default: boolean;
416
+ };
417
+ /**
418
+ * The id for the input id attribute.
419
+ * The id for the label for attribute.
420
+ * If the prop is not set a random value will be generated.
421
+ */
422
+ id: {
423
+ type: StringConstructor;
424
+ required: false;
425
+ default: () => string;
426
+ };
427
+ /**
428
+ * The value for the input checked attribute.
429
+ * @model
430
+ */
431
+ modelValue: {
432
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
433
+ required: false;
434
+ };
435
+ /**
436
+ * The value for the input.
437
+ */
438
+ value: {
439
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
440
+ required: true;
441
+ };
442
+ }>, {
443
+ sharedName: string | undefined;
444
+ showDetails: "always" | "never" | "when-selected";
445
+ getFieldsetLabelText: () => string | undefined;
446
+ }, {
447
+ height: number;
448
+ initialStyle: {
449
+ overflow: string;
450
+ transition: string;
451
+ };
452
+ hiddenStyle: {
453
+ height: string;
454
+ position: string;
455
+ visibility: string;
456
+ };
457
+ visibleStyle: {
458
+ width: string;
459
+ position: string;
460
+ visibility: string;
461
+ height: string;
462
+ };
463
+ openedStyle: {
464
+ height: string;
465
+ };
466
+ }, {
467
+ attrs(): Record<string, unknown>;
468
+ disabledClass(): string;
469
+ }, {
470
+ onValidity({ detail }: CustomEvent<ValidityEvent>): Promise<void>;
471
+ enter(element: Element): void;
472
+ afterEnter(element: Element): void;
473
+ leave(element: Element): void;
474
+ }, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes< {
475
+ /**
476
+ * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
477
+ */
478
+ disabled: {
479
+ type: BooleanConstructor;
480
+ required: false;
481
+ default: boolean;
482
+ };
483
+ /**
484
+ * The id for the input id attribute.
485
+ * The id for the label for attribute.
486
+ * If the prop is not set a random value will be generated.
487
+ */
488
+ id: {
489
+ type: StringConstructor;
490
+ required: false;
491
+ default: () => string;
492
+ };
493
+ /**
494
+ * The value for the input checked attribute.
495
+ * @model
496
+ */
497
+ modelValue: {
498
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
499
+ required: false;
500
+ };
501
+ /**
502
+ * The value for the input.
503
+ */
504
+ value: {
505
+ type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
506
+ required: true;
507
+ };
508
+ }>> & Readonly<{
509
+ onChange?: ((...args: any[]) => any) | undefined;
510
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
511
+ }>, {
512
+ id: string;
513
+ disabled: boolean;
514
+ }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
515
+ export { _default_2 as FRadioField }
516
+ export { _default_2 as FRadioGroupField }
517
+
518
+ declare const _default_3: DefineComponent<ExtractPropTypes< {
519
+ /**
287
520
  * If given, this function is called before the `submit` event is emitted.
288
521
  *
289
522
  * Optionally this callback may return `FValidationFormAction`. If
@@ -415,8 +648,8 @@ default(): BeforeNavigate;
415
648
  }>> & Readonly<{
416
649
  onSubmit?: ((...args: any[]) => any) | undefined;
417
650
  }>, {
418
- beforeSubmit: FValidationFormCallback;
419
651
  id: string;
652
+ beforeSubmit: FValidationFormCallback;
420
653
  beforeValidation: FValidationFormCallback;
421
654
  useErrorList: boolean;
422
655
  errorListBullets: boolean;
@@ -601,264 +834,40 @@ grow: {
601
834
  type: BooleanConstructor;
602
835
  default: boolean;
603
836
  };
604
- shrink: {
605
- type: BooleanConstructor;
606
- default: boolean;
607
- };
608
- align: {
609
- type: StringConstructor;
610
- default: string;
611
- validator(val: string): boolean;
612
- };
613
- }>, {}, {}, {
614
- classList(): string[];
615
- }, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
616
- grow: {
617
- type: BooleanConstructor;
618
- default: boolean;
619
- };
620
- shrink: {
621
- type: BooleanConstructor;
622
- default: boolean;
623
- };
624
- align: {
625
- type: StringConstructor;
626
- default: string;
627
- validator(val: string): boolean;
628
- };
629
- }>> & Readonly<{}>, {
630
- grow: boolean;
631
- shrink: boolean;
632
- align: string;
633
- }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
634
- }, {}, string, ComponentProvideOptions, true, {}, any>;
635
- }, {}, string, ComponentProvideOptions, true, {}, any>;
636
- export { _default as FValidationForm }
637
- export { _default as IValidationForm }
638
-
639
- declare const _default_2: DefineComponent<ExtractPropTypes< {
640
- /**
641
- * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
642
- */
643
- disabled: {
644
- type: BooleanConstructor;
645
- required: false;
646
- default: boolean;
647
- };
648
- /**
649
- * The id for the input id attribute.
650
- * The id for the label for attribute.
651
- * If the prop is not set a random value will be generated.
652
- */
653
- id: {
654
- type: StringConstructor;
655
- required: false;
656
- default: () => string;
657
- };
658
- /**
659
- * The value for the input checked attribute.
660
- * @model
661
- */
662
- modelValue: {
663
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
664
- required: false;
665
- };
666
- /**
667
- * The value for the input.
668
- */
669
- value: {
670
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
671
- required: true;
672
- };
673
- }>, {
674
- showDetails: "always" | "never" | "when-selected";
675
- getFieldsetLabelText: () => string | undefined;
676
- }, {
677
- expanded: boolean;
678
- height: number;
679
- initialStyle: {
680
- overflow: string;
681
- transition: string;
682
- };
683
- hiddenStyle: {
684
- height: string;
685
- position: string;
686
- visibility: string;
687
- };
688
- visibleStyle: {
689
- width: string;
690
- position: string;
691
- visibility: string;
692
- height: string;
693
- };
694
- openedStyle: {
695
- height: string;
696
- };
697
- }, {
698
- attrs(): Record<string, unknown>;
699
- disabledClass(): string;
700
- injected(): any;
701
- }, {
702
- updateExpandedFlag(): void;
703
- emitVModelEvent(event: Event): void;
704
- onKeydown(event: Event): void;
705
- onValidity({ detail }: CustomEvent<ValidityEvent>): void;
706
- enter(element: Element): void;
707
- afterEnter(element: Element): void;
708
- leave(element: Element): void;
709
- }, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes< {
710
- /**
711
- * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
712
- */
713
- disabled: {
714
- type: BooleanConstructor;
715
- required: false;
716
- default: boolean;
717
- };
718
- /**
719
- * The id for the input id attribute.
720
- * The id for the label for attribute.
721
- * If the prop is not set a random value will be generated.
722
- */
723
- id: {
724
- type: StringConstructor;
725
- required: false;
726
- default: () => string;
727
- };
728
- /**
729
- * The value for the input checked attribute.
730
- * @model
731
- */
732
- modelValue: {
733
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
734
- required: false;
735
- };
736
- /**
737
- * The value for the input.
738
- */
739
- value: {
740
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
741
- required: true;
742
- };
743
- }>> & Readonly<{
744
- onChange?: ((...args: any[]) => any) | undefined;
745
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
746
- }>, {
747
- id: string;
748
- disabled: boolean;
749
- }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
750
- export { _default_2 as FCheckboxField }
751
- export { _default_2 as FCheckboxGroupField }
752
-
753
- declare const _default_3: DefineComponent<ExtractPropTypes< {
754
- /**
755
- * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
756
- */
757
- disabled: {
758
- type: BooleanConstructor;
759
- required: false;
760
- default: boolean;
761
- };
762
- /**
763
- * The id for the input id attribute.
764
- * The id for the label for attribute.
765
- * If the prop is not set a random value will be generated.
766
- */
767
- id: {
768
- type: StringConstructor;
769
- required: false;
770
- default: () => string;
771
- };
772
- /**
773
- * The value for the input checked attribute.
774
- * @model
775
- */
776
- modelValue: {
777
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
778
- required: false;
779
- };
780
- /**
781
- * The value for the input.
782
- */
783
- value: {
784
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
785
- required: true;
786
- };
787
- }>, {
788
- sharedName: string | undefined;
789
- showDetails: "always" | "never" | "when-selected";
790
- getFieldsetLabelText: () => string | undefined;
791
- }, {
792
- height: number;
793
- initialStyle: {
794
- overflow: string;
795
- transition: string;
796
- };
797
- hiddenStyle: {
798
- height: string;
799
- position: string;
800
- visibility: string;
801
- };
802
- visibleStyle: {
803
- width: string;
804
- position: string;
805
- visibility: string;
806
- height: string;
807
- };
808
- openedStyle: {
809
- height: string;
810
- };
811
- }, {
812
- attrs(): Record<string, unknown>;
813
- disabledClass(): string;
814
- }, {
815
- onValidity({ detail }: CustomEvent<ValidityEvent>): Promise<void>;
816
- enter(element: Element): void;
817
- afterEnter(element: Element): void;
818
- leave(element: Element): void;
819
- }, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes< {
820
- /**
821
- * Set to `true`, empty string `""` or string `"disabled"` to disable this input field.
822
- */
823
- disabled: {
837
+ shrink: {
824
838
  type: BooleanConstructor;
825
- required: false;
826
839
  default: boolean;
827
840
  };
828
- /**
829
- * The id for the input id attribute.
830
- * The id for the label for attribute.
831
- * If the prop is not set a random value will be generated.
832
- */
833
- id: {
841
+ align: {
834
842
  type: StringConstructor;
835
- required: false;
836
- default: () => string;
843
+ default: string;
844
+ validator(val: string): boolean;
837
845
  };
838
- /**
839
- * The value for the input checked attribute.
840
- * @model
841
- */
842
- modelValue: {
843
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
844
- required: false;
846
+ }>, {}, {}, {
847
+ classList(): string[];
848
+ }, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
849
+ grow: {
850
+ type: BooleanConstructor;
851
+ default: boolean;
845
852
  };
846
- /**
847
- * The value for the input.
848
- */
849
- value: {
850
- type: (StringConstructor | BooleanConstructor | ObjectConstructor | DateConstructor | ArrayConstructor | NumberConstructor)[];
851
- required: true;
853
+ shrink: {
854
+ type: BooleanConstructor;
855
+ default: boolean;
852
856
  };
853
- }>> & Readonly<{
854
- onChange?: ((...args: any[]) => any) | undefined;
855
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
856
- }>, {
857
- id: string;
858
- disabled: boolean;
857
+ align: {
858
+ type: StringConstructor;
859
+ default: string;
860
+ validator(val: string): boolean;
861
+ };
862
+ }>> & Readonly<{}>, {
863
+ grow: boolean;
864
+ shrink: boolean;
865
+ align: string;
859
866
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
860
- export { _default_3 as FRadioField }
861
- export { _default_3 as FRadioGroupField }
867
+ }, {}, string, ComponentProvideOptions, true, {}, any>;
868
+ }, {}, string, ComponentProvideOptions, true, {}, any>;
869
+ export { _default_3 as FValidationForm }
870
+ export { _default_3 as IValidationForm }
862
871
 
863
872
  /* Excluded from this release type: dispatchComponentUnmountEvent */
864
873
 
@@ -1009,6 +1018,16 @@ default: typeof parseBankAccountNumber;
1009
1018
  };
1010
1019
  }>, {
1011
1020
  textFieldTableMode: boolean;
1021
+ viewValue: Ref<string>;
1022
+ onOptionSelected: (value: string) => void;
1023
+ dropdownId: string;
1024
+ dropdownIsOpen: Readonly<Ref<boolean>>;
1025
+ dropdownOptions: Readonly<Ref<string[]>>;
1026
+ activeOptionId: string;
1027
+ activeOption: Readonly<Ref<string | null>>;
1028
+ toggleDropdown: () => void;
1029
+ selectOption: (value: string) => void;
1030
+ closeDropdown: () => void;
1012
1031
  }, {
1013
1032
  defaultText: string;
1014
1033
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -1052,11 +1071,30 @@ type: StringConstructor;
1052
1071
  required: false;
1053
1072
  default: string;
1054
1073
  };
1074
+ options: {
1075
+ type: PropType<string[] | undefined>;
1076
+ required: false;
1077
+ default: () => undefined;
1078
+ };
1079
+ disabled: {
1080
+ type: BooleanConstructor;
1081
+ required: false;
1082
+ default: boolean;
1083
+ };
1055
1084
  }>, {
1056
1085
  textFieldTableMode: boolean;
1086
+ viewValue: Ref<string, string>;
1087
+ onOptionSelected: (value: string) => void;
1088
+ dropdownId: string;
1089
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
1090
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
1091
+ activeOptionId: string;
1092
+ activeOption: Readonly<Ref<string | null, string | null>>;
1093
+ toggleDropdown: () => void;
1094
+ selectOption: (value: string) => void;
1095
+ closeDropdown: () => void;
1057
1096
  }, {
1058
1097
  showErrorPopup: boolean;
1059
- viewValue: string;
1060
1098
  lastModelValue: unknown;
1061
1099
  validationMessage: string;
1062
1100
  validityMode: string;
@@ -1076,6 +1114,8 @@ labelWrapperClass(): string | undefined;
1076
1114
  inputWrapperClass(): string | undefined;
1077
1115
  isModelUpdatedProgrammatically(): boolean;
1078
1116
  }, {
1117
+ onDropdownSelect(value: string): void;
1118
+ onDropdownClose(): void;
1079
1119
  getErrorPopupAnchor(): HTMLElement;
1080
1120
  closePopupError(): void;
1081
1121
  onChange(): Promise<void>;
@@ -1129,6 +1169,16 @@ type: StringConstructor;
1129
1169
  required: false;
1130
1170
  default: string;
1131
1171
  };
1172
+ options: {
1173
+ type: PropType<string[] | undefined>;
1174
+ required: false;
1175
+ default: () => undefined;
1176
+ };
1177
+ disabled: {
1178
+ type: BooleanConstructor;
1179
+ required: false;
1180
+ default: boolean;
1181
+ };
1132
1182
  }>> & Readonly<{
1133
1183
  onBlur?: ((...args: any[]) => any) | undefined;
1134
1184
  onChange?: ((...args: any[]) => any) | undefined;
@@ -1139,6 +1189,8 @@ type: string;
1139
1189
  id: string;
1140
1190
  modelValue: string | number;
1141
1191
  inline: boolean;
1192
+ disabled: boolean;
1193
+ options: string[] | undefined;
1142
1194
  labelWidth: string;
1143
1195
  formatter: FormatFunction<any>;
1144
1196
  parser: ParseFunction<any>;
@@ -1377,6 +1429,34 @@ flip: string;
1377
1429
  rotate: string;
1378
1430
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
1379
1431
  }, {}, string, ComponentProvideOptions, true, {}, any>;
1432
+ IComboboxDropdown: DefineComponent< {
1433
+ id: string;
1434
+ isOpen: boolean;
1435
+ options: string[];
1436
+ activeOption: string | null;
1437
+ activeOptionId: string;
1438
+ inputNode: HTMLInputElement;
1439
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1440
+ close: () => any;
1441
+ select: (option: string) => any;
1442
+ }, string, PublicProps, Readonly<{
1443
+ id: string;
1444
+ isOpen: boolean;
1445
+ options: string[];
1446
+ activeOption: string | null;
1447
+ activeOptionId: string;
1448
+ inputNode: HTMLInputElement;
1449
+ }> & Readonly<{
1450
+ onClose?: (() => any) | undefined;
1451
+ onSelect?: ((option: string) => any) | undefined;
1452
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
1453
+ listbox: HTMLUListElement;
1454
+ }, HTMLDivElement>;
1455
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1456
+ toggle: () => any;
1457
+ }, string, PublicProps, Readonly<{}> & Readonly<{
1458
+ onToggle?: (() => any) | undefined;
1459
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
1380
1460
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
1381
1461
  parser: {
1382
1462
  type: PropType<ParseFunction<BankAccountNumberString>>;
@@ -1395,6 +1475,16 @@ default: typeof parseBankgiro;
1395
1475
  };
1396
1476
  }>, {
1397
1477
  textFieldTableMode: boolean;
1478
+ viewValue: Ref<string>;
1479
+ onOptionSelected: (value: string) => void;
1480
+ dropdownId: string;
1481
+ dropdownIsOpen: Readonly<Ref<boolean>>;
1482
+ dropdownOptions: Readonly<Ref<string[]>>;
1483
+ activeOptionId: string;
1484
+ activeOption: Readonly<Ref<string | null>>;
1485
+ toggleDropdown: () => void;
1486
+ selectOption: (value: string) => void;
1487
+ closeDropdown: () => void;
1398
1488
  }, {
1399
1489
  defaultText: string;
1400
1490
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -1438,11 +1528,30 @@ type: StringConstructor;
1438
1528
  required: false;
1439
1529
  default: string;
1440
1530
  };
1531
+ options: {
1532
+ type: PropType<string[] | undefined>;
1533
+ required: false;
1534
+ default: () => undefined;
1535
+ };
1536
+ disabled: {
1537
+ type: BooleanConstructor;
1538
+ required: false;
1539
+ default: boolean;
1540
+ };
1441
1541
  }>, {
1442
1542
  textFieldTableMode: boolean;
1543
+ viewValue: Ref<string, string>;
1544
+ onOptionSelected: (value: string) => void;
1545
+ dropdownId: string;
1546
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
1547
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
1548
+ activeOptionId: string;
1549
+ activeOption: Readonly<Ref<string | null, string | null>>;
1550
+ toggleDropdown: () => void;
1551
+ selectOption: (value: string) => void;
1552
+ closeDropdown: () => void;
1443
1553
  }, {
1444
1554
  showErrorPopup: boolean;
1445
- viewValue: string;
1446
1555
  lastModelValue: unknown;
1447
1556
  validationMessage: string;
1448
1557
  validityMode: string;
@@ -1462,6 +1571,8 @@ labelWrapperClass(): string | undefined;
1462
1571
  inputWrapperClass(): string | undefined;
1463
1572
  isModelUpdatedProgrammatically(): boolean;
1464
1573
  }, {
1574
+ onDropdownSelect(value: string): void;
1575
+ onDropdownClose(): void;
1465
1576
  getErrorPopupAnchor(): HTMLElement;
1466
1577
  closePopupError(): void;
1467
1578
  onChange(): Promise<void>;
@@ -1515,6 +1626,16 @@ type: StringConstructor;
1515
1626
  required: false;
1516
1627
  default: string;
1517
1628
  };
1629
+ options: {
1630
+ type: PropType<string[] | undefined>;
1631
+ required: false;
1632
+ default: () => undefined;
1633
+ };
1634
+ disabled: {
1635
+ type: BooleanConstructor;
1636
+ required: false;
1637
+ default: boolean;
1638
+ };
1518
1639
  }>> & Readonly<{
1519
1640
  onBlur?: ((...args: any[]) => any) | undefined;
1520
1641
  onChange?: ((...args: any[]) => any) | undefined;
@@ -1525,6 +1646,8 @@ type: string;
1525
1646
  id: string;
1526
1647
  modelValue: string | number;
1527
1648
  inline: boolean;
1649
+ disabled: boolean;
1650
+ options: string[] | undefined;
1528
1651
  labelWidth: string;
1529
1652
  formatter: FormatFunction<any>;
1530
1653
  parser: ParseFunction<any>;
@@ -1763,6 +1886,34 @@ flip: string;
1763
1886
  rotate: string;
1764
1887
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
1765
1888
  }, {}, string, ComponentProvideOptions, true, {}, any>;
1889
+ IComboboxDropdown: DefineComponent< {
1890
+ id: string;
1891
+ isOpen: boolean;
1892
+ options: string[];
1893
+ activeOption: string | null;
1894
+ activeOptionId: string;
1895
+ inputNode: HTMLInputElement;
1896
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1897
+ close: () => any;
1898
+ select: (option: string) => any;
1899
+ }, string, PublicProps, Readonly<{
1900
+ id: string;
1901
+ isOpen: boolean;
1902
+ options: string[];
1903
+ activeOption: string | null;
1904
+ activeOptionId: string;
1905
+ inputNode: HTMLInputElement;
1906
+ }> & Readonly<{
1907
+ onClose?: (() => any) | undefined;
1908
+ onSelect?: ((option: string) => any) | undefined;
1909
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
1910
+ listbox: HTMLUListElement;
1911
+ }, HTMLDivElement>;
1912
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1913
+ toggle: () => any;
1914
+ }, string, PublicProps, Readonly<{}> & Readonly<{
1915
+ onToggle?: (() => any) | undefined;
1916
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
1766
1917
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
1767
1918
  formatter: {
1768
1919
  type: PropType<FormatFunction<BankgiroString>>;
@@ -2360,6 +2511,16 @@ default: typeof parseClearingNumber;
2360
2511
  };
2361
2512
  }>, {
2362
2513
  textFieldTableMode: boolean;
2514
+ viewValue: Ref<string>;
2515
+ onOptionSelected: (value: string) => void;
2516
+ dropdownId: string;
2517
+ dropdownIsOpen: Readonly<Ref<boolean>>;
2518
+ dropdownOptions: Readonly<Ref<string[]>>;
2519
+ activeOptionId: string;
2520
+ activeOption: Readonly<Ref<string | null>>;
2521
+ toggleDropdown: () => void;
2522
+ selectOption: (value: string) => void;
2523
+ closeDropdown: () => void;
2363
2524
  }, {
2364
2525
  defaultText: string;
2365
2526
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -2403,11 +2564,30 @@ type: StringConstructor;
2403
2564
  required: false;
2404
2565
  default: string;
2405
2566
  };
2567
+ options: {
2568
+ type: PropType<string[] | undefined>;
2569
+ required: false;
2570
+ default: () => undefined;
2571
+ };
2572
+ disabled: {
2573
+ type: BooleanConstructor;
2574
+ required: false;
2575
+ default: boolean;
2576
+ };
2406
2577
  }>, {
2407
2578
  textFieldTableMode: boolean;
2579
+ viewValue: Ref<string, string>;
2580
+ onOptionSelected: (value: string) => void;
2581
+ dropdownId: string;
2582
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
2583
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
2584
+ activeOptionId: string;
2585
+ activeOption: Readonly<Ref<string | null, string | null>>;
2586
+ toggleDropdown: () => void;
2587
+ selectOption: (value: string) => void;
2588
+ closeDropdown: () => void;
2408
2589
  }, {
2409
2590
  showErrorPopup: boolean;
2410
- viewValue: string;
2411
2591
  lastModelValue: unknown;
2412
2592
  validationMessage: string;
2413
2593
  validityMode: string;
@@ -2427,6 +2607,8 @@ labelWrapperClass(): string | undefined;
2427
2607
  inputWrapperClass(): string | undefined;
2428
2608
  isModelUpdatedProgrammatically(): boolean;
2429
2609
  }, {
2610
+ onDropdownSelect(value: string): void;
2611
+ onDropdownClose(): void;
2430
2612
  getErrorPopupAnchor(): HTMLElement;
2431
2613
  closePopupError(): void;
2432
2614
  onChange(): Promise<void>;
@@ -2480,6 +2662,16 @@ type: StringConstructor;
2480
2662
  required: false;
2481
2663
  default: string;
2482
2664
  };
2665
+ options: {
2666
+ type: PropType<string[] | undefined>;
2667
+ required: false;
2668
+ default: () => undefined;
2669
+ };
2670
+ disabled: {
2671
+ type: BooleanConstructor;
2672
+ required: false;
2673
+ default: boolean;
2674
+ };
2483
2675
  }>> & Readonly<{
2484
2676
  onBlur?: ((...args: any[]) => any) | undefined;
2485
2677
  onChange?: ((...args: any[]) => any) | undefined;
@@ -2490,6 +2682,8 @@ type: string;
2490
2682
  id: string;
2491
2683
  modelValue: string | number;
2492
2684
  inline: boolean;
2685
+ disabled: boolean;
2686
+ options: string[] | undefined;
2493
2687
  labelWidth: string;
2494
2688
  formatter: FormatFunction<any>;
2495
2689
  parser: ParseFunction<any>;
@@ -2728,6 +2922,34 @@ flip: string;
2728
2922
  rotate: string;
2729
2923
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
2730
2924
  }, {}, string, ComponentProvideOptions, true, {}, any>;
2925
+ IComboboxDropdown: DefineComponent< {
2926
+ id: string;
2927
+ isOpen: boolean;
2928
+ options: string[];
2929
+ activeOption: string | null;
2930
+ activeOptionId: string;
2931
+ inputNode: HTMLInputElement;
2932
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
2933
+ close: () => any;
2934
+ select: (option: string) => any;
2935
+ }, string, PublicProps, Readonly<{
2936
+ id: string;
2937
+ isOpen: boolean;
2938
+ options: string[];
2939
+ activeOption: string | null;
2940
+ activeOptionId: string;
2941
+ inputNode: HTMLInputElement;
2942
+ }> & Readonly<{
2943
+ onClose?: (() => any) | undefined;
2944
+ onSelect?: ((option: string) => any) | undefined;
2945
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
2946
+ listbox: HTMLUListElement;
2947
+ }, HTMLDivElement>;
2948
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
2949
+ toggle: () => any;
2950
+ }, string, PublicProps, Readonly<{}> & Readonly<{
2951
+ onToggle?: (() => any) | undefined;
2952
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
2731
2953
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
2732
2954
  formatter: {
2733
2955
  type: PropType<FormatFunction<ClearingnumberString>>;
@@ -2980,8 +3202,8 @@ validator(value: string): boolean;
2980
3202
  }>> & Readonly<{
2981
3203
  onClose?: ((...args: any[]) => any) | undefined;
2982
3204
  }>, {
2983
- focus: "on" | "off" | "open";
2984
3205
  type: "" | "warning" | "error" | "information";
3206
+ focus: "on" | "off" | "open";
2985
3207
  size: string;
2986
3208
  isOpen: boolean;
2987
3209
  fullscreen: boolean;
@@ -3248,7 +3470,7 @@ onOpen?: ((...args: any[]) => any) | undefined;
3248
3470
  }>, {
3249
3471
  anchor: HTMLElement | null | undefined;
3250
3472
  viewport: HTMLElement;
3251
- inline: "always" | "never" | "auto";
3473
+ inline: "auto" | "always" | "never";
3252
3474
  alwaysInline: boolean;
3253
3475
  container: HTMLElement | null | undefined;
3254
3476
  keyboardTrap: boolean;
@@ -3591,9 +3813,9 @@ onCreated?: ((...args: any[]) => any) | undefined;
3591
3813
  onUpdated?: ((...args: any[]) => any) | undefined;
3592
3814
  onDeleted?: ((...args: any[]) => any) | undefined;
3593
3815
  }>, {
3594
- beforeSubmit: FValidationFormCallback;
3595
3816
  beforeCreate: (() => ListItem) | undefined;
3596
3817
  modelValue: ListArray<UnknownItem>;
3818
+ beforeSubmit: FValidationFormCallback;
3597
3819
  beforeValidation: FValidationFormCallback;
3598
3820
  onCancel: () => void;
3599
3821
  primaryButtonRight: boolean;
@@ -3727,9 +3949,9 @@ value: Record<string, any>;
3727
3949
  size: string;
3728
3950
  isOpen: boolean;
3729
3951
  fullscreen: boolean;
3730
- beforeSubmit: FValidationFormCallback;
3731
3952
  ariaCloseText: string;
3732
3953
  buttons: FModalButtonDescriptor[];
3954
+ beforeSubmit: FValidationFormCallback;
3733
3955
  beforeValidation: FValidationFormCallback;
3734
3956
  useErrorList: boolean;
3735
3957
  dataTest: string;
@@ -3821,8 +4043,8 @@ validator(value: string): boolean;
3821
4043
  }>> & Readonly<{
3822
4044
  onClose?: ((...args: any[]) => any) | undefined;
3823
4045
  }>, {
3824
- focus: "on" | "off" | "open";
3825
4046
  type: "" | "warning" | "error" | "information";
4047
+ focus: "on" | "off" | "open";
3826
4048
  size: string;
3827
4049
  isOpen: boolean;
3828
4050
  fullscreen: boolean;
@@ -3959,8 +4181,8 @@ default(): BeforeNavigate;
3959
4181
  }>> & Readonly<{
3960
4182
  onSubmit?: ((...args: any[]) => any) | undefined;
3961
4183
  }>, {
3962
- beforeSubmit: FValidationFormCallback;
3963
4184
  id: string;
4185
+ beforeSubmit: FValidationFormCallback;
3964
4186
  beforeValidation: FValidationFormCallback;
3965
4187
  useErrorList: boolean;
3966
4188
  errorListBullets: boolean;
@@ -4363,8 +4585,8 @@ validator(value: string): boolean;
4363
4585
  }>> & Readonly<{
4364
4586
  onClose?: ((...args: any[]) => any) | undefined;
4365
4587
  }>, {
4366
- focus: "on" | "off" | "open";
4367
4588
  type: "" | "warning" | "error" | "information";
4589
+ focus: "on" | "off" | "open";
4368
4590
  size: string;
4369
4591
  isOpen: boolean;
4370
4592
  fullscreen: boolean;
@@ -4519,6 +4741,16 @@ default: typeof parseNumber;
4519
4741
  };
4520
4742
  }>, {
4521
4743
  textFieldTableMode: boolean;
4744
+ viewValue: Ref<string>;
4745
+ onOptionSelected: (value: string) => void;
4746
+ dropdownId: string;
4747
+ dropdownIsOpen: Readonly<Ref<boolean>>;
4748
+ dropdownOptions: Readonly<Ref<string[]>>;
4749
+ activeOptionId: string;
4750
+ activeOption: Readonly<Ref<string | null>>;
4751
+ toggleDropdown: () => void;
4752
+ selectOption: (value: string) => void;
4753
+ closeDropdown: () => void;
4522
4754
  }, {
4523
4755
  defaultText: string;
4524
4756
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -4562,11 +4794,30 @@ type: StringConstructor;
4562
4794
  required: false;
4563
4795
  default: string;
4564
4796
  };
4797
+ options: {
4798
+ type: PropType<string[] | undefined>;
4799
+ required: false;
4800
+ default: () => undefined;
4801
+ };
4802
+ disabled: {
4803
+ type: BooleanConstructor;
4804
+ required: false;
4805
+ default: boolean;
4806
+ };
4565
4807
  }>, {
4566
4808
  textFieldTableMode: boolean;
4809
+ viewValue: Ref<string, string>;
4810
+ onOptionSelected: (value: string) => void;
4811
+ dropdownId: string;
4812
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
4813
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
4814
+ activeOptionId: string;
4815
+ activeOption: Readonly<Ref<string | null, string | null>>;
4816
+ toggleDropdown: () => void;
4817
+ selectOption: (value: string) => void;
4818
+ closeDropdown: () => void;
4567
4819
  }, {
4568
4820
  showErrorPopup: boolean;
4569
- viewValue: string;
4570
4821
  lastModelValue: unknown;
4571
4822
  validationMessage: string;
4572
4823
  validityMode: string;
@@ -4586,6 +4837,8 @@ labelWrapperClass(): string | undefined;
4586
4837
  inputWrapperClass(): string | undefined;
4587
4838
  isModelUpdatedProgrammatically(): boolean;
4588
4839
  }, {
4840
+ onDropdownSelect(value: string): void;
4841
+ onDropdownClose(): void;
4589
4842
  getErrorPopupAnchor(): HTMLElement;
4590
4843
  closePopupError(): void;
4591
4844
  onChange(): Promise<void>;
@@ -4639,6 +4892,16 @@ type: StringConstructor;
4639
4892
  required: false;
4640
4893
  default: string;
4641
4894
  };
4895
+ options: {
4896
+ type: PropType<string[] | undefined>;
4897
+ required: false;
4898
+ default: () => undefined;
4899
+ };
4900
+ disabled: {
4901
+ type: BooleanConstructor;
4902
+ required: false;
4903
+ default: boolean;
4904
+ };
4642
4905
  }>> & Readonly<{
4643
4906
  onBlur?: ((...args: any[]) => any) | undefined;
4644
4907
  onChange?: ((...args: any[]) => any) | undefined;
@@ -4649,6 +4912,8 @@ type: string;
4649
4912
  id: string;
4650
4913
  modelValue: string | number;
4651
4914
  inline: boolean;
4915
+ disabled: boolean;
4916
+ options: string[] | undefined;
4652
4917
  labelWidth: string;
4653
4918
  formatter: FormatFunction<any>;
4654
4919
  parser: ParseFunction<any>;
@@ -4887,6 +5152,34 @@ flip: string;
4887
5152
  rotate: string;
4888
5153
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
4889
5154
  }, {}, string, ComponentProvideOptions, true, {}, any>;
5155
+ IComboboxDropdown: DefineComponent< {
5156
+ id: string;
5157
+ isOpen: boolean;
5158
+ options: string[];
5159
+ activeOption: string | null;
5160
+ activeOptionId: string;
5161
+ inputNode: HTMLInputElement;
5162
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
5163
+ close: () => any;
5164
+ select: (option: string) => any;
5165
+ }, string, PublicProps, Readonly<{
5166
+ id: string;
5167
+ isOpen: boolean;
5168
+ options: string[];
5169
+ activeOption: string | null;
5170
+ activeOptionId: string;
5171
+ inputNode: HTMLInputElement;
5172
+ }> & Readonly<{
5173
+ onClose?: (() => any) | undefined;
5174
+ onSelect?: ((option: string) => any) | undefined;
5175
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
5176
+ listbox: HTMLUListElement;
5177
+ }, HTMLDivElement>;
5178
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
5179
+ toggle: () => any;
5180
+ }, string, PublicProps, Readonly<{}> & Readonly<{
5181
+ onToggle?: (() => any) | undefined;
5182
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
4890
5183
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
4891
5184
  formatter: {
4892
5185
  type: PropType<FormatFunction<number>>;
@@ -5583,7 +5876,7 @@ onOpen?: ((...args: any[]) => any) | undefined;
5583
5876
  }>, {
5584
5877
  anchor: HTMLElement | null | undefined;
5585
5878
  viewport: HTMLElement;
5586
- inline: "always" | "never" | "auto";
5879
+ inline: "auto" | "always" | "never";
5587
5880
  alwaysInline: boolean;
5588
5881
  container: HTMLElement | null | undefined;
5589
5882
  keyboardTrap: boolean;
@@ -5631,11 +5924,30 @@ type: StringConstructor;
5631
5924
  required: false;
5632
5925
  default: string;
5633
5926
  };
5927
+ options: {
5928
+ type: PropType<string[] | undefined>;
5929
+ required: false;
5930
+ default: () => undefined;
5931
+ };
5932
+ disabled: {
5933
+ type: BooleanConstructor;
5934
+ required: false;
5935
+ default: boolean;
5936
+ };
5634
5937
  }>, {
5635
5938
  textFieldTableMode: boolean;
5939
+ viewValue: Ref<string, string>;
5940
+ onOptionSelected: (value: string) => void;
5941
+ dropdownId: string;
5942
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
5943
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
5944
+ activeOptionId: string;
5945
+ activeOption: Readonly<Ref<string | null, string | null>>;
5946
+ toggleDropdown: () => void;
5947
+ selectOption: (value: string) => void;
5948
+ closeDropdown: () => void;
5636
5949
  }, {
5637
5950
  showErrorPopup: boolean;
5638
- viewValue: string;
5639
5951
  lastModelValue: unknown;
5640
5952
  validationMessage: string;
5641
5953
  validityMode: string;
@@ -5655,6 +5967,8 @@ labelWrapperClass(): string | undefined;
5655
5967
  inputWrapperClass(): string | undefined;
5656
5968
  isModelUpdatedProgrammatically(): boolean;
5657
5969
  }, {
5970
+ onDropdownSelect(value: string): void;
5971
+ onDropdownClose(): void;
5658
5972
  getErrorPopupAnchor(): HTMLElement;
5659
5973
  closePopupError(): void;
5660
5974
  onChange(): Promise<void>;
@@ -5708,6 +6022,16 @@ type: StringConstructor;
5708
6022
  required: false;
5709
6023
  default: string;
5710
6024
  };
6025
+ options: {
6026
+ type: PropType<string[] | undefined>;
6027
+ required: false;
6028
+ default: () => undefined;
6029
+ };
6030
+ disabled: {
6031
+ type: BooleanConstructor;
6032
+ required: false;
6033
+ default: boolean;
6034
+ };
5711
6035
  }>> & Readonly<{
5712
6036
  onBlur?: ((...args: any[]) => any) | undefined;
5713
6037
  onChange?: ((...args: any[]) => any) | undefined;
@@ -5718,6 +6042,8 @@ type: string;
5718
6042
  id: string;
5719
6043
  modelValue: string | number;
5720
6044
  inline: boolean;
6045
+ disabled: boolean;
6046
+ options: string[] | undefined;
5721
6047
  labelWidth: string;
5722
6048
  formatter: FormatFunction<any>;
5723
6049
  parser: ParseFunction<any>;
@@ -5956,6 +6282,34 @@ flip: string;
5956
6282
  rotate: string;
5957
6283
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
5958
6284
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6285
+ IComboboxDropdown: DefineComponent< {
6286
+ id: string;
6287
+ isOpen: boolean;
6288
+ options: string[];
6289
+ activeOption: string | null;
6290
+ activeOptionId: string;
6291
+ inputNode: HTMLInputElement;
6292
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
6293
+ close: () => any;
6294
+ select: (option: string) => any;
6295
+ }, string, PublicProps, Readonly<{
6296
+ id: string;
6297
+ isOpen: boolean;
6298
+ options: string[];
6299
+ activeOption: string | null;
6300
+ activeOptionId: string;
6301
+ inputNode: HTMLInputElement;
6302
+ }> & Readonly<{
6303
+ onClose?: (() => any) | undefined;
6304
+ onSelect?: ((option: string) => any) | undefined;
6305
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
6306
+ listbox: HTMLUListElement;
6307
+ }, HTMLDivElement>;
6308
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
6309
+ toggle: () => any;
6310
+ }, string, PublicProps, Readonly<{}> & Readonly<{
6311
+ onToggle?: (() => any) | undefined;
6312
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
5959
6313
  }, {}, string, ComponentProvideOptions, true, {}, any>;
5960
6314
  FIcon: DefineComponent<ExtractPropTypes< {
5961
6315
  name: {
@@ -6362,11 +6716,30 @@ type: StringConstructor;
6362
6716
  required: false;
6363
6717
  default: string;
6364
6718
  };
6719
+ options: {
6720
+ type: PropType<string[] | undefined>;
6721
+ required: false;
6722
+ default: () => undefined;
6723
+ };
6724
+ disabled: {
6725
+ type: BooleanConstructor;
6726
+ required: false;
6727
+ default: boolean;
6728
+ };
6365
6729
  }>, {
6366
6730
  textFieldTableMode: boolean;
6731
+ viewValue: Ref<string, string>;
6732
+ onOptionSelected: (value: string) => void;
6733
+ dropdownId: string;
6734
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
6735
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
6736
+ activeOptionId: string;
6737
+ activeOption: Readonly<Ref<string | null, string | null>>;
6738
+ toggleDropdown: () => void;
6739
+ selectOption: (value: string) => void;
6740
+ closeDropdown: () => void;
6367
6741
  }, {
6368
6742
  showErrorPopup: boolean;
6369
- viewValue: string;
6370
6743
  lastModelValue: unknown;
6371
6744
  validationMessage: string;
6372
6745
  validityMode: string;
@@ -6386,6 +6759,8 @@ labelWrapperClass(): string | undefined;
6386
6759
  inputWrapperClass(): string | undefined;
6387
6760
  isModelUpdatedProgrammatically(): boolean;
6388
6761
  }, {
6762
+ onDropdownSelect(value: string): void;
6763
+ onDropdownClose(): void;
6389
6764
  getErrorPopupAnchor(): HTMLElement;
6390
6765
  closePopupError(): void;
6391
6766
  onChange(): Promise<void>;
@@ -6439,6 +6814,16 @@ type: StringConstructor;
6439
6814
  required: false;
6440
6815
  default: string;
6441
6816
  };
6817
+ options: {
6818
+ type: PropType<string[] | undefined>;
6819
+ required: false;
6820
+ default: () => undefined;
6821
+ };
6822
+ disabled: {
6823
+ type: BooleanConstructor;
6824
+ required: false;
6825
+ default: boolean;
6826
+ };
6442
6827
  }>> & Readonly<{
6443
6828
  onBlur?: ((...args: any[]) => any) | undefined;
6444
6829
  onChange?: ((...args: any[]) => any) | undefined;
@@ -6449,6 +6834,8 @@ type: string;
6449
6834
  id: string;
6450
6835
  modelValue: string | number;
6451
6836
  inline: boolean;
6837
+ disabled: boolean;
6838
+ options: string[] | undefined;
6452
6839
  labelWidth: string;
6453
6840
  formatter: FormatFunction<any>;
6454
6841
  parser: ParseFunction<any>;
@@ -6687,6 +7074,34 @@ flip: string;
6687
7074
  rotate: string;
6688
7075
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
6689
7076
  }, {}, string, ComponentProvideOptions, true, {}, any>;
7077
+ IComboboxDropdown: DefineComponent< {
7078
+ id: string;
7079
+ isOpen: boolean;
7080
+ options: string[];
7081
+ activeOption: string | null;
7082
+ activeOptionId: string;
7083
+ inputNode: HTMLInputElement;
7084
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
7085
+ close: () => any;
7086
+ select: (option: string) => any;
7087
+ }, string, PublicProps, Readonly<{
7088
+ id: string;
7089
+ isOpen: boolean;
7090
+ options: string[];
7091
+ activeOption: string | null;
7092
+ activeOptionId: string;
7093
+ inputNode: HTMLInputElement;
7094
+ }> & Readonly<{
7095
+ onClose?: (() => any) | undefined;
7096
+ onSelect?: ((option: string) => any) | undefined;
7097
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
7098
+ listbox: HTMLUListElement;
7099
+ }, HTMLDivElement>;
7100
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
7101
+ toggle: () => any;
7102
+ }, string, PublicProps, Readonly<{}> & Readonly<{
7103
+ onToggle?: (() => any) | undefined;
7104
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
6690
7105
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6691
7106
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6692
7107
 
@@ -7255,9 +7670,9 @@ onToggle?: ((...args: any[]) => any) | undefined;
7255
7670
  }>, {
7256
7671
  id: string;
7257
7672
  expanded: boolean;
7673
+ list: boolean;
7258
7674
  headerTag: string;
7259
7675
  headerVisualTag: string;
7260
- list: boolean;
7261
7676
  }, {}, {
7262
7677
  FIcon: DefineComponent<ExtractPropTypes< {
7263
7678
  name: {
@@ -8492,9 +8907,9 @@ value: Record<string, any>;
8492
8907
  size: string;
8493
8908
  isOpen: boolean;
8494
8909
  fullscreen: boolean;
8495
- beforeSubmit: FValidationFormCallback;
8496
8910
  ariaCloseText: string;
8497
8911
  buttons: FModalButtonDescriptor[];
8912
+ beforeSubmit: FValidationFormCallback;
8498
8913
  beforeValidation: FValidationFormCallback;
8499
8914
  useErrorList: boolean;
8500
8915
  dataTest: string;
@@ -8586,8 +9001,8 @@ validator(value: string): boolean;
8586
9001
  }>> & Readonly<{
8587
9002
  onClose?: ((...args: any[]) => any) | undefined;
8588
9003
  }>, {
8589
- focus: "on" | "off" | "open";
8590
9004
  type: "" | "warning" | "error" | "information";
9005
+ focus: "on" | "off" | "open";
8591
9006
  size: string;
8592
9007
  isOpen: boolean;
8593
9008
  fullscreen: boolean;
@@ -8724,8 +9139,8 @@ default(): BeforeNavigate;
8724
9139
  }>> & Readonly<{
8725
9140
  onSubmit?: ((...args: any[]) => any) | undefined;
8726
9141
  }>, {
8727
- beforeSubmit: FValidationFormCallback;
8728
9142
  id: string;
9143
+ beforeSubmit: FValidationFormCallback;
8729
9144
  beforeValidation: FValidationFormCallback;
8730
9145
  useErrorList: boolean;
8731
9146
  errorListBullets: boolean;
@@ -9746,17 +10161,17 @@ onClick?: ((...args: any[]) => any) | undefined;
9746
10161
  onSelect?: ((...args: any[]) => any) | undefined;
9747
10162
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
9748
10163
  onUpdate?: ((...args: any[]) => any) | undefined;
9749
- onUnselect?: ((...args: any[]) => any) | undefined;
9750
10164
  onCollapse?: ((...args: any[]) => any) | undefined;
9751
10165
  onExpand?: ((...args: any[]) => any) | undefined;
10166
+ onUnselect?: ((...args: any[]) => any) | undefined;
9752
10167
  }>, {
9753
10168
  scroll: TableScroll;
9754
10169
  modelValue: ListArray | undefined;
9755
10170
  striped: boolean;
9756
- selectable: boolean;
9757
10171
  hover: boolean;
9758
10172
  expandableAttribute: string;
9759
10173
  expandableDescribedby: string;
10174
+ selectable: boolean;
9760
10175
  }, {}, {
9761
10176
  FCheckboxField: DefineComponent<ExtractPropTypes< {
9762
10177
  disabled: {
@@ -10997,8 +11412,8 @@ validator(value: string): boolean;
10997
11412
  }>> & Readonly<{
10998
11413
  onClose?: ((...args: any[]) => any) | undefined;
10999
11414
  }>, {
11000
- focus: "on" | "off" | "open";
11001
11415
  type: "" | "warning" | "error" | "information";
11416
+ focus: "on" | "off" | "open";
11002
11417
  size: string;
11003
11418
  isOpen: boolean;
11004
11419
  fullscreen: boolean;
@@ -11419,9 +11834,9 @@ onClose?: ((...args: any[]) => any) | undefined;
11419
11834
  }>, {
11420
11835
  anchor: HTMLElement | undefined;
11421
11836
  modelValue: string;
11422
- ariaLabel: string;
11423
11837
  focusedItem: string;
11424
11838
  enableKeyboardNavigation: boolean;
11839
+ ariaLabel: string;
11425
11840
  selectedMenuItemScreenReaderText: string;
11426
11841
  }, {}, {
11427
11842
  IPopup: DefineComponent<ExtractPropTypes< {
@@ -11539,7 +11954,7 @@ onOpen?: ((...args: any[]) => any) | undefined;
11539
11954
  }>, {
11540
11955
  anchor: HTMLElement | null | undefined;
11541
11956
  viewport: HTMLElement;
11542
- inline: "always" | "never" | "auto";
11957
+ inline: "auto" | "always" | "never";
11543
11958
  alwaysInline: boolean;
11544
11959
  container: HTMLElement | null | undefined;
11545
11960
  keyboardTrap: boolean;
@@ -11583,6 +11998,16 @@ default: typeof parseNumber;
11583
11998
  };
11584
11999
  }>, {
11585
12000
  textFieldTableMode: boolean;
12001
+ viewValue: Ref<string>;
12002
+ onOptionSelected: (value: string) => void;
12003
+ dropdownId: string;
12004
+ dropdownIsOpen: Readonly<Ref<boolean>>;
12005
+ dropdownOptions: Readonly<Ref<string[]>>;
12006
+ activeOptionId: string;
12007
+ activeOption: Readonly<Ref<string | null>>;
12008
+ toggleDropdown: () => void;
12009
+ selectOption: (value: string) => void;
12010
+ closeDropdown: () => void;
11586
12011
  }, {}, {}, {}, ComponentOptionsMixin, DefineComponent<ExtractPropTypes< {
11587
12012
  id: {
11588
12013
  type: StringConstructor;
@@ -11624,11 +12049,30 @@ type: StringConstructor;
11624
12049
  required: false;
11625
12050
  default: string;
11626
12051
  };
12052
+ options: {
12053
+ type: PropType<string[] | undefined>;
12054
+ required: false;
12055
+ default: () => undefined;
12056
+ };
12057
+ disabled: {
12058
+ type: BooleanConstructor;
12059
+ required: false;
12060
+ default: boolean;
12061
+ };
11627
12062
  }>, {
11628
12063
  textFieldTableMode: boolean;
12064
+ viewValue: Ref<string, string>;
12065
+ onOptionSelected: (value: string) => void;
12066
+ dropdownId: string;
12067
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
12068
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
12069
+ activeOptionId: string;
12070
+ activeOption: Readonly<Ref<string | null, string | null>>;
12071
+ toggleDropdown: () => void;
12072
+ selectOption: (value: string) => void;
12073
+ closeDropdown: () => void;
11629
12074
  }, {
11630
12075
  showErrorPopup: boolean;
11631
- viewValue: string;
11632
12076
  lastModelValue: unknown;
11633
12077
  validationMessage: string;
11634
12078
  validityMode: string;
@@ -11648,6 +12092,8 @@ labelWrapperClass(): string | undefined;
11648
12092
  inputWrapperClass(): string | undefined;
11649
12093
  isModelUpdatedProgrammatically(): boolean;
11650
12094
  }, {
12095
+ onDropdownSelect(value: string): void;
12096
+ onDropdownClose(): void;
11651
12097
  getErrorPopupAnchor(): HTMLElement;
11652
12098
  closePopupError(): void;
11653
12099
  onChange(): Promise<void>;
@@ -11701,6 +12147,16 @@ type: StringConstructor;
11701
12147
  required: false;
11702
12148
  default: string;
11703
12149
  };
12150
+ options: {
12151
+ type: PropType<string[] | undefined>;
12152
+ required: false;
12153
+ default: () => undefined;
12154
+ };
12155
+ disabled: {
12156
+ type: BooleanConstructor;
12157
+ required: false;
12158
+ default: boolean;
12159
+ };
11704
12160
  }>> & Readonly<{
11705
12161
  onBlur?: ((...args: any[]) => any) | undefined;
11706
12162
  onChange?: ((...args: any[]) => any) | undefined;
@@ -11711,6 +12167,8 @@ type: string;
11711
12167
  id: string;
11712
12168
  modelValue: string | number;
11713
12169
  inline: boolean;
12170
+ disabled: boolean;
12171
+ options: string[] | undefined;
11714
12172
  labelWidth: string;
11715
12173
  formatter: FormatFunction<any>;
11716
12174
  parser: ParseFunction<any>;
@@ -11949,6 +12407,34 @@ flip: string;
11949
12407
  rotate: string;
11950
12408
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
11951
12409
  }, {}, string, ComponentProvideOptions, true, {}, any>;
12410
+ IComboboxDropdown: DefineComponent< {
12411
+ id: string;
12412
+ isOpen: boolean;
12413
+ options: string[];
12414
+ activeOption: string | null;
12415
+ activeOptionId: string;
12416
+ inputNode: HTMLInputElement;
12417
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
12418
+ close: () => any;
12419
+ select: (option: string) => any;
12420
+ }, string, PublicProps, Readonly<{
12421
+ id: string;
12422
+ isOpen: boolean;
12423
+ options: string[];
12424
+ activeOption: string | null;
12425
+ activeOptionId: string;
12426
+ inputNode: HTMLInputElement;
12427
+ }> & Readonly<{
12428
+ onClose?: (() => any) | undefined;
12429
+ onSelect?: ((option: string) => any) | undefined;
12430
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
12431
+ listbox: HTMLUListElement;
12432
+ }, HTMLDivElement>;
12433
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
12434
+ toggle: () => any;
12435
+ }, string, PublicProps, Readonly<{}> & Readonly<{
12436
+ onToggle?: (() => any) | undefined;
12437
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
11952
12438
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
11953
12439
  /**
11954
12440
  * The number of decimals to format number as.
@@ -12146,6 +12632,16 @@ default: typeof parseOrganisationsnummer;
12146
12632
  };
12147
12633
  }>, {
12148
12634
  textFieldTableMode: boolean;
12635
+ viewValue: Ref<string>;
12636
+ onOptionSelected: (value: string) => void;
12637
+ dropdownId: string;
12638
+ dropdownIsOpen: Readonly<Ref<boolean>>;
12639
+ dropdownOptions: Readonly<Ref<string[]>>;
12640
+ activeOptionId: string;
12641
+ activeOption: Readonly<Ref<string | null>>;
12642
+ toggleDropdown: () => void;
12643
+ selectOption: (value: string) => void;
12644
+ closeDropdown: () => void;
12149
12645
  }, {
12150
12646
  defaultText: string;
12151
12647
  discreteDescriptionText: string;
@@ -12189,13 +12685,32 @@ default: string;
12189
12685
  inputWidth: {
12190
12686
  type: StringConstructor;
12191
12687
  required: false;
12192
- default: string;
12688
+ default: string;
12689
+ };
12690
+ options: {
12691
+ type: PropType<string[] | undefined>;
12692
+ required: false;
12693
+ default: () => undefined;
12694
+ };
12695
+ disabled: {
12696
+ type: BooleanConstructor;
12697
+ required: false;
12698
+ default: boolean;
12193
12699
  };
12194
12700
  }>, {
12195
12701
  textFieldTableMode: boolean;
12702
+ viewValue: Ref<string, string>;
12703
+ onOptionSelected: (value: string) => void;
12704
+ dropdownId: string;
12705
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
12706
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
12707
+ activeOptionId: string;
12708
+ activeOption: Readonly<Ref<string | null, string | null>>;
12709
+ toggleDropdown: () => void;
12710
+ selectOption: (value: string) => void;
12711
+ closeDropdown: () => void;
12196
12712
  }, {
12197
12713
  showErrorPopup: boolean;
12198
- viewValue: string;
12199
12714
  lastModelValue: unknown;
12200
12715
  validationMessage: string;
12201
12716
  validityMode: string;
@@ -12215,6 +12730,8 @@ labelWrapperClass(): string | undefined;
12215
12730
  inputWrapperClass(): string | undefined;
12216
12731
  isModelUpdatedProgrammatically(): boolean;
12217
12732
  }, {
12733
+ onDropdownSelect(value: string): void;
12734
+ onDropdownClose(): void;
12218
12735
  getErrorPopupAnchor(): HTMLElement;
12219
12736
  closePopupError(): void;
12220
12737
  onChange(): Promise<void>;
@@ -12268,6 +12785,16 @@ type: StringConstructor;
12268
12785
  required: false;
12269
12786
  default: string;
12270
12787
  };
12788
+ options: {
12789
+ type: PropType<string[] | undefined>;
12790
+ required: false;
12791
+ default: () => undefined;
12792
+ };
12793
+ disabled: {
12794
+ type: BooleanConstructor;
12795
+ required: false;
12796
+ default: boolean;
12797
+ };
12271
12798
  }>> & Readonly<{
12272
12799
  onBlur?: ((...args: any[]) => any) | undefined;
12273
12800
  onChange?: ((...args: any[]) => any) | undefined;
@@ -12278,6 +12805,8 @@ type: string;
12278
12805
  id: string;
12279
12806
  modelValue: string | number;
12280
12807
  inline: boolean;
12808
+ disabled: boolean;
12809
+ options: string[] | undefined;
12281
12810
  labelWidth: string;
12282
12811
  formatter: FormatFunction<any>;
12283
12812
  parser: ParseFunction<any>;
@@ -12516,6 +13045,34 @@ flip: string;
12516
13045
  rotate: string;
12517
13046
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
12518
13047
  }, {}, string, ComponentProvideOptions, true, {}, any>;
13048
+ IComboboxDropdown: DefineComponent< {
13049
+ id: string;
13050
+ isOpen: boolean;
13051
+ options: string[];
13052
+ activeOption: string | null;
13053
+ activeOptionId: string;
13054
+ inputNode: HTMLInputElement;
13055
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
13056
+ close: () => any;
13057
+ select: (option: string) => any;
13058
+ }, string, PublicProps, Readonly<{
13059
+ id: string;
13060
+ isOpen: boolean;
13061
+ options: string[];
13062
+ activeOption: string | null;
13063
+ activeOptionId: string;
13064
+ inputNode: HTMLInputElement;
13065
+ }> & Readonly<{
13066
+ onClose?: (() => any) | undefined;
13067
+ onSelect?: ((option: string) => any) | undefined;
13068
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
13069
+ listbox: HTMLUListElement;
13070
+ }, HTMLDivElement>;
13071
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
13072
+ toggle: () => any;
13073
+ }, string, PublicProps, Readonly<{}> & Readonly<{
13074
+ onToggle?: (() => any) | undefined;
13075
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
12519
13076
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
12520
13077
  formatter: {
12521
13078
  type: PropType<FormatFunction<OrganisationsnummerString>>;
@@ -12546,7 +13103,7 @@ export declare interface FormErrorList extends ErrorItem {
12546
13103
  * @public
12547
13104
  */
12548
13105
  export declare class FormErrorList implements FormErrorList {
12549
- focusElementId?: string;
13106
+ focusElementId?: string | undefined;
12550
13107
  id: string;
12551
13108
  isValid: boolean;
12552
13109
  numberOfTimesSubmitted: number;
@@ -12576,8 +13133,6 @@ export declare type FormModalMaybeOptions = Partial<FormModalModalOptions>;
12576
13133
  export declare interface FormModalModalOptions {
12577
13134
  /** Modal size */
12578
13135
  size: "large" | "fullscreen";
12579
- /** Modal beforeSubmit callback */
12580
- beforeSubmit?: FValidationFormCallback;
12581
13136
  /** Modal props */
12582
13137
  props: Record<string, unknown | undefined>;
12583
13138
  }
@@ -12922,6 +13477,16 @@ default: typeof parsePercent;
12922
13477
  };
12923
13478
  }>, {
12924
13479
  textFieldTableMode: boolean;
13480
+ viewValue: Ref<string>;
13481
+ onOptionSelected: (value: string) => void;
13482
+ dropdownId: string;
13483
+ dropdownIsOpen: Readonly<Ref<boolean>>;
13484
+ dropdownOptions: Readonly<Ref<string[]>>;
13485
+ activeOptionId: string;
13486
+ activeOption: Readonly<Ref<string | null>>;
13487
+ toggleDropdown: () => void;
13488
+ selectOption: (value: string) => void;
13489
+ closeDropdown: () => void;
12925
13490
  }, {
12926
13491
  defaultText: string;
12927
13492
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -12965,11 +13530,30 @@ type: StringConstructor;
12965
13530
  required: false;
12966
13531
  default: string;
12967
13532
  };
13533
+ options: {
13534
+ type: PropType<string[] | undefined>;
13535
+ required: false;
13536
+ default: () => undefined;
13537
+ };
13538
+ disabled: {
13539
+ type: BooleanConstructor;
13540
+ required: false;
13541
+ default: boolean;
13542
+ };
12968
13543
  }>, {
12969
13544
  textFieldTableMode: boolean;
13545
+ viewValue: Ref<string, string>;
13546
+ onOptionSelected: (value: string) => void;
13547
+ dropdownId: string;
13548
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
13549
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
13550
+ activeOptionId: string;
13551
+ activeOption: Readonly<Ref<string | null, string | null>>;
13552
+ toggleDropdown: () => void;
13553
+ selectOption: (value: string) => void;
13554
+ closeDropdown: () => void;
12970
13555
  }, {
12971
13556
  showErrorPopup: boolean;
12972
- viewValue: string;
12973
13557
  lastModelValue: unknown;
12974
13558
  validationMessage: string;
12975
13559
  validityMode: string;
@@ -12989,6 +13573,8 @@ labelWrapperClass(): string | undefined;
12989
13573
  inputWrapperClass(): string | undefined;
12990
13574
  isModelUpdatedProgrammatically(): boolean;
12991
13575
  }, {
13576
+ onDropdownSelect(value: string): void;
13577
+ onDropdownClose(): void;
12992
13578
  getErrorPopupAnchor(): HTMLElement;
12993
13579
  closePopupError(): void;
12994
13580
  onChange(): Promise<void>;
@@ -13042,6 +13628,16 @@ type: StringConstructor;
13042
13628
  required: false;
13043
13629
  default: string;
13044
13630
  };
13631
+ options: {
13632
+ type: PropType<string[] | undefined>;
13633
+ required: false;
13634
+ default: () => undefined;
13635
+ };
13636
+ disabled: {
13637
+ type: BooleanConstructor;
13638
+ required: false;
13639
+ default: boolean;
13640
+ };
13045
13641
  }>> & Readonly<{
13046
13642
  onBlur?: ((...args: any[]) => any) | undefined;
13047
13643
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13052,6 +13648,8 @@ type: string;
13052
13648
  id: string;
13053
13649
  modelValue: string | number;
13054
13650
  inline: boolean;
13651
+ disabled: boolean;
13652
+ options: string[] | undefined;
13055
13653
  labelWidth: string;
13056
13654
  formatter: FormatFunction<any>;
13057
13655
  parser: ParseFunction<any>;
@@ -13290,6 +13888,34 @@ flip: string;
13290
13888
  rotate: string;
13291
13889
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
13292
13890
  }, {}, string, ComponentProvideOptions, true, {}, any>;
13891
+ IComboboxDropdown: DefineComponent< {
13892
+ id: string;
13893
+ isOpen: boolean;
13894
+ options: string[];
13895
+ activeOption: string | null;
13896
+ activeOptionId: string;
13897
+ inputNode: HTMLInputElement;
13898
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
13899
+ close: () => any;
13900
+ select: (option: string) => any;
13901
+ }, string, PublicProps, Readonly<{
13902
+ id: string;
13903
+ isOpen: boolean;
13904
+ options: string[];
13905
+ activeOption: string | null;
13906
+ activeOptionId: string;
13907
+ inputNode: HTMLInputElement;
13908
+ }> & Readonly<{
13909
+ onClose?: (() => any) | undefined;
13910
+ onSelect?: ((option: string) => any) | undefined;
13911
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
13912
+ listbox: HTMLUListElement;
13913
+ }, HTMLDivElement>;
13914
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
13915
+ toggle: () => any;
13916
+ }, string, PublicProps, Readonly<{}> & Readonly<{
13917
+ onToggle?: (() => any) | undefined;
13918
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
13293
13919
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
13294
13920
  /**
13295
13921
  * The number of decimals to format number as.
@@ -13328,6 +13954,16 @@ default: typeof parsePersonnummer;
13328
13954
  };
13329
13955
  }>, {
13330
13956
  textFieldTableMode: boolean;
13957
+ viewValue: Ref<string>;
13958
+ onOptionSelected: (value: string) => void;
13959
+ dropdownId: string;
13960
+ dropdownIsOpen: Readonly<Ref<boolean>>;
13961
+ dropdownOptions: Readonly<Ref<string[]>>;
13962
+ activeOptionId: string;
13963
+ activeOption: Readonly<Ref<string | null>>;
13964
+ toggleDropdown: () => void;
13965
+ selectOption: (value: string) => void;
13966
+ closeDropdown: () => void;
13331
13967
  }, {
13332
13968
  defaultText: string;
13333
13969
  discreteDescriptionText: string;
@@ -13373,11 +14009,30 @@ type: StringConstructor;
13373
14009
  required: false;
13374
14010
  default: string;
13375
14011
  };
14012
+ options: {
14013
+ type: PropType<string[] | undefined>;
14014
+ required: false;
14015
+ default: () => undefined;
14016
+ };
14017
+ disabled: {
14018
+ type: BooleanConstructor;
14019
+ required: false;
14020
+ default: boolean;
14021
+ };
13376
14022
  }>, {
13377
14023
  textFieldTableMode: boolean;
14024
+ viewValue: Ref<string, string>;
14025
+ onOptionSelected: (value: string) => void;
14026
+ dropdownId: string;
14027
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
14028
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
14029
+ activeOptionId: string;
14030
+ activeOption: Readonly<Ref<string | null, string | null>>;
14031
+ toggleDropdown: () => void;
14032
+ selectOption: (value: string) => void;
14033
+ closeDropdown: () => void;
13378
14034
  }, {
13379
14035
  showErrorPopup: boolean;
13380
- viewValue: string;
13381
14036
  lastModelValue: unknown;
13382
14037
  validationMessage: string;
13383
14038
  validityMode: string;
@@ -13397,6 +14052,8 @@ labelWrapperClass(): string | undefined;
13397
14052
  inputWrapperClass(): string | undefined;
13398
14053
  isModelUpdatedProgrammatically(): boolean;
13399
14054
  }, {
14055
+ onDropdownSelect(value: string): void;
14056
+ onDropdownClose(): void;
13400
14057
  getErrorPopupAnchor(): HTMLElement;
13401
14058
  closePopupError(): void;
13402
14059
  onChange(): Promise<void>;
@@ -13450,6 +14107,16 @@ type: StringConstructor;
13450
14107
  required: false;
13451
14108
  default: string;
13452
14109
  };
14110
+ options: {
14111
+ type: PropType<string[] | undefined>;
14112
+ required: false;
14113
+ default: () => undefined;
14114
+ };
14115
+ disabled: {
14116
+ type: BooleanConstructor;
14117
+ required: false;
14118
+ default: boolean;
14119
+ };
13453
14120
  }>> & Readonly<{
13454
14121
  onBlur?: ((...args: any[]) => any) | undefined;
13455
14122
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13460,6 +14127,8 @@ type: string;
13460
14127
  id: string;
13461
14128
  modelValue: string | number;
13462
14129
  inline: boolean;
14130
+ disabled: boolean;
14131
+ options: string[] | undefined;
13463
14132
  labelWidth: string;
13464
14133
  formatter: FormatFunction<any>;
13465
14134
  parser: ParseFunction<any>;
@@ -13698,6 +14367,34 @@ flip: string;
13698
14367
  rotate: string;
13699
14368
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
13700
14369
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14370
+ IComboboxDropdown: DefineComponent< {
14371
+ id: string;
14372
+ isOpen: boolean;
14373
+ options: string[];
14374
+ activeOption: string | null;
14375
+ activeOptionId: string;
14376
+ inputNode: HTMLInputElement;
14377
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14378
+ close: () => any;
14379
+ select: (option: string) => any;
14380
+ }, string, PublicProps, Readonly<{
14381
+ id: string;
14382
+ isOpen: boolean;
14383
+ options: string[];
14384
+ activeOption: string | null;
14385
+ activeOptionId: string;
14386
+ inputNode: HTMLInputElement;
14387
+ }> & Readonly<{
14388
+ onClose?: (() => any) | undefined;
14389
+ onSelect?: ((option: string) => any) | undefined;
14390
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
14391
+ listbox: HTMLUListElement;
14392
+ }, HTMLDivElement>;
14393
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14394
+ toggle: () => any;
14395
+ }, string, PublicProps, Readonly<{}> & Readonly<{
14396
+ onToggle?: (() => any) | undefined;
14397
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
13701
14398
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
13702
14399
  formatter: {
13703
14400
  type: PropType<FormatFunction<PersonnummerString>>;
@@ -13836,11 +14533,30 @@ type: StringConstructor;
13836
14533
  required: false;
13837
14534
  default: string;
13838
14535
  };
14536
+ options: {
14537
+ type: PropType<string[] | undefined>;
14538
+ required: false;
14539
+ default: () => undefined;
14540
+ };
14541
+ disabled: {
14542
+ type: BooleanConstructor;
14543
+ required: false;
14544
+ default: boolean;
14545
+ };
13839
14546
  }>, {
13840
14547
  textFieldTableMode: boolean;
14548
+ viewValue: Ref<string, string>;
14549
+ onOptionSelected: (value: string) => void;
14550
+ dropdownId: string;
14551
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
14552
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
14553
+ activeOptionId: string;
14554
+ activeOption: Readonly<Ref<string | null, string | null>>;
14555
+ toggleDropdown: () => void;
14556
+ selectOption: (value: string) => void;
14557
+ closeDropdown: () => void;
13841
14558
  }, {
13842
14559
  showErrorPopup: boolean;
13843
- viewValue: string;
13844
14560
  lastModelValue: unknown;
13845
14561
  validationMessage: string;
13846
14562
  validityMode: string;
@@ -13860,6 +14576,8 @@ labelWrapperClass(): string | undefined;
13860
14576
  inputWrapperClass(): string | undefined;
13861
14577
  isModelUpdatedProgrammatically(): boolean;
13862
14578
  }, {
14579
+ onDropdownSelect(value: string): void;
14580
+ onDropdownClose(): void;
13863
14581
  getErrorPopupAnchor(): HTMLElement;
13864
14582
  closePopupError(): void;
13865
14583
  onChange(): Promise<void>;
@@ -13913,6 +14631,16 @@ type: StringConstructor;
13913
14631
  required: false;
13914
14632
  default: string;
13915
14633
  };
14634
+ options: {
14635
+ type: PropType<string[] | undefined>;
14636
+ required: false;
14637
+ default: () => undefined;
14638
+ };
14639
+ disabled: {
14640
+ type: BooleanConstructor;
14641
+ required: false;
14642
+ default: boolean;
14643
+ };
13916
14644
  }>> & Readonly<{
13917
14645
  onBlur?: ((...args: any[]) => any) | undefined;
13918
14646
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13923,6 +14651,8 @@ type: string;
13923
14651
  id: string;
13924
14652
  modelValue: string | number;
13925
14653
  inline: boolean;
14654
+ disabled: boolean;
14655
+ options: string[] | undefined;
13926
14656
  labelWidth: string;
13927
14657
  formatter: FormatFunction<any>;
13928
14658
  parser: ParseFunction<any>;
@@ -14161,6 +14891,34 @@ flip: string;
14161
14891
  rotate: string;
14162
14892
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14163
14893
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14894
+ IComboboxDropdown: DefineComponent< {
14895
+ id: string;
14896
+ isOpen: boolean;
14897
+ options: string[];
14898
+ activeOption: string | null;
14899
+ activeOptionId: string;
14900
+ inputNode: HTMLInputElement;
14901
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14902
+ close: () => any;
14903
+ select: (option: string) => any;
14904
+ }, string, PublicProps, Readonly<{
14905
+ id: string;
14906
+ isOpen: boolean;
14907
+ options: string[];
14908
+ activeOption: string | null;
14909
+ activeOptionId: string;
14910
+ inputNode: HTMLInputElement;
14911
+ }> & Readonly<{
14912
+ onClose?: (() => any) | undefined;
14913
+ onSelect?: ((option: string) => any) | undefined;
14914
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
14915
+ listbox: HTMLUListElement;
14916
+ }, HTMLDivElement>;
14917
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14918
+ toggle: () => any;
14919
+ }, string, PublicProps, Readonly<{}> & Readonly<{
14920
+ onToggle?: (() => any) | undefined;
14921
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
14164
14922
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14165
14923
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14166
14924
 
@@ -14172,6 +14930,16 @@ default: typeof parsePlusgiro;
14172
14930
  };
14173
14931
  }>, {
14174
14932
  textFieldTableMode: boolean;
14933
+ viewValue: Ref<string>;
14934
+ onOptionSelected: (value: string) => void;
14935
+ dropdownId: string;
14936
+ dropdownIsOpen: Readonly<Ref<boolean>>;
14937
+ dropdownOptions: Readonly<Ref<string[]>>;
14938
+ activeOptionId: string;
14939
+ activeOption: Readonly<Ref<string | null>>;
14940
+ toggleDropdown: () => void;
14941
+ selectOption: (value: string) => void;
14942
+ closeDropdown: () => void;
14175
14943
  }, {
14176
14944
  defaultText: string;
14177
14945
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -14215,11 +14983,30 @@ type: StringConstructor;
14215
14983
  required: false;
14216
14984
  default: string;
14217
14985
  };
14986
+ options: {
14987
+ type: PropType<string[] | undefined>;
14988
+ required: false;
14989
+ default: () => undefined;
14990
+ };
14991
+ disabled: {
14992
+ type: BooleanConstructor;
14993
+ required: false;
14994
+ default: boolean;
14995
+ };
14218
14996
  }>, {
14219
14997
  textFieldTableMode: boolean;
14998
+ viewValue: Ref<string, string>;
14999
+ onOptionSelected: (value: string) => void;
15000
+ dropdownId: string;
15001
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
15002
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
15003
+ activeOptionId: string;
15004
+ activeOption: Readonly<Ref<string | null, string | null>>;
15005
+ toggleDropdown: () => void;
15006
+ selectOption: (value: string) => void;
15007
+ closeDropdown: () => void;
14220
15008
  }, {
14221
15009
  showErrorPopup: boolean;
14222
- viewValue: string;
14223
15010
  lastModelValue: unknown;
14224
15011
  validationMessage: string;
14225
15012
  validityMode: string;
@@ -14239,6 +15026,8 @@ labelWrapperClass(): string | undefined;
14239
15026
  inputWrapperClass(): string | undefined;
14240
15027
  isModelUpdatedProgrammatically(): boolean;
14241
15028
  }, {
15029
+ onDropdownSelect(value: string): void;
15030
+ onDropdownClose(): void;
14242
15031
  getErrorPopupAnchor(): HTMLElement;
14243
15032
  closePopupError(): void;
14244
15033
  onChange(): Promise<void>;
@@ -14292,6 +15081,16 @@ type: StringConstructor;
14292
15081
  required: false;
14293
15082
  default: string;
14294
15083
  };
15084
+ options: {
15085
+ type: PropType<string[] | undefined>;
15086
+ required: false;
15087
+ default: () => undefined;
15088
+ };
15089
+ disabled: {
15090
+ type: BooleanConstructor;
15091
+ required: false;
15092
+ default: boolean;
15093
+ };
14295
15094
  }>> & Readonly<{
14296
15095
  onBlur?: ((...args: any[]) => any) | undefined;
14297
15096
  onChange?: ((...args: any[]) => any) | undefined;
@@ -14302,6 +15101,8 @@ type: string;
14302
15101
  id: string;
14303
15102
  modelValue: string | number;
14304
15103
  inline: boolean;
15104
+ disabled: boolean;
15105
+ options: string[] | undefined;
14305
15106
  labelWidth: string;
14306
15107
  formatter: FormatFunction<any>;
14307
15108
  parser: ParseFunction<any>;
@@ -14540,6 +15341,34 @@ flip: string;
14540
15341
  rotate: string;
14541
15342
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14542
15343
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15344
+ IComboboxDropdown: DefineComponent< {
15345
+ id: string;
15346
+ isOpen: boolean;
15347
+ options: string[];
15348
+ activeOption: string | null;
15349
+ activeOptionId: string;
15350
+ inputNode: HTMLInputElement;
15351
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15352
+ close: () => any;
15353
+ select: (option: string) => any;
15354
+ }, string, PublicProps, Readonly<{
15355
+ id: string;
15356
+ isOpen: boolean;
15357
+ options: string[];
15358
+ activeOption: string | null;
15359
+ activeOptionId: string;
15360
+ inputNode: HTMLInputElement;
15361
+ }> & Readonly<{
15362
+ onClose?: (() => any) | undefined;
15363
+ onSelect?: ((option: string) => any) | undefined;
15364
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
15365
+ listbox: HTMLUListElement;
15366
+ }, HTMLDivElement>;
15367
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15368
+ toggle: () => any;
15369
+ }, string, PublicProps, Readonly<{}> & Readonly<{
15370
+ onToggle?: (() => any) | undefined;
15371
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
14543
15372
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
14544
15373
  formatter: {
14545
15374
  type: PropType<FormatFunction<PlusgiroString>>;
@@ -14558,6 +15387,16 @@ default: typeof formatPostalCode;
14558
15387
  };
14559
15388
  }>, {
14560
15389
  textFieldTableMode: boolean;
15390
+ viewValue: Ref<string>;
15391
+ onOptionSelected: (value: string) => void;
15392
+ dropdownId: string;
15393
+ dropdownIsOpen: Readonly<Ref<boolean>>;
15394
+ dropdownOptions: Readonly<Ref<string[]>>;
15395
+ activeOptionId: string;
15396
+ activeOption: Readonly<Ref<string | null>>;
15397
+ toggleDropdown: () => void;
15398
+ selectOption: (value: string) => void;
15399
+ closeDropdown: () => void;
14561
15400
  }, {
14562
15401
  defaultText: string;
14563
15402
  discreteDescriptionText: string;
@@ -14603,11 +15442,30 @@ type: StringConstructor;
14603
15442
  required: false;
14604
15443
  default: string;
14605
15444
  };
15445
+ options: {
15446
+ type: PropType<string[] | undefined>;
15447
+ required: false;
15448
+ default: () => undefined;
15449
+ };
15450
+ disabled: {
15451
+ type: BooleanConstructor;
15452
+ required: false;
15453
+ default: boolean;
15454
+ };
14606
15455
  }>, {
14607
15456
  textFieldTableMode: boolean;
15457
+ viewValue: Ref<string, string>;
15458
+ onOptionSelected: (value: string) => void;
15459
+ dropdownId: string;
15460
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
15461
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
15462
+ activeOptionId: string;
15463
+ activeOption: Readonly<Ref<string | null, string | null>>;
15464
+ toggleDropdown: () => void;
15465
+ selectOption: (value: string) => void;
15466
+ closeDropdown: () => void;
14608
15467
  }, {
14609
15468
  showErrorPopup: boolean;
14610
- viewValue: string;
14611
15469
  lastModelValue: unknown;
14612
15470
  validationMessage: string;
14613
15471
  validityMode: string;
@@ -14627,6 +15485,8 @@ labelWrapperClass(): string | undefined;
14627
15485
  inputWrapperClass(): string | undefined;
14628
15486
  isModelUpdatedProgrammatically(): boolean;
14629
15487
  }, {
15488
+ onDropdownSelect(value: string): void;
15489
+ onDropdownClose(): void;
14630
15490
  getErrorPopupAnchor(): HTMLElement;
14631
15491
  closePopupError(): void;
14632
15492
  onChange(): Promise<void>;
@@ -14680,6 +15540,16 @@ type: StringConstructor;
14680
15540
  required: false;
14681
15541
  default: string;
14682
15542
  };
15543
+ options: {
15544
+ type: PropType<string[] | undefined>;
15545
+ required: false;
15546
+ default: () => undefined;
15547
+ };
15548
+ disabled: {
15549
+ type: BooleanConstructor;
15550
+ required: false;
15551
+ default: boolean;
15552
+ };
14683
15553
  }>> & Readonly<{
14684
15554
  onBlur?: ((...args: any[]) => any) | undefined;
14685
15555
  onChange?: ((...args: any[]) => any) | undefined;
@@ -14690,6 +15560,8 @@ type: string;
14690
15560
  id: string;
14691
15561
  modelValue: string | number;
14692
15562
  inline: boolean;
15563
+ disabled: boolean;
15564
+ options: string[] | undefined;
14693
15565
  labelWidth: string;
14694
15566
  formatter: FormatFunction<any>;
14695
15567
  parser: ParseFunction<any>;
@@ -14928,6 +15800,34 @@ flip: string;
14928
15800
  rotate: string;
14929
15801
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14930
15802
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15803
+ IComboboxDropdown: DefineComponent< {
15804
+ id: string;
15805
+ isOpen: boolean;
15806
+ options: string[];
15807
+ activeOption: string | null;
15808
+ activeOptionId: string;
15809
+ inputNode: HTMLInputElement;
15810
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15811
+ close: () => any;
15812
+ select: (option: string) => any;
15813
+ }, string, PublicProps, Readonly<{
15814
+ id: string;
15815
+ isOpen: boolean;
15816
+ options: string[];
15817
+ activeOption: string | null;
15818
+ activeOptionId: string;
15819
+ inputNode: HTMLInputElement;
15820
+ }> & Readonly<{
15821
+ onClose?: (() => any) | undefined;
15822
+ onSelect?: ((option: string) => any) | undefined;
15823
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
15824
+ listbox: HTMLUListElement;
15825
+ }, HTMLDivElement>;
15826
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15827
+ toggle: () => any;
15828
+ }, string, PublicProps, Readonly<{}> & Readonly<{
15829
+ onToggle?: (() => any) | undefined;
15830
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
14931
15831
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
14932
15832
  formatter: {
14933
15833
  type: PropType<FormatFunction<PostalCodeString>>;
@@ -15332,11 +16232,30 @@ type: StringConstructor;
15332
16232
  required: false;
15333
16233
  default: string;
15334
16234
  };
16235
+ options: {
16236
+ type: PropType<string[] | undefined>;
16237
+ required: false;
16238
+ default: () => undefined;
16239
+ };
16240
+ disabled: {
16241
+ type: BooleanConstructor;
16242
+ required: false;
16243
+ default: boolean;
16244
+ };
15335
16245
  }>, {
15336
16246
  textFieldTableMode: boolean;
16247
+ viewValue: Ref<string, string>;
16248
+ onOptionSelected: (value: string) => void;
16249
+ dropdownId: string;
16250
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
16251
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
16252
+ activeOptionId: string;
16253
+ activeOption: Readonly<Ref<string | null, string | null>>;
16254
+ toggleDropdown: () => void;
16255
+ selectOption: (value: string) => void;
16256
+ closeDropdown: () => void;
15337
16257
  }, {
15338
16258
  showErrorPopup: boolean;
15339
- viewValue: string;
15340
16259
  lastModelValue: unknown;
15341
16260
  validationMessage: string;
15342
16261
  validityMode: string;
@@ -15356,6 +16275,8 @@ labelWrapperClass(): string | undefined;
15356
16275
  inputWrapperClass(): string | undefined;
15357
16276
  isModelUpdatedProgrammatically(): boolean;
15358
16277
  }, {
16278
+ onDropdownSelect(value: string): void;
16279
+ onDropdownClose(): void;
15359
16280
  getErrorPopupAnchor(): HTMLElement;
15360
16281
  closePopupError(): void;
15361
16282
  onChange(): Promise<void>;
@@ -15409,6 +16330,16 @@ type: StringConstructor;
15409
16330
  required: false;
15410
16331
  default: string;
15411
16332
  };
16333
+ options: {
16334
+ type: PropType<string[] | undefined>;
16335
+ required: false;
16336
+ default: () => undefined;
16337
+ };
16338
+ disabled: {
16339
+ type: BooleanConstructor;
16340
+ required: false;
16341
+ default: boolean;
16342
+ };
15412
16343
  }>> & Readonly<{
15413
16344
  onBlur?: ((...args: any[]) => any) | undefined;
15414
16345
  onChange?: ((...args: any[]) => any) | undefined;
@@ -15419,6 +16350,8 @@ type: string;
15419
16350
  id: string;
15420
16351
  modelValue: string | number;
15421
16352
  inline: boolean;
16353
+ disabled: boolean;
16354
+ options: string[] | undefined;
15422
16355
  labelWidth: string;
15423
16356
  formatter: FormatFunction<any>;
15424
16357
  parser: ParseFunction<any>;
@@ -15657,6 +16590,34 @@ flip: string;
15657
16590
  rotate: string;
15658
16591
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
15659
16592
  }, {}, string, ComponentProvideOptions, true, {}, any>;
16593
+ IComboboxDropdown: DefineComponent< {
16594
+ id: string;
16595
+ isOpen: boolean;
16596
+ options: string[];
16597
+ activeOption: string | null;
16598
+ activeOptionId: string;
16599
+ inputNode: HTMLInputElement;
16600
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
16601
+ close: () => any;
16602
+ select: (option: string) => any;
16603
+ }, string, PublicProps, Readonly<{
16604
+ id: string;
16605
+ isOpen: boolean;
16606
+ options: string[];
16607
+ activeOption: string | null;
16608
+ activeOptionId: string;
16609
+ inputNode: HTMLInputElement;
16610
+ }> & Readonly<{
16611
+ onClose?: (() => any) | undefined;
16612
+ onSelect?: ((option: string) => any) | undefined;
16613
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
16614
+ listbox: HTMLUListElement;
16615
+ }, HTMLDivElement>;
16616
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
16617
+ toggle: () => any;
16618
+ }, string, PublicProps, Readonly<{}> & Readonly<{
16619
+ onToggle?: (() => any) | undefined;
16620
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
15660
16621
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15661
16622
  FIcon: DefineComponent<ExtractPropTypes< {
15662
16623
  name: {
@@ -15780,7 +16741,7 @@ labelClass(): string;
15780
16741
  labelWrapperClass(): string | undefined;
15781
16742
  selectWrapperClass(): string | undefined;
15782
16743
  vModel: {
15783
- get(): string | number | boolean | Record<string, any> | unknown[] | undefined;
16744
+ get(): string | number | boolean | unknown[] | Record<string, any> | undefined;
15784
16745
  set(value: unknown): void;
15785
16746
  };
15786
16747
  }, {
@@ -15843,7 +16804,7 @@ onChange?: ((...args: any[]) => any) | undefined;
15843
16804
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
15844
16805
  }>, {
15845
16806
  id: string;
15846
- modelValue: string | number | boolean | Record<string, any> | unknown[];
16807
+ modelValue: string | number | boolean | unknown[] | Record<string, any>;
15847
16808
  inline: boolean;
15848
16809
  labelWidth: string;
15849
16810
  selectWidth: string;
@@ -16165,7 +17126,7 @@ labelClass(): string;
16165
17126
  labelWrapperClass(): string | undefined;
16166
17127
  selectWrapperClass(): string | undefined;
16167
17128
  vModel: {
16168
- get(): string | number | boolean | Record<string, any> | unknown[] | undefined;
17129
+ get(): string | number | boolean | unknown[] | Record<string, any> | undefined;
16169
17130
  set(value: unknown): void;
16170
17131
  };
16171
17132
  }, {
@@ -16201,7 +17162,7 @@ onChange?: ((...args: any[]) => any) | undefined;
16201
17162
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
16202
17163
  }>, {
16203
17164
  id: string;
16204
- modelValue: string | number | boolean | Record<string, any> | unknown[];
17165
+ modelValue: string | number | boolean | unknown[] | Record<string, any>;
16205
17166
  inline: boolean;
16206
17167
  labelWidth: string;
16207
17168
  selectWidth: string;
@@ -16380,11 +17341,30 @@ type: StringConstructor;
16380
17341
  required: false;
16381
17342
  default: string;
16382
17343
  };
17344
+ options: {
17345
+ type: PropType<string[] | undefined>;
17346
+ required: false;
17347
+ default: () => undefined;
17348
+ };
17349
+ disabled: {
17350
+ type: BooleanConstructor;
17351
+ required: false;
17352
+ default: boolean;
17353
+ };
16383
17354
  }>, {
16384
17355
  textFieldTableMode: boolean;
17356
+ viewValue: Ref<string, string>;
17357
+ onOptionSelected: (value: string) => void;
17358
+ dropdownId: string;
17359
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
17360
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
17361
+ activeOptionId: string;
17362
+ activeOption: Readonly<Ref<string | null, string | null>>;
17363
+ toggleDropdown: () => void;
17364
+ selectOption: (value: string) => void;
17365
+ closeDropdown: () => void;
16385
17366
  }, {
16386
17367
  showErrorPopup: boolean;
16387
- viewValue: string;
16388
17368
  lastModelValue: unknown;
16389
17369
  validationMessage: string;
16390
17370
  validityMode: string;
@@ -16404,6 +17384,8 @@ labelWrapperClass(): string | undefined;
16404
17384
  inputWrapperClass(): string | undefined;
16405
17385
  isModelUpdatedProgrammatically(): boolean;
16406
17386
  }, {
17387
+ onDropdownSelect(value: string): void;
17388
+ onDropdownClose(): void;
16407
17389
  getErrorPopupAnchor(): HTMLElement;
16408
17390
  closePopupError(): void;
16409
17391
  onChange(): Promise<void>;
@@ -16457,6 +17439,16 @@ type: StringConstructor;
16457
17439
  required: false;
16458
17440
  default: string;
16459
17441
  };
17442
+ options: {
17443
+ type: PropType<string[] | undefined>;
17444
+ required: false;
17445
+ default: () => undefined;
17446
+ };
17447
+ disabled: {
17448
+ type: BooleanConstructor;
17449
+ required: false;
17450
+ default: boolean;
17451
+ };
16460
17452
  }>> & Readonly<{
16461
17453
  onBlur?: ((...args: any[]) => any) | undefined;
16462
17454
  onChange?: ((...args: any[]) => any) | undefined;
@@ -16467,6 +17459,8 @@ type: string;
16467
17459
  id: string;
16468
17460
  modelValue: string | number;
16469
17461
  inline: boolean;
17462
+ disabled: boolean;
17463
+ options: string[] | undefined;
16470
17464
  labelWidth: string;
16471
17465
  formatter: FormatFunction<any>;
16472
17466
  parser: ParseFunction<any>;
@@ -16705,6 +17699,34 @@ flip: string;
16705
17699
  rotate: string;
16706
17700
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
16707
17701
  }, {}, string, ComponentProvideOptions, true, {}, any>;
17702
+ IComboboxDropdown: DefineComponent< {
17703
+ id: string;
17704
+ isOpen: boolean;
17705
+ options: string[];
17706
+ activeOption: string | null;
17707
+ activeOptionId: string;
17708
+ inputNode: HTMLInputElement;
17709
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
17710
+ close: () => any;
17711
+ select: (option: string) => any;
17712
+ }, string, PublicProps, Readonly<{
17713
+ id: string;
17714
+ isOpen: boolean;
17715
+ options: string[];
17716
+ activeOption: string | null;
17717
+ activeOptionId: string;
17718
+ inputNode: HTMLInputElement;
17719
+ }> & Readonly<{
17720
+ onClose?: (() => any) | undefined;
17721
+ onSelect?: ((option: string) => any) | undefined;
17722
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
17723
+ listbox: HTMLUListElement;
17724
+ }, HTMLDivElement>;
17725
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
17726
+ toggle: () => any;
17727
+ }, string, PublicProps, Readonly<{}> & Readonly<{
17728
+ onToggle?: (() => any) | undefined;
17729
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
16708
17730
  }, {}, string, ComponentProvideOptions, true, {}, any>;
16709
17731
  FIcon: DefineComponent<ExtractPropTypes< {
16710
17732
  name: {
@@ -17547,11 +18569,40 @@ type: StringConstructor;
17547
18569
  required: false;
17548
18570
  default: string;
17549
18571
  };
18572
+ /**
18573
+ * List of options.
18574
+ *
18575
+ * When set, the user can select a value from the list of options and filter while typing.
18576
+ *
18577
+ * If a formatter is used by the component, make sure the options are formatted as well.
18578
+ */
18579
+ options: {
18580
+ type: PropType<string[] | undefined>;
18581
+ required: false;
18582
+ default: () => undefined;
18583
+ };
18584
+ /**
18585
+ * Set to `true`, empty string `""` or string `"disabled"` to disable this field.
18586
+ */
18587
+ disabled: {
18588
+ type: BooleanConstructor;
18589
+ required: false;
18590
+ default: boolean;
18591
+ };
17550
18592
  }>, {
17551
18593
  textFieldTableMode: boolean;
18594
+ viewValue: Ref<string, string>;
18595
+ onOptionSelected: (value: string) => void;
18596
+ dropdownId: string;
18597
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
18598
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
18599
+ activeOptionId: string;
18600
+ activeOption: Readonly<Ref<string | null, string | null>>;
18601
+ toggleDropdown: () => void;
18602
+ selectOption: (value: string) => void;
18603
+ closeDropdown: () => void;
17552
18604
  }, {
17553
18605
  showErrorPopup: boolean;
17554
- viewValue: string;
17555
18606
  lastModelValue: unknown;
17556
18607
  validationMessage: string;
17557
18608
  validityMode: string;
@@ -17571,6 +18622,8 @@ labelWrapperClass(): string | undefined;
17571
18622
  inputWrapperClass(): string | undefined;
17572
18623
  isModelUpdatedProgrammatically(): boolean;
17573
18624
  }, {
18625
+ onDropdownSelect(value: string): void;
18626
+ onDropdownClose(): void;
17574
18627
  getErrorPopupAnchor(): HTMLElement;
17575
18628
  closePopupError(): void;
17576
18629
  onChange(): Promise<void>;
@@ -17674,6 +18727,26 @@ type: StringConstructor;
17674
18727
  required: false;
17675
18728
  default: string;
17676
18729
  };
18730
+ /**
18731
+ * List of options.
18732
+ *
18733
+ * When set, the user can select a value from the list of options and filter while typing.
18734
+ *
18735
+ * If a formatter is used by the component, make sure the options are formatted as well.
18736
+ */
18737
+ options: {
18738
+ type: PropType<string[] | undefined>;
18739
+ required: false;
18740
+ default: () => undefined;
18741
+ };
18742
+ /**
18743
+ * Set to `true`, empty string `""` or string `"disabled"` to disable this field.
18744
+ */
18745
+ disabled: {
18746
+ type: BooleanConstructor;
18747
+ required: false;
18748
+ default: boolean;
18749
+ };
17677
18750
  }>> & Readonly<{
17678
18751
  onBlur?: ((...args: any[]) => any) | undefined;
17679
18752
  onChange?: ((...args: any[]) => any) | undefined;
@@ -17684,6 +18757,8 @@ type: string;
17684
18757
  id: string;
17685
18758
  modelValue: string | number;
17686
18759
  inline: boolean;
18760
+ disabled: boolean;
18761
+ options: string[] | undefined;
17687
18762
  labelWidth: string;
17688
18763
  formatter: FormatFunction<any>;
17689
18764
  parser: ParseFunction<any>;
@@ -17922,6 +18997,34 @@ flip: string;
17922
18997
  rotate: string;
17923
18998
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
17924
18999
  }, {}, string, ComponentProvideOptions, true, {}, any>;
19000
+ IComboboxDropdown: DefineComponent< {
19001
+ id: string;
19002
+ isOpen: boolean;
19003
+ options: string[];
19004
+ activeOption: string | null;
19005
+ activeOptionId: string;
19006
+ inputNode: HTMLInputElement;
19007
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
19008
+ close: () => any;
19009
+ select: (option: string) => any;
19010
+ }, string, PublicProps, Readonly<{
19011
+ id: string;
19012
+ isOpen: boolean;
19013
+ options: string[];
19014
+ activeOption: string | null;
19015
+ activeOptionId: string;
19016
+ inputNode: HTMLInputElement;
19017
+ }> & Readonly<{
19018
+ onClose?: (() => any) | undefined;
19019
+ onSelect?: ((option: string) => any) | undefined;
19020
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
19021
+ listbox: HTMLUListElement;
19022
+ }, HTMLDivElement>;
19023
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
19024
+ toggle: () => any;
19025
+ }, string, PublicProps, Readonly<{}> & Readonly<{
19026
+ onToggle?: (() => any) | undefined;
19027
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
17925
19028
  }, {}, string, ComponentProvideOptions, true, {}, any>;
17926
19029
 
17927
19030
  export declare const FTooltip: DefineComponent<ExtractPropTypes< {
@@ -18732,8 +19835,8 @@ default(): BeforeNavigate;
18732
19835
  }>> & Readonly<{
18733
19836
  onSubmit?: ((...args: any[]) => any) | undefined;
18734
19837
  }>, {
18735
- beforeSubmit: FValidationFormCallback;
18736
19838
  id: string;
19839
+ beforeSubmit: FValidationFormCallback;
18737
19840
  beforeValidation: FValidationFormCallback;
18738
19841
  useErrorList: boolean;
18739
19842
  errorListBullets: boolean;
@@ -19594,6 +20697,22 @@ rotate: string;
19594
20697
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
19595
20698
  }, {}, string, ComponentProvideOptions, true, {}, any>;
19596
20699
 
20700
+ export declare const IComboboxDropdown: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
20701
+ close: () => any;
20702
+ select: (option: string) => any;
20703
+ }, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
20704
+ onClose?: (() => any) | undefined;
20705
+ onSelect?: ((option: string) => any) | undefined;
20706
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
20707
+ listbox: HTMLUListElement;
20708
+ }, HTMLDivElement>;
20709
+
20710
+ export declare const IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
20711
+ toggle: () => any;
20712
+ }, string, PublicProps, Readonly<{}> & Readonly<{
20713
+ onToggle?: (() => any) | undefined;
20714
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
20715
+
19597
20716
  export declare const IFlex: DefineComponent<ExtractPropTypes< {
19598
20717
  /**
19599
20718
  * Set gap (gutter) between items.
@@ -19947,7 +21066,7 @@ onOpen?: ((...args: any[]) => any) | undefined;
19947
21066
  }>, {
19948
21067
  anchor: HTMLElement | null | undefined;
19949
21068
  viewport: HTMLElement;
19950
- inline: "always" | "never" | "auto";
21069
+ inline: "auto" | "always" | "never";
19951
21070
  alwaysInline: boolean;
19952
21071
  container: HTMLElement | null | undefined;
19953
21072
  keyboardTrap: boolean;
@@ -20101,6 +21220,7 @@ declare interface IPopupListboxProps {
20101
21220
  anchor: HTMLElement | null;
20102
21221
  numOfItems: number;
20103
21222
  itemHeight?: number;
21223
+ activeElement?: HTMLElement | undefined;
20104
21224
  }
20105
21225
 
20106
21226
  export declare const IPopupMenu: DefineComponent<ExtractPropTypes< {
@@ -20262,9 +21382,9 @@ onClose?: ((...args: any[]) => any) | undefined;
20262
21382
  }>, {
20263
21383
  anchor: HTMLElement | undefined;
20264
21384
  modelValue: string;
20265
- ariaLabel: string;
20266
21385
  focusedItem: string;
20267
21386
  enableKeyboardNavigation: boolean;
21387
+ ariaLabel: string;
20268
21388
  selectedMenuItemScreenReaderText: string;
20269
21389
  }, {}, {
20270
21390
  IPopup: DefineComponent<ExtractPropTypes< {
@@ -20382,7 +21502,7 @@ onOpen?: ((...args: any[]) => any) | undefined;
20382
21502
  }>, {
20383
21503
  anchor: HTMLElement | null | undefined;
20384
21504
  viewport: HTMLElement;
20385
- inline: "always" | "never" | "auto";
21505
+ inline: "auto" | "always" | "never";
20386
21506
  alwaysInline: boolean;
20387
21507
  container: HTMLElement | null | undefined;
20388
21508
  keyboardTrap: boolean;
@@ -20574,19 +21694,19 @@ export declare interface MountOptions {
20574
21694
  */
20575
21695
  export declare interface NavigationMenuItem {
20576
21696
  /**
20577
- * Menu item label text
21697
+ * Text to display for the menu item.
20578
21698
  */
20579
21699
  label: string;
20580
21700
  /**
20581
- * Menu item route used upon for example item selection
21701
+ * Unique identifier for the menu item.
20582
21702
  */
20583
21703
  route: string;
20584
21704
  /**
20585
- * Optional href attribute to use on menu item link
21705
+ * `href` attribute to add to menu item anchor element
20586
21706
  */
20587
21707
  href?: string;
20588
21708
  /**
20589
- * Optional target attribute on menu item link
21709
+ * `target` attribute to add to menu item anchor element.
20590
21710
  */
20591
21711
  target?: string;
20592
21712
  }
@@ -20837,6 +21957,21 @@ export declare function tableScrollClasses(val: TableScroll): string[];
20837
21957
  */
20838
21958
  export declare const TestPlugin: Plugin_2;
20839
21959
 
21960
+ /**
21961
+ * @public
21962
+ */
21963
+ export declare interface TextFieldSetupProps {
21964
+ id: string;
21965
+ inline: boolean;
21966
+ modelValue: string | number;
21967
+ type: string;
21968
+ formatter?: FormatFunction<unknown>;
21969
+ parser?: ParseFunction<unknown>;
21970
+ labelWidth: string;
21971
+ inputWidth: string;
21972
+ options?: string[];
21973
+ }
21974
+
20840
21975
  /* Excluded from this release type: tooltipAttachTo */
20841
21976
 
20842
21977
  /**
@@ -20897,6 +22032,20 @@ export declare const UNHANDLED_ERROR_EVENT: "unhandled-error";
20897
22032
  */
20898
22033
  export declare type UnknownItem = Record<string, unknown>;
20899
22034
 
22035
+ /**
22036
+ * @public
22037
+ */
22038
+ export declare function useCombobox(inputRef: Readonly<ShallowRef<HTMLInputElement | null>>, options: string[] | undefined, onOptionSelected?: (value: string) => void): {
22039
+ dropdownId: string;
22040
+ dropdownIsOpen: Readonly<Ref<boolean>>;
22041
+ dropdownOptions: Readonly<Ref<string[]>>;
22042
+ activeOptionId: string;
22043
+ activeOption: Readonly<Ref<string | null>>;
22044
+ toggleDropdown: () => void;
22045
+ selectOption: (value: string) => void;
22046
+ closeDropdown: () => void;
22047
+ };
22048
+
20900
22049
  /**
20901
22050
  * Composable to get access to modal functions.
20902
22051
  *
@@ -20955,6 +22104,26 @@ export declare interface UseSlotUtils {
20955
22104
  */
20956
22105
  export declare function useSlotUtils(): UseSlotUtils;
20957
22106
 
22107
+ /**
22108
+ * Setup logic used by `FTextField`.
22109
+ * Components extending `FTextField` reuse the same setup.
22110
+ *
22111
+ * @public
22112
+ */
22113
+ export declare function useTextFieldSetup(props: TextFieldSetupProps): {
22114
+ textFieldTableMode: boolean;
22115
+ viewValue: Ref<string>;
22116
+ onOptionSelected: (value: string) => void;
22117
+ dropdownId: string;
22118
+ dropdownIsOpen: Readonly<Ref<boolean>>;
22119
+ dropdownOptions: Readonly<Ref<string[]>>;
22120
+ activeOptionId: string;
22121
+ activeOption: Readonly<Ref<string | null>>;
22122
+ toggleDropdown: () => void;
22123
+ selectOption: (value: string) => void;
22124
+ closeDropdown: () => void;
22125
+ };
22126
+
20958
22127
  /**
20959
22128
  * Translation function.
20960
22129
  * @public