@fkui/vue 5.43.0 → 5.44.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: {
@@ -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,25 @@ 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
+ };
1055
1079
  }>, {
1056
1080
  textFieldTableMode: boolean;
1081
+ viewValue: Ref<string, string>;
1082
+ onOptionSelected: (value: string) => void;
1083
+ dropdownId: string;
1084
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
1085
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
1086
+ activeOptionId: string;
1087
+ activeOption: Readonly<Ref<string | null, string | null>>;
1088
+ toggleDropdown: () => void;
1089
+ selectOption: (value: string) => void;
1090
+ closeDropdown: () => void;
1057
1091
  }, {
1058
1092
  showErrorPopup: boolean;
1059
- viewValue: string;
1060
1093
  lastModelValue: unknown;
1061
1094
  validationMessage: string;
1062
1095
  validityMode: string;
@@ -1076,6 +1109,8 @@ labelWrapperClass(): string | undefined;
1076
1109
  inputWrapperClass(): string | undefined;
1077
1110
  isModelUpdatedProgrammatically(): boolean;
1078
1111
  }, {
1112
+ onDropdownSelect(value: string): void;
1113
+ onDropdownClose(): void;
1079
1114
  getErrorPopupAnchor(): HTMLElement;
1080
1115
  closePopupError(): void;
1081
1116
  onChange(): Promise<void>;
@@ -1129,6 +1164,11 @@ type: StringConstructor;
1129
1164
  required: false;
1130
1165
  default: string;
1131
1166
  };
1167
+ options: {
1168
+ type: PropType<string[] | undefined>;
1169
+ required: false;
1170
+ default: () => undefined;
1171
+ };
1132
1172
  }>> & Readonly<{
1133
1173
  onBlur?: ((...args: any[]) => any) | undefined;
1134
1174
  onChange?: ((...args: any[]) => any) | undefined;
@@ -1139,6 +1179,7 @@ type: string;
1139
1179
  id: string;
1140
1180
  modelValue: string | number;
1141
1181
  inline: boolean;
1182
+ options: string[] | undefined;
1142
1183
  labelWidth: string;
1143
1184
  formatter: FormatFunction<any>;
1144
1185
  parser: ParseFunction<any>;
@@ -1377,6 +1418,34 @@ flip: string;
1377
1418
  rotate: string;
1378
1419
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
1379
1420
  }, {}, string, ComponentProvideOptions, true, {}, any>;
1421
+ IComboboxDropdown: DefineComponent< {
1422
+ id: string;
1423
+ isOpen: boolean;
1424
+ options: string[];
1425
+ activeOption: string | null;
1426
+ activeOptionId: string;
1427
+ inputNode: HTMLInputElement;
1428
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1429
+ close: () => any;
1430
+ select: (option: string) => any;
1431
+ }, string, PublicProps, Readonly<{
1432
+ id: string;
1433
+ isOpen: boolean;
1434
+ options: string[];
1435
+ activeOption: string | null;
1436
+ activeOptionId: string;
1437
+ inputNode: HTMLInputElement;
1438
+ }> & Readonly<{
1439
+ onClose?: (() => any) | undefined;
1440
+ onSelect?: ((option: string) => any) | undefined;
1441
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
1442
+ listbox: HTMLUListElement;
1443
+ }, HTMLDivElement>;
1444
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1445
+ toggle: () => any;
1446
+ }, string, PublicProps, Readonly<{}> & Readonly<{
1447
+ onToggle?: (() => any) | undefined;
1448
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
1380
1449
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
1381
1450
  parser: {
1382
1451
  type: PropType<ParseFunction<BankAccountNumberString>>;
@@ -1395,6 +1464,16 @@ default: typeof parseBankgiro;
1395
1464
  };
1396
1465
  }>, {
1397
1466
  textFieldTableMode: boolean;
1467
+ viewValue: Ref<string>;
1468
+ onOptionSelected: (value: string) => void;
1469
+ dropdownId: string;
1470
+ dropdownIsOpen: Readonly<Ref<boolean>>;
1471
+ dropdownOptions: Readonly<Ref<string[]>>;
1472
+ activeOptionId: string;
1473
+ activeOption: Readonly<Ref<string | null>>;
1474
+ toggleDropdown: () => void;
1475
+ selectOption: (value: string) => void;
1476
+ closeDropdown: () => void;
1398
1477
  }, {
1399
1478
  defaultText: string;
1400
1479
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -1438,11 +1517,25 @@ type: StringConstructor;
1438
1517
  required: false;
1439
1518
  default: string;
1440
1519
  };
1520
+ options: {
1521
+ type: PropType<string[] | undefined>;
1522
+ required: false;
1523
+ default: () => undefined;
1524
+ };
1441
1525
  }>, {
1442
1526
  textFieldTableMode: boolean;
1527
+ viewValue: Ref<string, string>;
1528
+ onOptionSelected: (value: string) => void;
1529
+ dropdownId: string;
1530
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
1531
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
1532
+ activeOptionId: string;
1533
+ activeOption: Readonly<Ref<string | null, string | null>>;
1534
+ toggleDropdown: () => void;
1535
+ selectOption: (value: string) => void;
1536
+ closeDropdown: () => void;
1443
1537
  }, {
1444
1538
  showErrorPopup: boolean;
1445
- viewValue: string;
1446
1539
  lastModelValue: unknown;
1447
1540
  validationMessage: string;
1448
1541
  validityMode: string;
@@ -1462,6 +1555,8 @@ labelWrapperClass(): string | undefined;
1462
1555
  inputWrapperClass(): string | undefined;
1463
1556
  isModelUpdatedProgrammatically(): boolean;
1464
1557
  }, {
1558
+ onDropdownSelect(value: string): void;
1559
+ onDropdownClose(): void;
1465
1560
  getErrorPopupAnchor(): HTMLElement;
1466
1561
  closePopupError(): void;
1467
1562
  onChange(): Promise<void>;
@@ -1515,6 +1610,11 @@ type: StringConstructor;
1515
1610
  required: false;
1516
1611
  default: string;
1517
1612
  };
1613
+ options: {
1614
+ type: PropType<string[] | undefined>;
1615
+ required: false;
1616
+ default: () => undefined;
1617
+ };
1518
1618
  }>> & Readonly<{
1519
1619
  onBlur?: ((...args: any[]) => any) | undefined;
1520
1620
  onChange?: ((...args: any[]) => any) | undefined;
@@ -1525,6 +1625,7 @@ type: string;
1525
1625
  id: string;
1526
1626
  modelValue: string | number;
1527
1627
  inline: boolean;
1628
+ options: string[] | undefined;
1528
1629
  labelWidth: string;
1529
1630
  formatter: FormatFunction<any>;
1530
1631
  parser: ParseFunction<any>;
@@ -1763,6 +1864,34 @@ flip: string;
1763
1864
  rotate: string;
1764
1865
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
1765
1866
  }, {}, string, ComponentProvideOptions, true, {}, any>;
1867
+ IComboboxDropdown: DefineComponent< {
1868
+ id: string;
1869
+ isOpen: boolean;
1870
+ options: string[];
1871
+ activeOption: string | null;
1872
+ activeOptionId: string;
1873
+ inputNode: HTMLInputElement;
1874
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1875
+ close: () => any;
1876
+ select: (option: string) => any;
1877
+ }, string, PublicProps, Readonly<{
1878
+ id: string;
1879
+ isOpen: boolean;
1880
+ options: string[];
1881
+ activeOption: string | null;
1882
+ activeOptionId: string;
1883
+ inputNode: HTMLInputElement;
1884
+ }> & Readonly<{
1885
+ onClose?: (() => any) | undefined;
1886
+ onSelect?: ((option: string) => any) | undefined;
1887
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
1888
+ listbox: HTMLUListElement;
1889
+ }, HTMLDivElement>;
1890
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1891
+ toggle: () => any;
1892
+ }, string, PublicProps, Readonly<{}> & Readonly<{
1893
+ onToggle?: (() => any) | undefined;
1894
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
1766
1895
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
1767
1896
  formatter: {
1768
1897
  type: PropType<FormatFunction<BankgiroString>>;
@@ -2360,6 +2489,16 @@ default: typeof parseClearingNumber;
2360
2489
  };
2361
2490
  }>, {
2362
2491
  textFieldTableMode: boolean;
2492
+ viewValue: Ref<string>;
2493
+ onOptionSelected: (value: string) => void;
2494
+ dropdownId: string;
2495
+ dropdownIsOpen: Readonly<Ref<boolean>>;
2496
+ dropdownOptions: Readonly<Ref<string[]>>;
2497
+ activeOptionId: string;
2498
+ activeOption: Readonly<Ref<string | null>>;
2499
+ toggleDropdown: () => void;
2500
+ selectOption: (value: string) => void;
2501
+ closeDropdown: () => void;
2363
2502
  }, {
2364
2503
  defaultText: string;
2365
2504
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -2403,11 +2542,25 @@ type: StringConstructor;
2403
2542
  required: false;
2404
2543
  default: string;
2405
2544
  };
2545
+ options: {
2546
+ type: PropType<string[] | undefined>;
2547
+ required: false;
2548
+ default: () => undefined;
2549
+ };
2406
2550
  }>, {
2407
2551
  textFieldTableMode: boolean;
2552
+ viewValue: Ref<string, string>;
2553
+ onOptionSelected: (value: string) => void;
2554
+ dropdownId: string;
2555
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
2556
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
2557
+ activeOptionId: string;
2558
+ activeOption: Readonly<Ref<string | null, string | null>>;
2559
+ toggleDropdown: () => void;
2560
+ selectOption: (value: string) => void;
2561
+ closeDropdown: () => void;
2408
2562
  }, {
2409
2563
  showErrorPopup: boolean;
2410
- viewValue: string;
2411
2564
  lastModelValue: unknown;
2412
2565
  validationMessage: string;
2413
2566
  validityMode: string;
@@ -2427,6 +2580,8 @@ labelWrapperClass(): string | undefined;
2427
2580
  inputWrapperClass(): string | undefined;
2428
2581
  isModelUpdatedProgrammatically(): boolean;
2429
2582
  }, {
2583
+ onDropdownSelect(value: string): void;
2584
+ onDropdownClose(): void;
2430
2585
  getErrorPopupAnchor(): HTMLElement;
2431
2586
  closePopupError(): void;
2432
2587
  onChange(): Promise<void>;
@@ -2480,6 +2635,11 @@ type: StringConstructor;
2480
2635
  required: false;
2481
2636
  default: string;
2482
2637
  };
2638
+ options: {
2639
+ type: PropType<string[] | undefined>;
2640
+ required: false;
2641
+ default: () => undefined;
2642
+ };
2483
2643
  }>> & Readonly<{
2484
2644
  onBlur?: ((...args: any[]) => any) | undefined;
2485
2645
  onChange?: ((...args: any[]) => any) | undefined;
@@ -2490,6 +2650,7 @@ type: string;
2490
2650
  id: string;
2491
2651
  modelValue: string | number;
2492
2652
  inline: boolean;
2653
+ options: string[] | undefined;
2493
2654
  labelWidth: string;
2494
2655
  formatter: FormatFunction<any>;
2495
2656
  parser: ParseFunction<any>;
@@ -2728,6 +2889,34 @@ flip: string;
2728
2889
  rotate: string;
2729
2890
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
2730
2891
  }, {}, string, ComponentProvideOptions, true, {}, any>;
2892
+ IComboboxDropdown: DefineComponent< {
2893
+ id: string;
2894
+ isOpen: boolean;
2895
+ options: string[];
2896
+ activeOption: string | null;
2897
+ activeOptionId: string;
2898
+ inputNode: HTMLInputElement;
2899
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
2900
+ close: () => any;
2901
+ select: (option: string) => any;
2902
+ }, string, PublicProps, Readonly<{
2903
+ id: string;
2904
+ isOpen: boolean;
2905
+ options: string[];
2906
+ activeOption: string | null;
2907
+ activeOptionId: string;
2908
+ inputNode: HTMLInputElement;
2909
+ }> & Readonly<{
2910
+ onClose?: (() => any) | undefined;
2911
+ onSelect?: ((option: string) => any) | undefined;
2912
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
2913
+ listbox: HTMLUListElement;
2914
+ }, HTMLDivElement>;
2915
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
2916
+ toggle: () => any;
2917
+ }, string, PublicProps, Readonly<{}> & Readonly<{
2918
+ onToggle?: (() => any) | undefined;
2919
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
2731
2920
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
2732
2921
  formatter: {
2733
2922
  type: PropType<FormatFunction<ClearingnumberString>>;
@@ -4519,6 +4708,16 @@ default: typeof parseNumber;
4519
4708
  };
4520
4709
  }>, {
4521
4710
  textFieldTableMode: boolean;
4711
+ viewValue: Ref<string>;
4712
+ onOptionSelected: (value: string) => void;
4713
+ dropdownId: string;
4714
+ dropdownIsOpen: Readonly<Ref<boolean>>;
4715
+ dropdownOptions: Readonly<Ref<string[]>>;
4716
+ activeOptionId: string;
4717
+ activeOption: Readonly<Ref<string | null>>;
4718
+ toggleDropdown: () => void;
4719
+ selectOption: (value: string) => void;
4720
+ closeDropdown: () => void;
4522
4721
  }, {
4523
4722
  defaultText: string;
4524
4723
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -4562,11 +4761,25 @@ type: StringConstructor;
4562
4761
  required: false;
4563
4762
  default: string;
4564
4763
  };
4764
+ options: {
4765
+ type: PropType<string[] | undefined>;
4766
+ required: false;
4767
+ default: () => undefined;
4768
+ };
4565
4769
  }>, {
4566
4770
  textFieldTableMode: boolean;
4771
+ viewValue: Ref<string, string>;
4772
+ onOptionSelected: (value: string) => void;
4773
+ dropdownId: string;
4774
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
4775
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
4776
+ activeOptionId: string;
4777
+ activeOption: Readonly<Ref<string | null, string | null>>;
4778
+ toggleDropdown: () => void;
4779
+ selectOption: (value: string) => void;
4780
+ closeDropdown: () => void;
4567
4781
  }, {
4568
4782
  showErrorPopup: boolean;
4569
- viewValue: string;
4570
4783
  lastModelValue: unknown;
4571
4784
  validationMessage: string;
4572
4785
  validityMode: string;
@@ -4586,6 +4799,8 @@ labelWrapperClass(): string | undefined;
4586
4799
  inputWrapperClass(): string | undefined;
4587
4800
  isModelUpdatedProgrammatically(): boolean;
4588
4801
  }, {
4802
+ onDropdownSelect(value: string): void;
4803
+ onDropdownClose(): void;
4589
4804
  getErrorPopupAnchor(): HTMLElement;
4590
4805
  closePopupError(): void;
4591
4806
  onChange(): Promise<void>;
@@ -4639,6 +4854,11 @@ type: StringConstructor;
4639
4854
  required: false;
4640
4855
  default: string;
4641
4856
  };
4857
+ options: {
4858
+ type: PropType<string[] | undefined>;
4859
+ required: false;
4860
+ default: () => undefined;
4861
+ };
4642
4862
  }>> & Readonly<{
4643
4863
  onBlur?: ((...args: any[]) => any) | undefined;
4644
4864
  onChange?: ((...args: any[]) => any) | undefined;
@@ -4649,6 +4869,7 @@ type: string;
4649
4869
  id: string;
4650
4870
  modelValue: string | number;
4651
4871
  inline: boolean;
4872
+ options: string[] | undefined;
4652
4873
  labelWidth: string;
4653
4874
  formatter: FormatFunction<any>;
4654
4875
  parser: ParseFunction<any>;
@@ -4887,6 +5108,34 @@ flip: string;
4887
5108
  rotate: string;
4888
5109
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
4889
5110
  }, {}, string, ComponentProvideOptions, true, {}, any>;
5111
+ IComboboxDropdown: DefineComponent< {
5112
+ id: string;
5113
+ isOpen: boolean;
5114
+ options: string[];
5115
+ activeOption: string | null;
5116
+ activeOptionId: string;
5117
+ inputNode: HTMLInputElement;
5118
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
5119
+ close: () => any;
5120
+ select: (option: string) => any;
5121
+ }, string, PublicProps, Readonly<{
5122
+ id: string;
5123
+ isOpen: boolean;
5124
+ options: string[];
5125
+ activeOption: string | null;
5126
+ activeOptionId: string;
5127
+ inputNode: HTMLInputElement;
5128
+ }> & Readonly<{
5129
+ onClose?: (() => any) | undefined;
5130
+ onSelect?: ((option: string) => any) | undefined;
5131
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
5132
+ listbox: HTMLUListElement;
5133
+ }, HTMLDivElement>;
5134
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
5135
+ toggle: () => any;
5136
+ }, string, PublicProps, Readonly<{}> & Readonly<{
5137
+ onToggle?: (() => any) | undefined;
5138
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
4890
5139
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
4891
5140
  formatter: {
4892
5141
  type: PropType<FormatFunction<number>>;
@@ -5631,11 +5880,25 @@ type: StringConstructor;
5631
5880
  required: false;
5632
5881
  default: string;
5633
5882
  };
5883
+ options: {
5884
+ type: PropType<string[] | undefined>;
5885
+ required: false;
5886
+ default: () => undefined;
5887
+ };
5634
5888
  }>, {
5635
5889
  textFieldTableMode: boolean;
5890
+ viewValue: Ref<string, string>;
5891
+ onOptionSelected: (value: string) => void;
5892
+ dropdownId: string;
5893
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
5894
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
5895
+ activeOptionId: string;
5896
+ activeOption: Readonly<Ref<string | null, string | null>>;
5897
+ toggleDropdown: () => void;
5898
+ selectOption: (value: string) => void;
5899
+ closeDropdown: () => void;
5636
5900
  }, {
5637
5901
  showErrorPopup: boolean;
5638
- viewValue: string;
5639
5902
  lastModelValue: unknown;
5640
5903
  validationMessage: string;
5641
5904
  validityMode: string;
@@ -5655,6 +5918,8 @@ labelWrapperClass(): string | undefined;
5655
5918
  inputWrapperClass(): string | undefined;
5656
5919
  isModelUpdatedProgrammatically(): boolean;
5657
5920
  }, {
5921
+ onDropdownSelect(value: string): void;
5922
+ onDropdownClose(): void;
5658
5923
  getErrorPopupAnchor(): HTMLElement;
5659
5924
  closePopupError(): void;
5660
5925
  onChange(): Promise<void>;
@@ -5708,6 +5973,11 @@ type: StringConstructor;
5708
5973
  required: false;
5709
5974
  default: string;
5710
5975
  };
5976
+ options: {
5977
+ type: PropType<string[] | undefined>;
5978
+ required: false;
5979
+ default: () => undefined;
5980
+ };
5711
5981
  }>> & Readonly<{
5712
5982
  onBlur?: ((...args: any[]) => any) | undefined;
5713
5983
  onChange?: ((...args: any[]) => any) | undefined;
@@ -5718,6 +5988,7 @@ type: string;
5718
5988
  id: string;
5719
5989
  modelValue: string | number;
5720
5990
  inline: boolean;
5991
+ options: string[] | undefined;
5721
5992
  labelWidth: string;
5722
5993
  formatter: FormatFunction<any>;
5723
5994
  parser: ParseFunction<any>;
@@ -5956,6 +6227,34 @@ flip: string;
5956
6227
  rotate: string;
5957
6228
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
5958
6229
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6230
+ IComboboxDropdown: DefineComponent< {
6231
+ id: string;
6232
+ isOpen: boolean;
6233
+ options: string[];
6234
+ activeOption: string | null;
6235
+ activeOptionId: string;
6236
+ inputNode: HTMLInputElement;
6237
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
6238
+ close: () => any;
6239
+ select: (option: string) => any;
6240
+ }, string, PublicProps, Readonly<{
6241
+ id: string;
6242
+ isOpen: boolean;
6243
+ options: string[];
6244
+ activeOption: string | null;
6245
+ activeOptionId: string;
6246
+ inputNode: HTMLInputElement;
6247
+ }> & Readonly<{
6248
+ onClose?: (() => any) | undefined;
6249
+ onSelect?: ((option: string) => any) | undefined;
6250
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
6251
+ listbox: HTMLUListElement;
6252
+ }, HTMLDivElement>;
6253
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
6254
+ toggle: () => any;
6255
+ }, string, PublicProps, Readonly<{}> & Readonly<{
6256
+ onToggle?: (() => any) | undefined;
6257
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
5959
6258
  }, {}, string, ComponentProvideOptions, true, {}, any>;
5960
6259
  FIcon: DefineComponent<ExtractPropTypes< {
5961
6260
  name: {
@@ -6362,11 +6661,25 @@ type: StringConstructor;
6362
6661
  required: false;
6363
6662
  default: string;
6364
6663
  };
6664
+ options: {
6665
+ type: PropType<string[] | undefined>;
6666
+ required: false;
6667
+ default: () => undefined;
6668
+ };
6365
6669
  }>, {
6366
6670
  textFieldTableMode: boolean;
6671
+ viewValue: Ref<string, string>;
6672
+ onOptionSelected: (value: string) => void;
6673
+ dropdownId: string;
6674
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
6675
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
6676
+ activeOptionId: string;
6677
+ activeOption: Readonly<Ref<string | null, string | null>>;
6678
+ toggleDropdown: () => void;
6679
+ selectOption: (value: string) => void;
6680
+ closeDropdown: () => void;
6367
6681
  }, {
6368
6682
  showErrorPopup: boolean;
6369
- viewValue: string;
6370
6683
  lastModelValue: unknown;
6371
6684
  validationMessage: string;
6372
6685
  validityMode: string;
@@ -6386,6 +6699,8 @@ labelWrapperClass(): string | undefined;
6386
6699
  inputWrapperClass(): string | undefined;
6387
6700
  isModelUpdatedProgrammatically(): boolean;
6388
6701
  }, {
6702
+ onDropdownSelect(value: string): void;
6703
+ onDropdownClose(): void;
6389
6704
  getErrorPopupAnchor(): HTMLElement;
6390
6705
  closePopupError(): void;
6391
6706
  onChange(): Promise<void>;
@@ -6439,6 +6754,11 @@ type: StringConstructor;
6439
6754
  required: false;
6440
6755
  default: string;
6441
6756
  };
6757
+ options: {
6758
+ type: PropType<string[] | undefined>;
6759
+ required: false;
6760
+ default: () => undefined;
6761
+ };
6442
6762
  }>> & Readonly<{
6443
6763
  onBlur?: ((...args: any[]) => any) | undefined;
6444
6764
  onChange?: ((...args: any[]) => any) | undefined;
@@ -6449,6 +6769,7 @@ type: string;
6449
6769
  id: string;
6450
6770
  modelValue: string | number;
6451
6771
  inline: boolean;
6772
+ options: string[] | undefined;
6452
6773
  labelWidth: string;
6453
6774
  formatter: FormatFunction<any>;
6454
6775
  parser: ParseFunction<any>;
@@ -6687,6 +7008,34 @@ flip: string;
6687
7008
  rotate: string;
6688
7009
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
6689
7010
  }, {}, string, ComponentProvideOptions, true, {}, any>;
7011
+ IComboboxDropdown: DefineComponent< {
7012
+ id: string;
7013
+ isOpen: boolean;
7014
+ options: string[];
7015
+ activeOption: string | null;
7016
+ activeOptionId: string;
7017
+ inputNode: HTMLInputElement;
7018
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
7019
+ close: () => any;
7020
+ select: (option: string) => any;
7021
+ }, string, PublicProps, Readonly<{
7022
+ id: string;
7023
+ isOpen: boolean;
7024
+ options: string[];
7025
+ activeOption: string | null;
7026
+ activeOptionId: string;
7027
+ inputNode: HTMLInputElement;
7028
+ }> & Readonly<{
7029
+ onClose?: (() => any) | undefined;
7030
+ onSelect?: ((option: string) => any) | undefined;
7031
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
7032
+ listbox: HTMLUListElement;
7033
+ }, HTMLDivElement>;
7034
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
7035
+ toggle: () => any;
7036
+ }, string, PublicProps, Readonly<{}> & Readonly<{
7037
+ onToggle?: (() => any) | undefined;
7038
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
6690
7039
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6691
7040
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6692
7041
 
@@ -7255,9 +7604,9 @@ onToggle?: ((...args: any[]) => any) | undefined;
7255
7604
  }>, {
7256
7605
  id: string;
7257
7606
  expanded: boolean;
7607
+ list: boolean;
7258
7608
  headerTag: string;
7259
7609
  headerVisualTag: string;
7260
- list: boolean;
7261
7610
  }, {}, {
7262
7611
  FIcon: DefineComponent<ExtractPropTypes< {
7263
7612
  name: {
@@ -11583,6 +11932,16 @@ default: typeof parseNumber;
11583
11932
  };
11584
11933
  }>, {
11585
11934
  textFieldTableMode: boolean;
11935
+ viewValue: Ref<string>;
11936
+ onOptionSelected: (value: string) => void;
11937
+ dropdownId: string;
11938
+ dropdownIsOpen: Readonly<Ref<boolean>>;
11939
+ dropdownOptions: Readonly<Ref<string[]>>;
11940
+ activeOptionId: string;
11941
+ activeOption: Readonly<Ref<string | null>>;
11942
+ toggleDropdown: () => void;
11943
+ selectOption: (value: string) => void;
11944
+ closeDropdown: () => void;
11586
11945
  }, {}, {}, {}, ComponentOptionsMixin, DefineComponent<ExtractPropTypes< {
11587
11946
  id: {
11588
11947
  type: StringConstructor;
@@ -11624,11 +11983,25 @@ type: StringConstructor;
11624
11983
  required: false;
11625
11984
  default: string;
11626
11985
  };
11986
+ options: {
11987
+ type: PropType<string[] | undefined>;
11988
+ required: false;
11989
+ default: () => undefined;
11990
+ };
11627
11991
  }>, {
11628
11992
  textFieldTableMode: boolean;
11993
+ viewValue: Ref<string, string>;
11994
+ onOptionSelected: (value: string) => void;
11995
+ dropdownId: string;
11996
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
11997
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
11998
+ activeOptionId: string;
11999
+ activeOption: Readonly<Ref<string | null, string | null>>;
12000
+ toggleDropdown: () => void;
12001
+ selectOption: (value: string) => void;
12002
+ closeDropdown: () => void;
11629
12003
  }, {
11630
12004
  showErrorPopup: boolean;
11631
- viewValue: string;
11632
12005
  lastModelValue: unknown;
11633
12006
  validationMessage: string;
11634
12007
  validityMode: string;
@@ -11648,6 +12021,8 @@ labelWrapperClass(): string | undefined;
11648
12021
  inputWrapperClass(): string | undefined;
11649
12022
  isModelUpdatedProgrammatically(): boolean;
11650
12023
  }, {
12024
+ onDropdownSelect(value: string): void;
12025
+ onDropdownClose(): void;
11651
12026
  getErrorPopupAnchor(): HTMLElement;
11652
12027
  closePopupError(): void;
11653
12028
  onChange(): Promise<void>;
@@ -11701,6 +12076,11 @@ type: StringConstructor;
11701
12076
  required: false;
11702
12077
  default: string;
11703
12078
  };
12079
+ options: {
12080
+ type: PropType<string[] | undefined>;
12081
+ required: false;
12082
+ default: () => undefined;
12083
+ };
11704
12084
  }>> & Readonly<{
11705
12085
  onBlur?: ((...args: any[]) => any) | undefined;
11706
12086
  onChange?: ((...args: any[]) => any) | undefined;
@@ -11711,6 +12091,7 @@ type: string;
11711
12091
  id: string;
11712
12092
  modelValue: string | number;
11713
12093
  inline: boolean;
12094
+ options: string[] | undefined;
11714
12095
  labelWidth: string;
11715
12096
  formatter: FormatFunction<any>;
11716
12097
  parser: ParseFunction<any>;
@@ -11949,6 +12330,34 @@ flip: string;
11949
12330
  rotate: string;
11950
12331
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
11951
12332
  }, {}, string, ComponentProvideOptions, true, {}, any>;
12333
+ IComboboxDropdown: DefineComponent< {
12334
+ id: string;
12335
+ isOpen: boolean;
12336
+ options: string[];
12337
+ activeOption: string | null;
12338
+ activeOptionId: string;
12339
+ inputNode: HTMLInputElement;
12340
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
12341
+ close: () => any;
12342
+ select: (option: string) => any;
12343
+ }, string, PublicProps, Readonly<{
12344
+ id: string;
12345
+ isOpen: boolean;
12346
+ options: string[];
12347
+ activeOption: string | null;
12348
+ activeOptionId: string;
12349
+ inputNode: HTMLInputElement;
12350
+ }> & Readonly<{
12351
+ onClose?: (() => any) | undefined;
12352
+ onSelect?: ((option: string) => any) | undefined;
12353
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
12354
+ listbox: HTMLUListElement;
12355
+ }, HTMLDivElement>;
12356
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
12357
+ toggle: () => any;
12358
+ }, string, PublicProps, Readonly<{}> & Readonly<{
12359
+ onToggle?: (() => any) | undefined;
12360
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
11952
12361
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
11953
12362
  /**
11954
12363
  * The number of decimals to format number as.
@@ -12146,6 +12555,16 @@ default: typeof parseOrganisationsnummer;
12146
12555
  };
12147
12556
  }>, {
12148
12557
  textFieldTableMode: boolean;
12558
+ viewValue: Ref<string>;
12559
+ onOptionSelected: (value: string) => void;
12560
+ dropdownId: string;
12561
+ dropdownIsOpen: Readonly<Ref<boolean>>;
12562
+ dropdownOptions: Readonly<Ref<string[]>>;
12563
+ activeOptionId: string;
12564
+ activeOption: Readonly<Ref<string | null>>;
12565
+ toggleDropdown: () => void;
12566
+ selectOption: (value: string) => void;
12567
+ closeDropdown: () => void;
12149
12568
  }, {
12150
12569
  defaultText: string;
12151
12570
  discreteDescriptionText: string;
@@ -12191,11 +12610,25 @@ type: StringConstructor;
12191
12610
  required: false;
12192
12611
  default: string;
12193
12612
  };
12613
+ options: {
12614
+ type: PropType<string[] | undefined>;
12615
+ required: false;
12616
+ default: () => undefined;
12617
+ };
12194
12618
  }>, {
12195
12619
  textFieldTableMode: boolean;
12620
+ viewValue: Ref<string, string>;
12621
+ onOptionSelected: (value: string) => void;
12622
+ dropdownId: string;
12623
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
12624
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
12625
+ activeOptionId: string;
12626
+ activeOption: Readonly<Ref<string | null, string | null>>;
12627
+ toggleDropdown: () => void;
12628
+ selectOption: (value: string) => void;
12629
+ closeDropdown: () => void;
12196
12630
  }, {
12197
12631
  showErrorPopup: boolean;
12198
- viewValue: string;
12199
12632
  lastModelValue: unknown;
12200
12633
  validationMessage: string;
12201
12634
  validityMode: string;
@@ -12215,6 +12648,8 @@ labelWrapperClass(): string | undefined;
12215
12648
  inputWrapperClass(): string | undefined;
12216
12649
  isModelUpdatedProgrammatically(): boolean;
12217
12650
  }, {
12651
+ onDropdownSelect(value: string): void;
12652
+ onDropdownClose(): void;
12218
12653
  getErrorPopupAnchor(): HTMLElement;
12219
12654
  closePopupError(): void;
12220
12655
  onChange(): Promise<void>;
@@ -12268,6 +12703,11 @@ type: StringConstructor;
12268
12703
  required: false;
12269
12704
  default: string;
12270
12705
  };
12706
+ options: {
12707
+ type: PropType<string[] | undefined>;
12708
+ required: false;
12709
+ default: () => undefined;
12710
+ };
12271
12711
  }>> & Readonly<{
12272
12712
  onBlur?: ((...args: any[]) => any) | undefined;
12273
12713
  onChange?: ((...args: any[]) => any) | undefined;
@@ -12278,6 +12718,7 @@ type: string;
12278
12718
  id: string;
12279
12719
  modelValue: string | number;
12280
12720
  inline: boolean;
12721
+ options: string[] | undefined;
12281
12722
  labelWidth: string;
12282
12723
  formatter: FormatFunction<any>;
12283
12724
  parser: ParseFunction<any>;
@@ -12516,6 +12957,34 @@ flip: string;
12516
12957
  rotate: string;
12517
12958
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
12518
12959
  }, {}, string, ComponentProvideOptions, true, {}, any>;
12960
+ IComboboxDropdown: DefineComponent< {
12961
+ id: string;
12962
+ isOpen: boolean;
12963
+ options: string[];
12964
+ activeOption: string | null;
12965
+ activeOptionId: string;
12966
+ inputNode: HTMLInputElement;
12967
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
12968
+ close: () => any;
12969
+ select: (option: string) => any;
12970
+ }, string, PublicProps, Readonly<{
12971
+ id: string;
12972
+ isOpen: boolean;
12973
+ options: string[];
12974
+ activeOption: string | null;
12975
+ activeOptionId: string;
12976
+ inputNode: HTMLInputElement;
12977
+ }> & Readonly<{
12978
+ onClose?: (() => any) | undefined;
12979
+ onSelect?: ((option: string) => any) | undefined;
12980
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
12981
+ listbox: HTMLUListElement;
12982
+ }, HTMLDivElement>;
12983
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
12984
+ toggle: () => any;
12985
+ }, string, PublicProps, Readonly<{}> & Readonly<{
12986
+ onToggle?: (() => any) | undefined;
12987
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
12519
12988
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
12520
12989
  formatter: {
12521
12990
  type: PropType<FormatFunction<OrganisationsnummerString>>;
@@ -12922,6 +13391,16 @@ default: typeof parsePercent;
12922
13391
  };
12923
13392
  }>, {
12924
13393
  textFieldTableMode: boolean;
13394
+ viewValue: Ref<string>;
13395
+ onOptionSelected: (value: string) => void;
13396
+ dropdownId: string;
13397
+ dropdownIsOpen: Readonly<Ref<boolean>>;
13398
+ dropdownOptions: Readonly<Ref<string[]>>;
13399
+ activeOptionId: string;
13400
+ activeOption: Readonly<Ref<string | null>>;
13401
+ toggleDropdown: () => void;
13402
+ selectOption: (value: string) => void;
13403
+ closeDropdown: () => void;
12925
13404
  }, {
12926
13405
  defaultText: string;
12927
13406
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -12965,11 +13444,25 @@ type: StringConstructor;
12965
13444
  required: false;
12966
13445
  default: string;
12967
13446
  };
13447
+ options: {
13448
+ type: PropType<string[] | undefined>;
13449
+ required: false;
13450
+ default: () => undefined;
13451
+ };
12968
13452
  }>, {
12969
13453
  textFieldTableMode: boolean;
13454
+ viewValue: Ref<string, string>;
13455
+ onOptionSelected: (value: string) => void;
13456
+ dropdownId: string;
13457
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
13458
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
13459
+ activeOptionId: string;
13460
+ activeOption: Readonly<Ref<string | null, string | null>>;
13461
+ toggleDropdown: () => void;
13462
+ selectOption: (value: string) => void;
13463
+ closeDropdown: () => void;
12970
13464
  }, {
12971
13465
  showErrorPopup: boolean;
12972
- viewValue: string;
12973
13466
  lastModelValue: unknown;
12974
13467
  validationMessage: string;
12975
13468
  validityMode: string;
@@ -12989,6 +13482,8 @@ labelWrapperClass(): string | undefined;
12989
13482
  inputWrapperClass(): string | undefined;
12990
13483
  isModelUpdatedProgrammatically(): boolean;
12991
13484
  }, {
13485
+ onDropdownSelect(value: string): void;
13486
+ onDropdownClose(): void;
12992
13487
  getErrorPopupAnchor(): HTMLElement;
12993
13488
  closePopupError(): void;
12994
13489
  onChange(): Promise<void>;
@@ -13042,6 +13537,11 @@ type: StringConstructor;
13042
13537
  required: false;
13043
13538
  default: string;
13044
13539
  };
13540
+ options: {
13541
+ type: PropType<string[] | undefined>;
13542
+ required: false;
13543
+ default: () => undefined;
13544
+ };
13045
13545
  }>> & Readonly<{
13046
13546
  onBlur?: ((...args: any[]) => any) | undefined;
13047
13547
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13052,6 +13552,7 @@ type: string;
13052
13552
  id: string;
13053
13553
  modelValue: string | number;
13054
13554
  inline: boolean;
13555
+ options: string[] | undefined;
13055
13556
  labelWidth: string;
13056
13557
  formatter: FormatFunction<any>;
13057
13558
  parser: ParseFunction<any>;
@@ -13290,6 +13791,34 @@ flip: string;
13290
13791
  rotate: string;
13291
13792
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
13292
13793
  }, {}, string, ComponentProvideOptions, true, {}, any>;
13794
+ IComboboxDropdown: DefineComponent< {
13795
+ id: string;
13796
+ isOpen: boolean;
13797
+ options: string[];
13798
+ activeOption: string | null;
13799
+ activeOptionId: string;
13800
+ inputNode: HTMLInputElement;
13801
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
13802
+ close: () => any;
13803
+ select: (option: string) => any;
13804
+ }, string, PublicProps, Readonly<{
13805
+ id: string;
13806
+ isOpen: boolean;
13807
+ options: string[];
13808
+ activeOption: string | null;
13809
+ activeOptionId: string;
13810
+ inputNode: HTMLInputElement;
13811
+ }> & Readonly<{
13812
+ onClose?: (() => any) | undefined;
13813
+ onSelect?: ((option: string) => any) | undefined;
13814
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
13815
+ listbox: HTMLUListElement;
13816
+ }, HTMLDivElement>;
13817
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
13818
+ toggle: () => any;
13819
+ }, string, PublicProps, Readonly<{}> & Readonly<{
13820
+ onToggle?: (() => any) | undefined;
13821
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
13293
13822
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
13294
13823
  /**
13295
13824
  * The number of decimals to format number as.
@@ -13328,6 +13857,16 @@ default: typeof parsePersonnummer;
13328
13857
  };
13329
13858
  }>, {
13330
13859
  textFieldTableMode: boolean;
13860
+ viewValue: Ref<string>;
13861
+ onOptionSelected: (value: string) => void;
13862
+ dropdownId: string;
13863
+ dropdownIsOpen: Readonly<Ref<boolean>>;
13864
+ dropdownOptions: Readonly<Ref<string[]>>;
13865
+ activeOptionId: string;
13866
+ activeOption: Readonly<Ref<string | null>>;
13867
+ toggleDropdown: () => void;
13868
+ selectOption: (value: string) => void;
13869
+ closeDropdown: () => void;
13331
13870
  }, {
13332
13871
  defaultText: string;
13333
13872
  discreteDescriptionText: string;
@@ -13373,11 +13912,25 @@ type: StringConstructor;
13373
13912
  required: false;
13374
13913
  default: string;
13375
13914
  };
13915
+ options: {
13916
+ type: PropType<string[] | undefined>;
13917
+ required: false;
13918
+ default: () => undefined;
13919
+ };
13376
13920
  }>, {
13377
13921
  textFieldTableMode: boolean;
13922
+ viewValue: Ref<string, string>;
13923
+ onOptionSelected: (value: string) => void;
13924
+ dropdownId: string;
13925
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
13926
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
13927
+ activeOptionId: string;
13928
+ activeOption: Readonly<Ref<string | null, string | null>>;
13929
+ toggleDropdown: () => void;
13930
+ selectOption: (value: string) => void;
13931
+ closeDropdown: () => void;
13378
13932
  }, {
13379
13933
  showErrorPopup: boolean;
13380
- viewValue: string;
13381
13934
  lastModelValue: unknown;
13382
13935
  validationMessage: string;
13383
13936
  validityMode: string;
@@ -13397,6 +13950,8 @@ labelWrapperClass(): string | undefined;
13397
13950
  inputWrapperClass(): string | undefined;
13398
13951
  isModelUpdatedProgrammatically(): boolean;
13399
13952
  }, {
13953
+ onDropdownSelect(value: string): void;
13954
+ onDropdownClose(): void;
13400
13955
  getErrorPopupAnchor(): HTMLElement;
13401
13956
  closePopupError(): void;
13402
13957
  onChange(): Promise<void>;
@@ -13450,6 +14005,11 @@ type: StringConstructor;
13450
14005
  required: false;
13451
14006
  default: string;
13452
14007
  };
14008
+ options: {
14009
+ type: PropType<string[] | undefined>;
14010
+ required: false;
14011
+ default: () => undefined;
14012
+ };
13453
14013
  }>> & Readonly<{
13454
14014
  onBlur?: ((...args: any[]) => any) | undefined;
13455
14015
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13460,6 +14020,7 @@ type: string;
13460
14020
  id: string;
13461
14021
  modelValue: string | number;
13462
14022
  inline: boolean;
14023
+ options: string[] | undefined;
13463
14024
  labelWidth: string;
13464
14025
  formatter: FormatFunction<any>;
13465
14026
  parser: ParseFunction<any>;
@@ -13698,6 +14259,34 @@ flip: string;
13698
14259
  rotate: string;
13699
14260
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
13700
14261
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14262
+ IComboboxDropdown: DefineComponent< {
14263
+ id: string;
14264
+ isOpen: boolean;
14265
+ options: string[];
14266
+ activeOption: string | null;
14267
+ activeOptionId: string;
14268
+ inputNode: HTMLInputElement;
14269
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14270
+ close: () => any;
14271
+ select: (option: string) => any;
14272
+ }, string, PublicProps, Readonly<{
14273
+ id: string;
14274
+ isOpen: boolean;
14275
+ options: string[];
14276
+ activeOption: string | null;
14277
+ activeOptionId: string;
14278
+ inputNode: HTMLInputElement;
14279
+ }> & Readonly<{
14280
+ onClose?: (() => any) | undefined;
14281
+ onSelect?: ((option: string) => any) | undefined;
14282
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
14283
+ listbox: HTMLUListElement;
14284
+ }, HTMLDivElement>;
14285
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14286
+ toggle: () => any;
14287
+ }, string, PublicProps, Readonly<{}> & Readonly<{
14288
+ onToggle?: (() => any) | undefined;
14289
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
13701
14290
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
13702
14291
  formatter: {
13703
14292
  type: PropType<FormatFunction<PersonnummerString>>;
@@ -13836,11 +14425,25 @@ type: StringConstructor;
13836
14425
  required: false;
13837
14426
  default: string;
13838
14427
  };
14428
+ options: {
14429
+ type: PropType<string[] | undefined>;
14430
+ required: false;
14431
+ default: () => undefined;
14432
+ };
13839
14433
  }>, {
13840
14434
  textFieldTableMode: boolean;
14435
+ viewValue: Ref<string, string>;
14436
+ onOptionSelected: (value: string) => void;
14437
+ dropdownId: string;
14438
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
14439
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
14440
+ activeOptionId: string;
14441
+ activeOption: Readonly<Ref<string | null, string | null>>;
14442
+ toggleDropdown: () => void;
14443
+ selectOption: (value: string) => void;
14444
+ closeDropdown: () => void;
13841
14445
  }, {
13842
14446
  showErrorPopup: boolean;
13843
- viewValue: string;
13844
14447
  lastModelValue: unknown;
13845
14448
  validationMessage: string;
13846
14449
  validityMode: string;
@@ -13860,6 +14463,8 @@ labelWrapperClass(): string | undefined;
13860
14463
  inputWrapperClass(): string | undefined;
13861
14464
  isModelUpdatedProgrammatically(): boolean;
13862
14465
  }, {
14466
+ onDropdownSelect(value: string): void;
14467
+ onDropdownClose(): void;
13863
14468
  getErrorPopupAnchor(): HTMLElement;
13864
14469
  closePopupError(): void;
13865
14470
  onChange(): Promise<void>;
@@ -13913,6 +14518,11 @@ type: StringConstructor;
13913
14518
  required: false;
13914
14519
  default: string;
13915
14520
  };
14521
+ options: {
14522
+ type: PropType<string[] | undefined>;
14523
+ required: false;
14524
+ default: () => undefined;
14525
+ };
13916
14526
  }>> & Readonly<{
13917
14527
  onBlur?: ((...args: any[]) => any) | undefined;
13918
14528
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13923,6 +14533,7 @@ type: string;
13923
14533
  id: string;
13924
14534
  modelValue: string | number;
13925
14535
  inline: boolean;
14536
+ options: string[] | undefined;
13926
14537
  labelWidth: string;
13927
14538
  formatter: FormatFunction<any>;
13928
14539
  parser: ParseFunction<any>;
@@ -14161,6 +14772,34 @@ flip: string;
14161
14772
  rotate: string;
14162
14773
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14163
14774
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14775
+ IComboboxDropdown: DefineComponent< {
14776
+ id: string;
14777
+ isOpen: boolean;
14778
+ options: string[];
14779
+ activeOption: string | null;
14780
+ activeOptionId: string;
14781
+ inputNode: HTMLInputElement;
14782
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14783
+ close: () => any;
14784
+ select: (option: string) => any;
14785
+ }, string, PublicProps, Readonly<{
14786
+ id: string;
14787
+ isOpen: boolean;
14788
+ options: string[];
14789
+ activeOption: string | null;
14790
+ activeOptionId: string;
14791
+ inputNode: HTMLInputElement;
14792
+ }> & Readonly<{
14793
+ onClose?: (() => any) | undefined;
14794
+ onSelect?: ((option: string) => any) | undefined;
14795
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
14796
+ listbox: HTMLUListElement;
14797
+ }, HTMLDivElement>;
14798
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
14799
+ toggle: () => any;
14800
+ }, string, PublicProps, Readonly<{}> & Readonly<{
14801
+ onToggle?: (() => any) | undefined;
14802
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
14164
14803
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14165
14804
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14166
14805
 
@@ -14172,6 +14811,16 @@ default: typeof parsePlusgiro;
14172
14811
  };
14173
14812
  }>, {
14174
14813
  textFieldTableMode: boolean;
14814
+ viewValue: Ref<string>;
14815
+ onOptionSelected: (value: string) => void;
14816
+ dropdownId: string;
14817
+ dropdownIsOpen: Readonly<Ref<boolean>>;
14818
+ dropdownOptions: Readonly<Ref<string[]>>;
14819
+ activeOptionId: string;
14820
+ activeOption: Readonly<Ref<string | null>>;
14821
+ toggleDropdown: () => void;
14822
+ selectOption: (value: string) => void;
14823
+ closeDropdown: () => void;
14175
14824
  }, {
14176
14825
  defaultText: string;
14177
14826
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -14215,11 +14864,25 @@ type: StringConstructor;
14215
14864
  required: false;
14216
14865
  default: string;
14217
14866
  };
14867
+ options: {
14868
+ type: PropType<string[] | undefined>;
14869
+ required: false;
14870
+ default: () => undefined;
14871
+ };
14218
14872
  }>, {
14219
14873
  textFieldTableMode: boolean;
14874
+ viewValue: Ref<string, string>;
14875
+ onOptionSelected: (value: string) => void;
14876
+ dropdownId: string;
14877
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
14878
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
14879
+ activeOptionId: string;
14880
+ activeOption: Readonly<Ref<string | null, string | null>>;
14881
+ toggleDropdown: () => void;
14882
+ selectOption: (value: string) => void;
14883
+ closeDropdown: () => void;
14220
14884
  }, {
14221
14885
  showErrorPopup: boolean;
14222
- viewValue: string;
14223
14886
  lastModelValue: unknown;
14224
14887
  validationMessage: string;
14225
14888
  validityMode: string;
@@ -14239,6 +14902,8 @@ labelWrapperClass(): string | undefined;
14239
14902
  inputWrapperClass(): string | undefined;
14240
14903
  isModelUpdatedProgrammatically(): boolean;
14241
14904
  }, {
14905
+ onDropdownSelect(value: string): void;
14906
+ onDropdownClose(): void;
14242
14907
  getErrorPopupAnchor(): HTMLElement;
14243
14908
  closePopupError(): void;
14244
14909
  onChange(): Promise<void>;
@@ -14292,6 +14957,11 @@ type: StringConstructor;
14292
14957
  required: false;
14293
14958
  default: string;
14294
14959
  };
14960
+ options: {
14961
+ type: PropType<string[] | undefined>;
14962
+ required: false;
14963
+ default: () => undefined;
14964
+ };
14295
14965
  }>> & Readonly<{
14296
14966
  onBlur?: ((...args: any[]) => any) | undefined;
14297
14967
  onChange?: ((...args: any[]) => any) | undefined;
@@ -14302,6 +14972,7 @@ type: string;
14302
14972
  id: string;
14303
14973
  modelValue: string | number;
14304
14974
  inline: boolean;
14975
+ options: string[] | undefined;
14305
14976
  labelWidth: string;
14306
14977
  formatter: FormatFunction<any>;
14307
14978
  parser: ParseFunction<any>;
@@ -14540,6 +15211,34 @@ flip: string;
14540
15211
  rotate: string;
14541
15212
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14542
15213
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15214
+ IComboboxDropdown: DefineComponent< {
15215
+ id: string;
15216
+ isOpen: boolean;
15217
+ options: string[];
15218
+ activeOption: string | null;
15219
+ activeOptionId: string;
15220
+ inputNode: HTMLInputElement;
15221
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15222
+ close: () => any;
15223
+ select: (option: string) => any;
15224
+ }, string, PublicProps, Readonly<{
15225
+ id: string;
15226
+ isOpen: boolean;
15227
+ options: string[];
15228
+ activeOption: string | null;
15229
+ activeOptionId: string;
15230
+ inputNode: HTMLInputElement;
15231
+ }> & Readonly<{
15232
+ onClose?: (() => any) | undefined;
15233
+ onSelect?: ((option: string) => any) | undefined;
15234
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
15235
+ listbox: HTMLUListElement;
15236
+ }, HTMLDivElement>;
15237
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15238
+ toggle: () => any;
15239
+ }, string, PublicProps, Readonly<{}> & Readonly<{
15240
+ onToggle?: (() => any) | undefined;
15241
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
14543
15242
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
14544
15243
  formatter: {
14545
15244
  type: PropType<FormatFunction<PlusgiroString>>;
@@ -14558,6 +15257,16 @@ default: typeof formatPostalCode;
14558
15257
  };
14559
15258
  }>, {
14560
15259
  textFieldTableMode: boolean;
15260
+ viewValue: Ref<string>;
15261
+ onOptionSelected: (value: string) => void;
15262
+ dropdownId: string;
15263
+ dropdownIsOpen: Readonly<Ref<boolean>>;
15264
+ dropdownOptions: Readonly<Ref<string[]>>;
15265
+ activeOptionId: string;
15266
+ activeOption: Readonly<Ref<string | null>>;
15267
+ toggleDropdown: () => void;
15268
+ selectOption: (value: string) => void;
15269
+ closeDropdown: () => void;
14561
15270
  }, {
14562
15271
  defaultText: string;
14563
15272
  discreteDescriptionText: string;
@@ -14603,11 +15312,25 @@ type: StringConstructor;
14603
15312
  required: false;
14604
15313
  default: string;
14605
15314
  };
15315
+ options: {
15316
+ type: PropType<string[] | undefined>;
15317
+ required: false;
15318
+ default: () => undefined;
15319
+ };
14606
15320
  }>, {
14607
15321
  textFieldTableMode: boolean;
15322
+ viewValue: Ref<string, string>;
15323
+ onOptionSelected: (value: string) => void;
15324
+ dropdownId: string;
15325
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
15326
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
15327
+ activeOptionId: string;
15328
+ activeOption: Readonly<Ref<string | null, string | null>>;
15329
+ toggleDropdown: () => void;
15330
+ selectOption: (value: string) => void;
15331
+ closeDropdown: () => void;
14608
15332
  }, {
14609
15333
  showErrorPopup: boolean;
14610
- viewValue: string;
14611
15334
  lastModelValue: unknown;
14612
15335
  validationMessage: string;
14613
15336
  validityMode: string;
@@ -14627,6 +15350,8 @@ labelWrapperClass(): string | undefined;
14627
15350
  inputWrapperClass(): string | undefined;
14628
15351
  isModelUpdatedProgrammatically(): boolean;
14629
15352
  }, {
15353
+ onDropdownSelect(value: string): void;
15354
+ onDropdownClose(): void;
14630
15355
  getErrorPopupAnchor(): HTMLElement;
14631
15356
  closePopupError(): void;
14632
15357
  onChange(): Promise<void>;
@@ -14680,6 +15405,11 @@ type: StringConstructor;
14680
15405
  required: false;
14681
15406
  default: string;
14682
15407
  };
15408
+ options: {
15409
+ type: PropType<string[] | undefined>;
15410
+ required: false;
15411
+ default: () => undefined;
15412
+ };
14683
15413
  }>> & Readonly<{
14684
15414
  onBlur?: ((...args: any[]) => any) | undefined;
14685
15415
  onChange?: ((...args: any[]) => any) | undefined;
@@ -14690,6 +15420,7 @@ type: string;
14690
15420
  id: string;
14691
15421
  modelValue: string | number;
14692
15422
  inline: boolean;
15423
+ options: string[] | undefined;
14693
15424
  labelWidth: string;
14694
15425
  formatter: FormatFunction<any>;
14695
15426
  parser: ParseFunction<any>;
@@ -14928,6 +15659,34 @@ flip: string;
14928
15659
  rotate: string;
14929
15660
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14930
15661
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15662
+ IComboboxDropdown: DefineComponent< {
15663
+ id: string;
15664
+ isOpen: boolean;
15665
+ options: string[];
15666
+ activeOption: string | null;
15667
+ activeOptionId: string;
15668
+ inputNode: HTMLInputElement;
15669
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15670
+ close: () => any;
15671
+ select: (option: string) => any;
15672
+ }, string, PublicProps, Readonly<{
15673
+ id: string;
15674
+ isOpen: boolean;
15675
+ options: string[];
15676
+ activeOption: string | null;
15677
+ activeOptionId: string;
15678
+ inputNode: HTMLInputElement;
15679
+ }> & Readonly<{
15680
+ onClose?: (() => any) | undefined;
15681
+ onSelect?: ((option: string) => any) | undefined;
15682
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
15683
+ listbox: HTMLUListElement;
15684
+ }, HTMLDivElement>;
15685
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
15686
+ toggle: () => any;
15687
+ }, string, PublicProps, Readonly<{}> & Readonly<{
15688
+ onToggle?: (() => any) | undefined;
15689
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
14931
15690
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
14932
15691
  formatter: {
14933
15692
  type: PropType<FormatFunction<PostalCodeString>>;
@@ -15332,11 +16091,25 @@ type: StringConstructor;
15332
16091
  required: false;
15333
16092
  default: string;
15334
16093
  };
16094
+ options: {
16095
+ type: PropType<string[] | undefined>;
16096
+ required: false;
16097
+ default: () => undefined;
16098
+ };
15335
16099
  }>, {
15336
16100
  textFieldTableMode: boolean;
16101
+ viewValue: Ref<string, string>;
16102
+ onOptionSelected: (value: string) => void;
16103
+ dropdownId: string;
16104
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
16105
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
16106
+ activeOptionId: string;
16107
+ activeOption: Readonly<Ref<string | null, string | null>>;
16108
+ toggleDropdown: () => void;
16109
+ selectOption: (value: string) => void;
16110
+ closeDropdown: () => void;
15337
16111
  }, {
15338
16112
  showErrorPopup: boolean;
15339
- viewValue: string;
15340
16113
  lastModelValue: unknown;
15341
16114
  validationMessage: string;
15342
16115
  validityMode: string;
@@ -15356,6 +16129,8 @@ labelWrapperClass(): string | undefined;
15356
16129
  inputWrapperClass(): string | undefined;
15357
16130
  isModelUpdatedProgrammatically(): boolean;
15358
16131
  }, {
16132
+ onDropdownSelect(value: string): void;
16133
+ onDropdownClose(): void;
15359
16134
  getErrorPopupAnchor(): HTMLElement;
15360
16135
  closePopupError(): void;
15361
16136
  onChange(): Promise<void>;
@@ -15409,6 +16184,11 @@ type: StringConstructor;
15409
16184
  required: false;
15410
16185
  default: string;
15411
16186
  };
16187
+ options: {
16188
+ type: PropType<string[] | undefined>;
16189
+ required: false;
16190
+ default: () => undefined;
16191
+ };
15412
16192
  }>> & Readonly<{
15413
16193
  onBlur?: ((...args: any[]) => any) | undefined;
15414
16194
  onChange?: ((...args: any[]) => any) | undefined;
@@ -15419,6 +16199,7 @@ type: string;
15419
16199
  id: string;
15420
16200
  modelValue: string | number;
15421
16201
  inline: boolean;
16202
+ options: string[] | undefined;
15422
16203
  labelWidth: string;
15423
16204
  formatter: FormatFunction<any>;
15424
16205
  parser: ParseFunction<any>;
@@ -15657,6 +16438,34 @@ flip: string;
15657
16438
  rotate: string;
15658
16439
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
15659
16440
  }, {}, string, ComponentProvideOptions, true, {}, any>;
16441
+ IComboboxDropdown: DefineComponent< {
16442
+ id: string;
16443
+ isOpen: boolean;
16444
+ options: string[];
16445
+ activeOption: string | null;
16446
+ activeOptionId: string;
16447
+ inputNode: HTMLInputElement;
16448
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
16449
+ close: () => any;
16450
+ select: (option: string) => any;
16451
+ }, string, PublicProps, Readonly<{
16452
+ id: string;
16453
+ isOpen: boolean;
16454
+ options: string[];
16455
+ activeOption: string | null;
16456
+ activeOptionId: string;
16457
+ inputNode: HTMLInputElement;
16458
+ }> & Readonly<{
16459
+ onClose?: (() => any) | undefined;
16460
+ onSelect?: ((option: string) => any) | undefined;
16461
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
16462
+ listbox: HTMLUListElement;
16463
+ }, HTMLDivElement>;
16464
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
16465
+ toggle: () => any;
16466
+ }, string, PublicProps, Readonly<{}> & Readonly<{
16467
+ onToggle?: (() => any) | undefined;
16468
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
15660
16469
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15661
16470
  FIcon: DefineComponent<ExtractPropTypes< {
15662
16471
  name: {
@@ -16380,11 +17189,25 @@ type: StringConstructor;
16380
17189
  required: false;
16381
17190
  default: string;
16382
17191
  };
17192
+ options: {
17193
+ type: PropType<string[] | undefined>;
17194
+ required: false;
17195
+ default: () => undefined;
17196
+ };
16383
17197
  }>, {
16384
17198
  textFieldTableMode: boolean;
17199
+ viewValue: Ref<string, string>;
17200
+ onOptionSelected: (value: string) => void;
17201
+ dropdownId: string;
17202
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
17203
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
17204
+ activeOptionId: string;
17205
+ activeOption: Readonly<Ref<string | null, string | null>>;
17206
+ toggleDropdown: () => void;
17207
+ selectOption: (value: string) => void;
17208
+ closeDropdown: () => void;
16385
17209
  }, {
16386
17210
  showErrorPopup: boolean;
16387
- viewValue: string;
16388
17211
  lastModelValue: unknown;
16389
17212
  validationMessage: string;
16390
17213
  validityMode: string;
@@ -16404,6 +17227,8 @@ labelWrapperClass(): string | undefined;
16404
17227
  inputWrapperClass(): string | undefined;
16405
17228
  isModelUpdatedProgrammatically(): boolean;
16406
17229
  }, {
17230
+ onDropdownSelect(value: string): void;
17231
+ onDropdownClose(): void;
16407
17232
  getErrorPopupAnchor(): HTMLElement;
16408
17233
  closePopupError(): void;
16409
17234
  onChange(): Promise<void>;
@@ -16457,6 +17282,11 @@ type: StringConstructor;
16457
17282
  required: false;
16458
17283
  default: string;
16459
17284
  };
17285
+ options: {
17286
+ type: PropType<string[] | undefined>;
17287
+ required: false;
17288
+ default: () => undefined;
17289
+ };
16460
17290
  }>> & Readonly<{
16461
17291
  onBlur?: ((...args: any[]) => any) | undefined;
16462
17292
  onChange?: ((...args: any[]) => any) | undefined;
@@ -16467,6 +17297,7 @@ type: string;
16467
17297
  id: string;
16468
17298
  modelValue: string | number;
16469
17299
  inline: boolean;
17300
+ options: string[] | undefined;
16470
17301
  labelWidth: string;
16471
17302
  formatter: FormatFunction<any>;
16472
17303
  parser: ParseFunction<any>;
@@ -16705,6 +17536,34 @@ flip: string;
16705
17536
  rotate: string;
16706
17537
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
16707
17538
  }, {}, string, ComponentProvideOptions, true, {}, any>;
17539
+ IComboboxDropdown: DefineComponent< {
17540
+ id: string;
17541
+ isOpen: boolean;
17542
+ options: string[];
17543
+ activeOption: string | null;
17544
+ activeOptionId: string;
17545
+ inputNode: HTMLInputElement;
17546
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
17547
+ close: () => any;
17548
+ select: (option: string) => any;
17549
+ }, string, PublicProps, Readonly<{
17550
+ id: string;
17551
+ isOpen: boolean;
17552
+ options: string[];
17553
+ activeOption: string | null;
17554
+ activeOptionId: string;
17555
+ inputNode: HTMLInputElement;
17556
+ }> & Readonly<{
17557
+ onClose?: (() => any) | undefined;
17558
+ onSelect?: ((option: string) => any) | undefined;
17559
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
17560
+ listbox: HTMLUListElement;
17561
+ }, HTMLDivElement>;
17562
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
17563
+ toggle: () => any;
17564
+ }, string, PublicProps, Readonly<{}> & Readonly<{
17565
+ onToggle?: (() => any) | undefined;
17566
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
16708
17567
  }, {}, string, ComponentProvideOptions, true, {}, any>;
16709
17568
  FIcon: DefineComponent<ExtractPropTypes< {
16710
17569
  name: {
@@ -17547,11 +18406,32 @@ type: StringConstructor;
17547
18406
  required: false;
17548
18407
  default: string;
17549
18408
  };
18409
+ /**
18410
+ * List of options.
18411
+ *
18412
+ * When set, the user can select a value from the list of options and filter while typing.
18413
+ *
18414
+ * If a formatter is used by the component, make sure the options are formatted as well.
18415
+ */
18416
+ options: {
18417
+ type: PropType<string[] | undefined>;
18418
+ required: false;
18419
+ default: () => undefined;
18420
+ };
17550
18421
  }>, {
17551
18422
  textFieldTableMode: boolean;
18423
+ viewValue: Ref<string, string>;
18424
+ onOptionSelected: (value: string) => void;
18425
+ dropdownId: string;
18426
+ dropdownIsOpen: Readonly<Ref<boolean, boolean>>;
18427
+ dropdownOptions: Readonly<Ref<string[], string[]>>;
18428
+ activeOptionId: string;
18429
+ activeOption: Readonly<Ref<string | null, string | null>>;
18430
+ toggleDropdown: () => void;
18431
+ selectOption: (value: string) => void;
18432
+ closeDropdown: () => void;
17552
18433
  }, {
17553
18434
  showErrorPopup: boolean;
17554
- viewValue: string;
17555
18435
  lastModelValue: unknown;
17556
18436
  validationMessage: string;
17557
18437
  validityMode: string;
@@ -17571,6 +18451,8 @@ labelWrapperClass(): string | undefined;
17571
18451
  inputWrapperClass(): string | undefined;
17572
18452
  isModelUpdatedProgrammatically(): boolean;
17573
18453
  }, {
18454
+ onDropdownSelect(value: string): void;
18455
+ onDropdownClose(): void;
17574
18456
  getErrorPopupAnchor(): HTMLElement;
17575
18457
  closePopupError(): void;
17576
18458
  onChange(): Promise<void>;
@@ -17674,6 +18556,18 @@ type: StringConstructor;
17674
18556
  required: false;
17675
18557
  default: string;
17676
18558
  };
18559
+ /**
18560
+ * List of options.
18561
+ *
18562
+ * When set, the user can select a value from the list of options and filter while typing.
18563
+ *
18564
+ * If a formatter is used by the component, make sure the options are formatted as well.
18565
+ */
18566
+ options: {
18567
+ type: PropType<string[] | undefined>;
18568
+ required: false;
18569
+ default: () => undefined;
18570
+ };
17677
18571
  }>> & Readonly<{
17678
18572
  onBlur?: ((...args: any[]) => any) | undefined;
17679
18573
  onChange?: ((...args: any[]) => any) | undefined;
@@ -17684,6 +18578,7 @@ type: string;
17684
18578
  id: string;
17685
18579
  modelValue: string | number;
17686
18580
  inline: boolean;
18581
+ options: string[] | undefined;
17687
18582
  labelWidth: string;
17688
18583
  formatter: FormatFunction<any>;
17689
18584
  parser: ParseFunction<any>;
@@ -17922,6 +18817,34 @@ flip: string;
17922
18817
  rotate: string;
17923
18818
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
17924
18819
  }, {}, string, ComponentProvideOptions, true, {}, any>;
18820
+ IComboboxDropdown: DefineComponent< {
18821
+ id: string;
18822
+ isOpen: boolean;
18823
+ options: string[];
18824
+ activeOption: string | null;
18825
+ activeOptionId: string;
18826
+ inputNode: HTMLInputElement;
18827
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
18828
+ close: () => any;
18829
+ select: (option: string) => any;
18830
+ }, string, PublicProps, Readonly<{
18831
+ id: string;
18832
+ isOpen: boolean;
18833
+ options: string[];
18834
+ activeOption: string | null;
18835
+ activeOptionId: string;
18836
+ inputNode: HTMLInputElement;
18837
+ }> & Readonly<{
18838
+ onClose?: (() => any) | undefined;
18839
+ onSelect?: ((option: string) => any) | undefined;
18840
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
18841
+ listbox: HTMLUListElement;
18842
+ }, HTMLDivElement>;
18843
+ IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
18844
+ toggle: () => any;
18845
+ }, string, PublicProps, Readonly<{}> & Readonly<{
18846
+ onToggle?: (() => any) | undefined;
18847
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
17925
18848
  }, {}, string, ComponentProvideOptions, true, {}, any>;
17926
18849
 
17927
18850
  export declare const FTooltip: DefineComponent<ExtractPropTypes< {
@@ -19594,6 +20517,22 @@ rotate: string;
19594
20517
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
19595
20518
  }, {}, string, ComponentProvideOptions, true, {}, any>;
19596
20519
 
20520
+ export declare const IComboboxDropdown: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
20521
+ close: () => any;
20522
+ select: (option: string) => any;
20523
+ }, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
20524
+ onClose?: (() => any) | undefined;
20525
+ onSelect?: ((option: string) => any) | undefined;
20526
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
20527
+ listbox: HTMLUListElement;
20528
+ }, HTMLDivElement>;
20529
+
20530
+ export declare const IComboboxToggleButton: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
20531
+ toggle: () => any;
20532
+ }, string, PublicProps, Readonly<{}> & Readonly<{
20533
+ onToggle?: (() => any) | undefined;
20534
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;
20535
+
19597
20536
  export declare const IFlex: DefineComponent<ExtractPropTypes< {
19598
20537
  /**
19599
20538
  * Set gap (gutter) between items.
@@ -20101,6 +21040,7 @@ declare interface IPopupListboxProps {
20101
21040
  anchor: HTMLElement | null;
20102
21041
  numOfItems: number;
20103
21042
  itemHeight?: number;
21043
+ activeElement?: HTMLElement | undefined;
20104
21044
  }
20105
21045
 
20106
21046
  export declare const IPopupMenu: DefineComponent<ExtractPropTypes< {
@@ -20837,6 +21777,21 @@ export declare function tableScrollClasses(val: TableScroll): string[];
20837
21777
  */
20838
21778
  export declare const TestPlugin: Plugin_2;
20839
21779
 
21780
+ /**
21781
+ * @public
21782
+ */
21783
+ export declare interface TextFieldSetupProps {
21784
+ id: string;
21785
+ inline: boolean;
21786
+ modelValue: string | number;
21787
+ type: string;
21788
+ formatter?: FormatFunction<unknown>;
21789
+ parser?: ParseFunction<unknown>;
21790
+ labelWidth: string;
21791
+ inputWidth: string;
21792
+ options?: string[];
21793
+ }
21794
+
20840
21795
  /* Excluded from this release type: tooltipAttachTo */
20841
21796
 
20842
21797
  /**
@@ -20897,6 +21852,20 @@ export declare const UNHANDLED_ERROR_EVENT: "unhandled-error";
20897
21852
  */
20898
21853
  export declare type UnknownItem = Record<string, unknown>;
20899
21854
 
21855
+ /**
21856
+ * @public
21857
+ */
21858
+ export declare function useCombobox(inputRef: Readonly<ShallowRef<HTMLInputElement | null>>, options: string[] | undefined, onOptionSelected?: (value: string) => void): {
21859
+ dropdownId: string;
21860
+ dropdownIsOpen: Readonly<Ref<boolean>>;
21861
+ dropdownOptions: Readonly<Ref<string[]>>;
21862
+ activeOptionId: string;
21863
+ activeOption: Readonly<Ref<string | null>>;
21864
+ toggleDropdown: () => void;
21865
+ selectOption: (value: string) => void;
21866
+ closeDropdown: () => void;
21867
+ };
21868
+
20900
21869
  /**
20901
21870
  * Composable to get access to modal functions.
20902
21871
  *
@@ -20955,6 +21924,26 @@ export declare interface UseSlotUtils {
20955
21924
  */
20956
21925
  export declare function useSlotUtils(): UseSlotUtils;
20957
21926
 
21927
+ /**
21928
+ * Setup logic used by `FTextField`.
21929
+ * Components extending `FTextField` reuse the same setup.
21930
+ *
21931
+ * @public
21932
+ */
21933
+ export declare function useTextFieldSetup(props: TextFieldSetupProps): {
21934
+ textFieldTableMode: boolean;
21935
+ viewValue: Ref<string>;
21936
+ onOptionSelected: (value: string) => void;
21937
+ dropdownId: string;
21938
+ dropdownIsOpen: Readonly<Ref<boolean>>;
21939
+ dropdownOptions: Readonly<Ref<string[]>>;
21940
+ activeOptionId: string;
21941
+ activeOption: Readonly<Ref<string | null>>;
21942
+ toggleDropdown: () => void;
21943
+ selectOption: (value: string) => void;
21944
+ closeDropdown: () => void;
21945
+ };
21946
+
20958
21947
  /**
20959
21948
  * Translation function.
20960
21949
  * @public