@fkui/vue 5.42.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>>;
@@ -2798,6 +2987,17 @@ type: PropType<FModalButtonDescriptor[]>;
2798
2987
  required: false;
2799
2988
  default: () => FModalButtonDescriptor[];
2800
2989
  };
2990
+ /**
2991
+ * Default behavior is that the modal will restore focus to previous element once closed.
2992
+ * - "on" (default) - component will set focus both when opened and closed
2993
+ * - "off" - focus strategy disabled
2994
+ * - "open" - focus will only be applied once modal is opened
2995
+ */
2996
+ focus: {
2997
+ type: PropType<"on" | "off" | "open">;
2998
+ default: string;
2999
+ validator(value: string): boolean;
3000
+ };
2801
3001
  }>, {}, {}, {
2802
3002
  preparedButtons(): FModalButton[];
2803
3003
  }, {
@@ -2860,9 +3060,21 @@ type: PropType<FModalButtonDescriptor[]>;
2860
3060
  required: false;
2861
3061
  default: () => FModalButtonDescriptor[];
2862
3062
  };
3063
+ /**
3064
+ * Default behavior is that the modal will restore focus to previous element once closed.
3065
+ * - "on" (default) - component will set focus both when opened and closed
3066
+ * - "off" - focus strategy disabled
3067
+ * - "open" - focus will only be applied once modal is opened
3068
+ */
3069
+ focus: {
3070
+ type: PropType<"on" | "off" | "open">;
3071
+ default: string;
3072
+ validator(value: string): boolean;
3073
+ };
2863
3074
  }>> & Readonly<{
2864
3075
  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
2865
3076
  }>, {
3077
+ focus: "on" | "off" | "open";
2866
3078
  size: string;
2867
3079
  content: string;
2868
3080
  isOpen: boolean;
@@ -2902,6 +3114,11 @@ type: StringConstructor;
2902
3114
  default: string;
2903
3115
  validator(value: string): boolean;
2904
3116
  };
3117
+ focus: {
3118
+ type: PropType<"on" | "off" | "open">;
3119
+ default: string;
3120
+ validator(value: string): boolean;
3121
+ };
2905
3122
  }>, {}, FModalData, {
2906
3123
  modalClass(): string[];
2907
3124
  containerClasses(): string[];
@@ -2944,9 +3161,15 @@ type: StringConstructor;
2944
3161
  default: string;
2945
3162
  validator(value: string): boolean;
2946
3163
  };
3164
+ focus: {
3165
+ type: PropType<"on" | "off" | "open">;
3166
+ default: string;
3167
+ validator(value: string): boolean;
3168
+ };
2947
3169
  }>> & Readonly<{
2948
3170
  onClose?: ((...args: any[]) => any) | undefined;
2949
3171
  }>, {
3172
+ focus: "on" | "off" | "open";
2950
3173
  type: "" | "warning" | "error" | "information";
2951
3174
  size: string;
2952
3175
  isOpen: boolean;
@@ -3732,6 +3955,11 @@ type: StringConstructor;
3732
3955
  default: string;
3733
3956
  validator(value: string): boolean;
3734
3957
  };
3958
+ focus: {
3959
+ type: PropType<"on" | "off" | "open">;
3960
+ default: string;
3961
+ validator(value: string): boolean;
3962
+ };
3735
3963
  }>, {}, FModalData, {
3736
3964
  modalClass(): string[];
3737
3965
  containerClasses(): string[];
@@ -3774,9 +4002,15 @@ type: StringConstructor;
3774
4002
  default: string;
3775
4003
  validator(value: string): boolean;
3776
4004
  };
4005
+ focus: {
4006
+ type: PropType<"on" | "off" | "open">;
4007
+ default: string;
4008
+ validator(value: string): boolean;
4009
+ };
3777
4010
  }>> & Readonly<{
3778
4011
  onClose?: ((...args: any[]) => any) | undefined;
3779
4012
  }>, {
4013
+ focus: "on" | "off" | "open";
3780
4014
  type: "" | "warning" | "error" | "information";
3781
4015
  size: string;
3782
4016
  isOpen: boolean;
@@ -4169,6 +4403,11 @@ type: PropType<FModalButtonDescriptor[]>;
4169
4403
  required: false;
4170
4404
  default: () => FModalButtonDescriptor[];
4171
4405
  };
4406
+ focus: {
4407
+ type: PropType<"on" | "off" | "open">;
4408
+ default: string;
4409
+ validator(value: string): boolean;
4410
+ };
4172
4411
  }>, {}, {}, {
4173
4412
  preparedButtons(): FModalButton[];
4174
4413
  }, {
@@ -4210,9 +4449,15 @@ type: PropType<FModalButtonDescriptor[]>;
4210
4449
  required: false;
4211
4450
  default: () => FModalButtonDescriptor[];
4212
4451
  };
4452
+ focus: {
4453
+ type: PropType<"on" | "off" | "open">;
4454
+ default: string;
4455
+ validator(value: string): boolean;
4456
+ };
4213
4457
  }>> & Readonly<{
4214
4458
  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
4215
4459
  }>, {
4460
+ focus: "on" | "off" | "open";
4216
4461
  size: string;
4217
4462
  content: string;
4218
4463
  isOpen: boolean;
@@ -4252,6 +4497,11 @@ type: StringConstructor;
4252
4497
  default: string;
4253
4498
  validator(value: string): boolean;
4254
4499
  };
4500
+ focus: {
4501
+ type: PropType<"on" | "off" | "open">;
4502
+ default: string;
4503
+ validator(value: string): boolean;
4504
+ };
4255
4505
  }>, {}, FModalData, {
4256
4506
  modalClass(): string[];
4257
4507
  containerClasses(): string[];
@@ -4294,9 +4544,15 @@ type: StringConstructor;
4294
4544
  default: string;
4295
4545
  validator(value: string): boolean;
4296
4546
  };
4547
+ focus: {
4548
+ type: PropType<"on" | "off" | "open">;
4549
+ default: string;
4550
+ validator(value: string): boolean;
4551
+ };
4297
4552
  }>> & Readonly<{
4298
4553
  onClose?: ((...args: any[]) => any) | undefined;
4299
4554
  }>, {
4555
+ focus: "on" | "off" | "open";
4300
4556
  type: "" | "warning" | "error" | "information";
4301
4557
  size: string;
4302
4558
  isOpen: boolean;
@@ -4452,6 +4708,16 @@ default: typeof parseNumber;
4452
4708
  };
4453
4709
  }>, {
4454
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;
4455
4721
  }, {
4456
4722
  defaultText: string;
4457
4723
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -4495,11 +4761,25 @@ type: StringConstructor;
4495
4761
  required: false;
4496
4762
  default: string;
4497
4763
  };
4764
+ options: {
4765
+ type: PropType<string[] | undefined>;
4766
+ required: false;
4767
+ default: () => undefined;
4768
+ };
4498
4769
  }>, {
4499
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;
4500
4781
  }, {
4501
4782
  showErrorPopup: boolean;
4502
- viewValue: string;
4503
4783
  lastModelValue: unknown;
4504
4784
  validationMessage: string;
4505
4785
  validityMode: string;
@@ -4519,6 +4799,8 @@ labelWrapperClass(): string | undefined;
4519
4799
  inputWrapperClass(): string | undefined;
4520
4800
  isModelUpdatedProgrammatically(): boolean;
4521
4801
  }, {
4802
+ onDropdownSelect(value: string): void;
4803
+ onDropdownClose(): void;
4522
4804
  getErrorPopupAnchor(): HTMLElement;
4523
4805
  closePopupError(): void;
4524
4806
  onChange(): Promise<void>;
@@ -4572,6 +4854,11 @@ type: StringConstructor;
4572
4854
  required: false;
4573
4855
  default: string;
4574
4856
  };
4857
+ options: {
4858
+ type: PropType<string[] | undefined>;
4859
+ required: false;
4860
+ default: () => undefined;
4861
+ };
4575
4862
  }>> & Readonly<{
4576
4863
  onBlur?: ((...args: any[]) => any) | undefined;
4577
4864
  onChange?: ((...args: any[]) => any) | undefined;
@@ -4582,6 +4869,7 @@ type: string;
4582
4869
  id: string;
4583
4870
  modelValue: string | number;
4584
4871
  inline: boolean;
4872
+ options: string[] | undefined;
4585
4873
  labelWidth: string;
4586
4874
  formatter: FormatFunction<any>;
4587
4875
  parser: ParseFunction<any>;
@@ -4820,6 +5108,34 @@ flip: string;
4820
5108
  rotate: string;
4821
5109
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
4822
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>;
4823
5139
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
4824
5140
  formatter: {
4825
5141
  type: PropType<FormatFunction<number>>;
@@ -5564,11 +5880,25 @@ type: StringConstructor;
5564
5880
  required: false;
5565
5881
  default: string;
5566
5882
  };
5883
+ options: {
5884
+ type: PropType<string[] | undefined>;
5885
+ required: false;
5886
+ default: () => undefined;
5887
+ };
5567
5888
  }>, {
5568
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;
5569
5900
  }, {
5570
5901
  showErrorPopup: boolean;
5571
- viewValue: string;
5572
5902
  lastModelValue: unknown;
5573
5903
  validationMessage: string;
5574
5904
  validityMode: string;
@@ -5588,6 +5918,8 @@ labelWrapperClass(): string | undefined;
5588
5918
  inputWrapperClass(): string | undefined;
5589
5919
  isModelUpdatedProgrammatically(): boolean;
5590
5920
  }, {
5921
+ onDropdownSelect(value: string): void;
5922
+ onDropdownClose(): void;
5591
5923
  getErrorPopupAnchor(): HTMLElement;
5592
5924
  closePopupError(): void;
5593
5925
  onChange(): Promise<void>;
@@ -5641,6 +5973,11 @@ type: StringConstructor;
5641
5973
  required: false;
5642
5974
  default: string;
5643
5975
  };
5976
+ options: {
5977
+ type: PropType<string[] | undefined>;
5978
+ required: false;
5979
+ default: () => undefined;
5980
+ };
5644
5981
  }>> & Readonly<{
5645
5982
  onBlur?: ((...args: any[]) => any) | undefined;
5646
5983
  onChange?: ((...args: any[]) => any) | undefined;
@@ -5651,6 +5988,7 @@ type: string;
5651
5988
  id: string;
5652
5989
  modelValue: string | number;
5653
5990
  inline: boolean;
5991
+ options: string[] | undefined;
5654
5992
  labelWidth: string;
5655
5993
  formatter: FormatFunction<any>;
5656
5994
  parser: ParseFunction<any>;
@@ -5889,6 +6227,34 @@ flip: string;
5889
6227
  rotate: string;
5890
6228
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
5891
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>;
5892
6258
  }, {}, string, ComponentProvideOptions, true, {}, any>;
5893
6259
  FIcon: DefineComponent<ExtractPropTypes< {
5894
6260
  name: {
@@ -6295,11 +6661,25 @@ type: StringConstructor;
6295
6661
  required: false;
6296
6662
  default: string;
6297
6663
  };
6664
+ options: {
6665
+ type: PropType<string[] | undefined>;
6666
+ required: false;
6667
+ default: () => undefined;
6668
+ };
6298
6669
  }>, {
6299
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;
6300
6681
  }, {
6301
6682
  showErrorPopup: boolean;
6302
- viewValue: string;
6303
6683
  lastModelValue: unknown;
6304
6684
  validationMessage: string;
6305
6685
  validityMode: string;
@@ -6319,6 +6699,8 @@ labelWrapperClass(): string | undefined;
6319
6699
  inputWrapperClass(): string | undefined;
6320
6700
  isModelUpdatedProgrammatically(): boolean;
6321
6701
  }, {
6702
+ onDropdownSelect(value: string): void;
6703
+ onDropdownClose(): void;
6322
6704
  getErrorPopupAnchor(): HTMLElement;
6323
6705
  closePopupError(): void;
6324
6706
  onChange(): Promise<void>;
@@ -6372,6 +6754,11 @@ type: StringConstructor;
6372
6754
  required: false;
6373
6755
  default: string;
6374
6756
  };
6757
+ options: {
6758
+ type: PropType<string[] | undefined>;
6759
+ required: false;
6760
+ default: () => undefined;
6761
+ };
6375
6762
  }>> & Readonly<{
6376
6763
  onBlur?: ((...args: any[]) => any) | undefined;
6377
6764
  onChange?: ((...args: any[]) => any) | undefined;
@@ -6382,6 +6769,7 @@ type: string;
6382
6769
  id: string;
6383
6770
  modelValue: string | number;
6384
6771
  inline: boolean;
6772
+ options: string[] | undefined;
6385
6773
  labelWidth: string;
6386
6774
  formatter: FormatFunction<any>;
6387
6775
  parser: ParseFunction<any>;
@@ -6620,6 +7008,34 @@ flip: string;
6620
7008
  rotate: string;
6621
7009
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
6622
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>;
6623
7039
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6624
7040
  }, {}, string, ComponentProvideOptions, true, {}, any>;
6625
7041
 
@@ -7188,9 +7604,9 @@ onToggle?: ((...args: any[]) => any) | undefined;
7188
7604
  }>, {
7189
7605
  id: string;
7190
7606
  expanded: boolean;
7607
+ list: boolean;
7191
7608
  headerTag: string;
7192
7609
  headerVisualTag: string;
7193
- list: boolean;
7194
7610
  }, {}, {
7195
7611
  FIcon: DefineComponent<ExtractPropTypes< {
7196
7612
  name: {
@@ -8464,6 +8880,11 @@ type: StringConstructor;
8464
8880
  default: string;
8465
8881
  validator(value: string): boolean;
8466
8882
  };
8883
+ focus: {
8884
+ type: PropType<"on" | "off" | "open">;
8885
+ default: string;
8886
+ validator(value: string): boolean;
8887
+ };
8467
8888
  }>, {}, FModalData, {
8468
8889
  modalClass(): string[];
8469
8890
  containerClasses(): string[];
@@ -8506,9 +8927,15 @@ type: StringConstructor;
8506
8927
  default: string;
8507
8928
  validator(value: string): boolean;
8508
8929
  };
8930
+ focus: {
8931
+ type: PropType<"on" | "off" | "open">;
8932
+ default: string;
8933
+ validator(value: string): boolean;
8934
+ };
8509
8935
  }>> & Readonly<{
8510
8936
  onClose?: ((...args: any[]) => any) | undefined;
8511
8937
  }>, {
8938
+ focus: "on" | "off" | "open";
8512
8939
  type: "" | "warning" | "error" | "information";
8513
8940
  size: string;
8514
8941
  isOpen: boolean;
@@ -10825,6 +11252,17 @@ type: StringConstructor;
10825
11252
  default: string;
10826
11253
  validator(value: string): boolean;
10827
11254
  };
11255
+ /**
11256
+ * Default behavior is that the modal will restore focus to previous element once closed.
11257
+ * - "on" (default) - component will set focus both when opened and closed
11258
+ * - "off" - focus strategy disabled
11259
+ * - "open" - focus will only be applied once modal is opened
11260
+ */
11261
+ focus: {
11262
+ type: PropType<"on" | "off" | "open">;
11263
+ default: string;
11264
+ validator(value: string): boolean;
11265
+ };
10828
11266
  }>, {}, FModalData, {
10829
11267
  modalClass(): string[];
10830
11268
  containerClasses(): string[];
@@ -10894,9 +11332,21 @@ type: StringConstructor;
10894
11332
  default: string;
10895
11333
  validator(value: string): boolean;
10896
11334
  };
11335
+ /**
11336
+ * Default behavior is that the modal will restore focus to previous element once closed.
11337
+ * - "on" (default) - component will set focus both when opened and closed
11338
+ * - "off" - focus strategy disabled
11339
+ * - "open" - focus will only be applied once modal is opened
11340
+ */
11341
+ focus: {
11342
+ type: PropType<"on" | "off" | "open">;
11343
+ default: string;
11344
+ validator(value: string): boolean;
11345
+ };
10897
11346
  }>> & Readonly<{
10898
11347
  onClose?: ((...args: any[]) => any) | undefined;
10899
11348
  }>, {
11349
+ focus: "on" | "off" | "open";
10900
11350
  type: "" | "warning" | "error" | "information";
10901
11351
  size: string;
10902
11352
  isOpen: boolean;
@@ -11482,6 +11932,16 @@ default: typeof parseNumber;
11482
11932
  };
11483
11933
  }>, {
11484
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;
11485
11945
  }, {}, {}, {}, ComponentOptionsMixin, DefineComponent<ExtractPropTypes< {
11486
11946
  id: {
11487
11947
  type: StringConstructor;
@@ -11523,11 +11983,25 @@ type: StringConstructor;
11523
11983
  required: false;
11524
11984
  default: string;
11525
11985
  };
11986
+ options: {
11987
+ type: PropType<string[] | undefined>;
11988
+ required: false;
11989
+ default: () => undefined;
11990
+ };
11526
11991
  }>, {
11527
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;
11528
12003
  }, {
11529
12004
  showErrorPopup: boolean;
11530
- viewValue: string;
11531
12005
  lastModelValue: unknown;
11532
12006
  validationMessage: string;
11533
12007
  validityMode: string;
@@ -11547,6 +12021,8 @@ labelWrapperClass(): string | undefined;
11547
12021
  inputWrapperClass(): string | undefined;
11548
12022
  isModelUpdatedProgrammatically(): boolean;
11549
12023
  }, {
12024
+ onDropdownSelect(value: string): void;
12025
+ onDropdownClose(): void;
11550
12026
  getErrorPopupAnchor(): HTMLElement;
11551
12027
  closePopupError(): void;
11552
12028
  onChange(): Promise<void>;
@@ -11600,6 +12076,11 @@ type: StringConstructor;
11600
12076
  required: false;
11601
12077
  default: string;
11602
12078
  };
12079
+ options: {
12080
+ type: PropType<string[] | undefined>;
12081
+ required: false;
12082
+ default: () => undefined;
12083
+ };
11603
12084
  }>> & Readonly<{
11604
12085
  onBlur?: ((...args: any[]) => any) | undefined;
11605
12086
  onChange?: ((...args: any[]) => any) | undefined;
@@ -11610,6 +12091,7 @@ type: string;
11610
12091
  id: string;
11611
12092
  modelValue: string | number;
11612
12093
  inline: boolean;
12094
+ options: string[] | undefined;
11613
12095
  labelWidth: string;
11614
12096
  formatter: FormatFunction<any>;
11615
12097
  parser: ParseFunction<any>;
@@ -11848,6 +12330,34 @@ flip: string;
11848
12330
  rotate: string;
11849
12331
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
11850
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>;
11851
12361
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
11852
12362
  /**
11853
12363
  * The number of decimals to format number as.
@@ -12045,6 +12555,16 @@ default: typeof parseOrganisationsnummer;
12045
12555
  };
12046
12556
  }>, {
12047
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;
12048
12568
  }, {
12049
12569
  defaultText: string;
12050
12570
  discreteDescriptionText: string;
@@ -12090,11 +12610,25 @@ type: StringConstructor;
12090
12610
  required: false;
12091
12611
  default: string;
12092
12612
  };
12613
+ options: {
12614
+ type: PropType<string[] | undefined>;
12615
+ required: false;
12616
+ default: () => undefined;
12617
+ };
12093
12618
  }>, {
12094
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;
12095
12630
  }, {
12096
12631
  showErrorPopup: boolean;
12097
- viewValue: string;
12098
12632
  lastModelValue: unknown;
12099
12633
  validationMessage: string;
12100
12634
  validityMode: string;
@@ -12114,6 +12648,8 @@ labelWrapperClass(): string | undefined;
12114
12648
  inputWrapperClass(): string | undefined;
12115
12649
  isModelUpdatedProgrammatically(): boolean;
12116
12650
  }, {
12651
+ onDropdownSelect(value: string): void;
12652
+ onDropdownClose(): void;
12117
12653
  getErrorPopupAnchor(): HTMLElement;
12118
12654
  closePopupError(): void;
12119
12655
  onChange(): Promise<void>;
@@ -12167,6 +12703,11 @@ type: StringConstructor;
12167
12703
  required: false;
12168
12704
  default: string;
12169
12705
  };
12706
+ options: {
12707
+ type: PropType<string[] | undefined>;
12708
+ required: false;
12709
+ default: () => undefined;
12710
+ };
12170
12711
  }>> & Readonly<{
12171
12712
  onBlur?: ((...args: any[]) => any) | undefined;
12172
12713
  onChange?: ((...args: any[]) => any) | undefined;
@@ -12177,6 +12718,7 @@ type: string;
12177
12718
  id: string;
12178
12719
  modelValue: string | number;
12179
12720
  inline: boolean;
12721
+ options: string[] | undefined;
12180
12722
  labelWidth: string;
12181
12723
  formatter: FormatFunction<any>;
12182
12724
  parser: ParseFunction<any>;
@@ -12415,6 +12957,34 @@ flip: string;
12415
12957
  rotate: string;
12416
12958
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
12417
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>;
12418
12988
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
12419
12989
  formatter: {
12420
12990
  type: PropType<FormatFunction<OrganisationsnummerString>>;
@@ -12821,6 +13391,16 @@ default: typeof parsePercent;
12821
13391
  };
12822
13392
  }>, {
12823
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;
12824
13404
  }, {
12825
13405
  defaultText: string;
12826
13406
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -12864,11 +13444,25 @@ type: StringConstructor;
12864
13444
  required: false;
12865
13445
  default: string;
12866
13446
  };
13447
+ options: {
13448
+ type: PropType<string[] | undefined>;
13449
+ required: false;
13450
+ default: () => undefined;
13451
+ };
12867
13452
  }>, {
12868
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;
12869
13464
  }, {
12870
13465
  showErrorPopup: boolean;
12871
- viewValue: string;
12872
13466
  lastModelValue: unknown;
12873
13467
  validationMessage: string;
12874
13468
  validityMode: string;
@@ -12888,6 +13482,8 @@ labelWrapperClass(): string | undefined;
12888
13482
  inputWrapperClass(): string | undefined;
12889
13483
  isModelUpdatedProgrammatically(): boolean;
12890
13484
  }, {
13485
+ onDropdownSelect(value: string): void;
13486
+ onDropdownClose(): void;
12891
13487
  getErrorPopupAnchor(): HTMLElement;
12892
13488
  closePopupError(): void;
12893
13489
  onChange(): Promise<void>;
@@ -12941,6 +13537,11 @@ type: StringConstructor;
12941
13537
  required: false;
12942
13538
  default: string;
12943
13539
  };
13540
+ options: {
13541
+ type: PropType<string[] | undefined>;
13542
+ required: false;
13543
+ default: () => undefined;
13544
+ };
12944
13545
  }>> & Readonly<{
12945
13546
  onBlur?: ((...args: any[]) => any) | undefined;
12946
13547
  onChange?: ((...args: any[]) => any) | undefined;
@@ -12951,6 +13552,7 @@ type: string;
12951
13552
  id: string;
12952
13553
  modelValue: string | number;
12953
13554
  inline: boolean;
13555
+ options: string[] | undefined;
12954
13556
  labelWidth: string;
12955
13557
  formatter: FormatFunction<any>;
12956
13558
  parser: ParseFunction<any>;
@@ -13189,6 +13791,34 @@ flip: string;
13189
13791
  rotate: string;
13190
13792
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
13191
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>;
13192
13822
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
13193
13823
  /**
13194
13824
  * The number of decimals to format number as.
@@ -13227,6 +13857,16 @@ default: typeof parsePersonnummer;
13227
13857
  };
13228
13858
  }>, {
13229
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;
13230
13870
  }, {
13231
13871
  defaultText: string;
13232
13872
  discreteDescriptionText: string;
@@ -13272,11 +13912,25 @@ type: StringConstructor;
13272
13912
  required: false;
13273
13913
  default: string;
13274
13914
  };
13915
+ options: {
13916
+ type: PropType<string[] | undefined>;
13917
+ required: false;
13918
+ default: () => undefined;
13919
+ };
13275
13920
  }>, {
13276
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;
13277
13932
  }, {
13278
13933
  showErrorPopup: boolean;
13279
- viewValue: string;
13280
13934
  lastModelValue: unknown;
13281
13935
  validationMessage: string;
13282
13936
  validityMode: string;
@@ -13296,6 +13950,8 @@ labelWrapperClass(): string | undefined;
13296
13950
  inputWrapperClass(): string | undefined;
13297
13951
  isModelUpdatedProgrammatically(): boolean;
13298
13952
  }, {
13953
+ onDropdownSelect(value: string): void;
13954
+ onDropdownClose(): void;
13299
13955
  getErrorPopupAnchor(): HTMLElement;
13300
13956
  closePopupError(): void;
13301
13957
  onChange(): Promise<void>;
@@ -13349,6 +14005,11 @@ type: StringConstructor;
13349
14005
  required: false;
13350
14006
  default: string;
13351
14007
  };
14008
+ options: {
14009
+ type: PropType<string[] | undefined>;
14010
+ required: false;
14011
+ default: () => undefined;
14012
+ };
13352
14013
  }>> & Readonly<{
13353
14014
  onBlur?: ((...args: any[]) => any) | undefined;
13354
14015
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13359,6 +14020,7 @@ type: string;
13359
14020
  id: string;
13360
14021
  modelValue: string | number;
13361
14022
  inline: boolean;
14023
+ options: string[] | undefined;
13362
14024
  labelWidth: string;
13363
14025
  formatter: FormatFunction<any>;
13364
14026
  parser: ParseFunction<any>;
@@ -13597,6 +14259,34 @@ flip: string;
13597
14259
  rotate: string;
13598
14260
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
13599
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>;
13600
14290
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
13601
14291
  formatter: {
13602
14292
  type: PropType<FormatFunction<PersonnummerString>>;
@@ -13735,11 +14425,25 @@ type: StringConstructor;
13735
14425
  required: false;
13736
14426
  default: string;
13737
14427
  };
14428
+ options: {
14429
+ type: PropType<string[] | undefined>;
14430
+ required: false;
14431
+ default: () => undefined;
14432
+ };
13738
14433
  }>, {
13739
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;
13740
14445
  }, {
13741
14446
  showErrorPopup: boolean;
13742
- viewValue: string;
13743
14447
  lastModelValue: unknown;
13744
14448
  validationMessage: string;
13745
14449
  validityMode: string;
@@ -13759,6 +14463,8 @@ labelWrapperClass(): string | undefined;
13759
14463
  inputWrapperClass(): string | undefined;
13760
14464
  isModelUpdatedProgrammatically(): boolean;
13761
14465
  }, {
14466
+ onDropdownSelect(value: string): void;
14467
+ onDropdownClose(): void;
13762
14468
  getErrorPopupAnchor(): HTMLElement;
13763
14469
  closePopupError(): void;
13764
14470
  onChange(): Promise<void>;
@@ -13812,6 +14518,11 @@ type: StringConstructor;
13812
14518
  required: false;
13813
14519
  default: string;
13814
14520
  };
14521
+ options: {
14522
+ type: PropType<string[] | undefined>;
14523
+ required: false;
14524
+ default: () => undefined;
14525
+ };
13815
14526
  }>> & Readonly<{
13816
14527
  onBlur?: ((...args: any[]) => any) | undefined;
13817
14528
  onChange?: ((...args: any[]) => any) | undefined;
@@ -13822,6 +14533,7 @@ type: string;
13822
14533
  id: string;
13823
14534
  modelValue: string | number;
13824
14535
  inline: boolean;
14536
+ options: string[] | undefined;
13825
14537
  labelWidth: string;
13826
14538
  formatter: FormatFunction<any>;
13827
14539
  parser: ParseFunction<any>;
@@ -14060,6 +14772,34 @@ flip: string;
14060
14772
  rotate: string;
14061
14773
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14062
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>;
14063
14803
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14064
14804
  }, {}, string, ComponentProvideOptions, true, {}, any>;
14065
14805
 
@@ -14071,6 +14811,16 @@ default: typeof parsePlusgiro;
14071
14811
  };
14072
14812
  }>, {
14073
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;
14074
14824
  }, {
14075
14825
  defaultText: string;
14076
14826
  }, {}, {}, ComponentOptions, DefineComponent<ExtractPropTypes< {
@@ -14114,11 +14864,25 @@ type: StringConstructor;
14114
14864
  required: false;
14115
14865
  default: string;
14116
14866
  };
14867
+ options: {
14868
+ type: PropType<string[] | undefined>;
14869
+ required: false;
14870
+ default: () => undefined;
14871
+ };
14117
14872
  }>, {
14118
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;
14119
14884
  }, {
14120
14885
  showErrorPopup: boolean;
14121
- viewValue: string;
14122
14886
  lastModelValue: unknown;
14123
14887
  validationMessage: string;
14124
14888
  validityMode: string;
@@ -14138,6 +14902,8 @@ labelWrapperClass(): string | undefined;
14138
14902
  inputWrapperClass(): string | undefined;
14139
14903
  isModelUpdatedProgrammatically(): boolean;
14140
14904
  }, {
14905
+ onDropdownSelect(value: string): void;
14906
+ onDropdownClose(): void;
14141
14907
  getErrorPopupAnchor(): HTMLElement;
14142
14908
  closePopupError(): void;
14143
14909
  onChange(): Promise<void>;
@@ -14191,6 +14957,11 @@ type: StringConstructor;
14191
14957
  required: false;
14192
14958
  default: string;
14193
14959
  };
14960
+ options: {
14961
+ type: PropType<string[] | undefined>;
14962
+ required: false;
14963
+ default: () => undefined;
14964
+ };
14194
14965
  }>> & Readonly<{
14195
14966
  onBlur?: ((...args: any[]) => any) | undefined;
14196
14967
  onChange?: ((...args: any[]) => any) | undefined;
@@ -14201,6 +14972,7 @@ type: string;
14201
14972
  id: string;
14202
14973
  modelValue: string | number;
14203
14974
  inline: boolean;
14975
+ options: string[] | undefined;
14204
14976
  labelWidth: string;
14205
14977
  formatter: FormatFunction<any>;
14206
14978
  parser: ParseFunction<any>;
@@ -14439,6 +15211,34 @@ flip: string;
14439
15211
  rotate: string;
14440
15212
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14441
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>;
14442
15242
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
14443
15243
  formatter: {
14444
15244
  type: PropType<FormatFunction<PlusgiroString>>;
@@ -14457,6 +15257,16 @@ default: typeof formatPostalCode;
14457
15257
  };
14458
15258
  }>, {
14459
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;
14460
15270
  }, {
14461
15271
  defaultText: string;
14462
15272
  discreteDescriptionText: string;
@@ -14502,11 +15312,25 @@ type: StringConstructor;
14502
15312
  required: false;
14503
15313
  default: string;
14504
15314
  };
15315
+ options: {
15316
+ type: PropType<string[] | undefined>;
15317
+ required: false;
15318
+ default: () => undefined;
15319
+ };
14505
15320
  }>, {
14506
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;
14507
15332
  }, {
14508
15333
  showErrorPopup: boolean;
14509
- viewValue: string;
14510
15334
  lastModelValue: unknown;
14511
15335
  validationMessage: string;
14512
15336
  validityMode: string;
@@ -14526,6 +15350,8 @@ labelWrapperClass(): string | undefined;
14526
15350
  inputWrapperClass(): string | undefined;
14527
15351
  isModelUpdatedProgrammatically(): boolean;
14528
15352
  }, {
15353
+ onDropdownSelect(value: string): void;
15354
+ onDropdownClose(): void;
14529
15355
  getErrorPopupAnchor(): HTMLElement;
14530
15356
  closePopupError(): void;
14531
15357
  onChange(): Promise<void>;
@@ -14579,6 +15405,11 @@ type: StringConstructor;
14579
15405
  required: false;
14580
15406
  default: string;
14581
15407
  };
15408
+ options: {
15409
+ type: PropType<string[] | undefined>;
15410
+ required: false;
15411
+ default: () => undefined;
15412
+ };
14582
15413
  }>> & Readonly<{
14583
15414
  onBlur?: ((...args: any[]) => any) | undefined;
14584
15415
  onChange?: ((...args: any[]) => any) | undefined;
@@ -14589,6 +15420,7 @@ type: string;
14589
15420
  id: string;
14590
15421
  modelValue: string | number;
14591
15422
  inline: boolean;
15423
+ options: string[] | undefined;
14592
15424
  labelWidth: string;
14593
15425
  formatter: FormatFunction<any>;
14594
15426
  parser: ParseFunction<any>;
@@ -14827,6 +15659,34 @@ flip: string;
14827
15659
  rotate: string;
14828
15660
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
14829
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>;
14830
15690
  }, {}, string, ComponentProvideOptions, true, {}, any>, {}, string, PublicProps, Readonly<ExtractPropTypes< {
14831
15691
  formatter: {
14832
15692
  type: PropType<FormatFunction<PostalCodeString>>;
@@ -15231,11 +16091,25 @@ type: StringConstructor;
15231
16091
  required: false;
15232
16092
  default: string;
15233
16093
  };
16094
+ options: {
16095
+ type: PropType<string[] | undefined>;
16096
+ required: false;
16097
+ default: () => undefined;
16098
+ };
15234
16099
  }>, {
15235
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;
15236
16111
  }, {
15237
16112
  showErrorPopup: boolean;
15238
- viewValue: string;
15239
16113
  lastModelValue: unknown;
15240
16114
  validationMessage: string;
15241
16115
  validityMode: string;
@@ -15255,6 +16129,8 @@ labelWrapperClass(): string | undefined;
15255
16129
  inputWrapperClass(): string | undefined;
15256
16130
  isModelUpdatedProgrammatically(): boolean;
15257
16131
  }, {
16132
+ onDropdownSelect(value: string): void;
16133
+ onDropdownClose(): void;
15258
16134
  getErrorPopupAnchor(): HTMLElement;
15259
16135
  closePopupError(): void;
15260
16136
  onChange(): Promise<void>;
@@ -15308,6 +16184,11 @@ type: StringConstructor;
15308
16184
  required: false;
15309
16185
  default: string;
15310
16186
  };
16187
+ options: {
16188
+ type: PropType<string[] | undefined>;
16189
+ required: false;
16190
+ default: () => undefined;
16191
+ };
15311
16192
  }>> & Readonly<{
15312
16193
  onBlur?: ((...args: any[]) => any) | undefined;
15313
16194
  onChange?: ((...args: any[]) => any) | undefined;
@@ -15318,6 +16199,7 @@ type: string;
15318
16199
  id: string;
15319
16200
  modelValue: string | number;
15320
16201
  inline: boolean;
16202
+ options: string[] | undefined;
15321
16203
  labelWidth: string;
15322
16204
  formatter: FormatFunction<any>;
15323
16205
  parser: ParseFunction<any>;
@@ -15556,6 +16438,34 @@ flip: string;
15556
16438
  rotate: string;
15557
16439
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
15558
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>;
15559
16469
  }, {}, string, ComponentProvideOptions, true, {}, any>;
15560
16470
  FIcon: DefineComponent<ExtractPropTypes< {
15561
16471
  name: {
@@ -16279,11 +17189,25 @@ type: StringConstructor;
16279
17189
  required: false;
16280
17190
  default: string;
16281
17191
  };
17192
+ options: {
17193
+ type: PropType<string[] | undefined>;
17194
+ required: false;
17195
+ default: () => undefined;
17196
+ };
16282
17197
  }>, {
16283
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;
16284
17209
  }, {
16285
17210
  showErrorPopup: boolean;
16286
- viewValue: string;
16287
17211
  lastModelValue: unknown;
16288
17212
  validationMessage: string;
16289
17213
  validityMode: string;
@@ -16303,6 +17227,8 @@ labelWrapperClass(): string | undefined;
16303
17227
  inputWrapperClass(): string | undefined;
16304
17228
  isModelUpdatedProgrammatically(): boolean;
16305
17229
  }, {
17230
+ onDropdownSelect(value: string): void;
17231
+ onDropdownClose(): void;
16306
17232
  getErrorPopupAnchor(): HTMLElement;
16307
17233
  closePopupError(): void;
16308
17234
  onChange(): Promise<void>;
@@ -16356,6 +17282,11 @@ type: StringConstructor;
16356
17282
  required: false;
16357
17283
  default: string;
16358
17284
  };
17285
+ options: {
17286
+ type: PropType<string[] | undefined>;
17287
+ required: false;
17288
+ default: () => undefined;
17289
+ };
16359
17290
  }>> & Readonly<{
16360
17291
  onBlur?: ((...args: any[]) => any) | undefined;
16361
17292
  onChange?: ((...args: any[]) => any) | undefined;
@@ -16366,6 +17297,7 @@ type: string;
16366
17297
  id: string;
16367
17298
  modelValue: string | number;
16368
17299
  inline: boolean;
17300
+ options: string[] | undefined;
16369
17301
  labelWidth: string;
16370
17302
  formatter: FormatFunction<any>;
16371
17303
  parser: ParseFunction<any>;
@@ -16604,6 +17536,34 @@ flip: string;
16604
17536
  rotate: string;
16605
17537
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
16606
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>;
16607
17567
  }, {}, string, ComponentProvideOptions, true, {}, any>;
16608
17568
  FIcon: DefineComponent<ExtractPropTypes< {
16609
17569
  name: {
@@ -17446,11 +18406,32 @@ type: StringConstructor;
17446
18406
  required: false;
17447
18407
  default: string;
17448
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
+ };
17449
18421
  }>, {
17450
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;
17451
18433
  }, {
17452
18434
  showErrorPopup: boolean;
17453
- viewValue: string;
17454
18435
  lastModelValue: unknown;
17455
18436
  validationMessage: string;
17456
18437
  validityMode: string;
@@ -17470,6 +18451,8 @@ labelWrapperClass(): string | undefined;
17470
18451
  inputWrapperClass(): string | undefined;
17471
18452
  isModelUpdatedProgrammatically(): boolean;
17472
18453
  }, {
18454
+ onDropdownSelect(value: string): void;
18455
+ onDropdownClose(): void;
17473
18456
  getErrorPopupAnchor(): HTMLElement;
17474
18457
  closePopupError(): void;
17475
18458
  onChange(): Promise<void>;
@@ -17573,6 +18556,18 @@ type: StringConstructor;
17573
18556
  required: false;
17574
18557
  default: string;
17575
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
+ };
17576
18571
  }>> & Readonly<{
17577
18572
  onBlur?: ((...args: any[]) => any) | undefined;
17578
18573
  onChange?: ((...args: any[]) => any) | undefined;
@@ -17583,6 +18578,7 @@ type: string;
17583
18578
  id: string;
17584
18579
  modelValue: string | number;
17585
18580
  inline: boolean;
18581
+ options: string[] | undefined;
17586
18582
  labelWidth: string;
17587
18583
  formatter: FormatFunction<any>;
17588
18584
  parser: ParseFunction<any>;
@@ -17821,6 +18817,34 @@ flip: string;
17821
18817
  rotate: string;
17822
18818
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
17823
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>;
17824
18848
  }, {}, string, ComponentProvideOptions, true, {}, any>;
17825
18849
 
17826
18850
  export declare const FTooltip: DefineComponent<ExtractPropTypes< {
@@ -19493,6 +20517,22 @@ rotate: string;
19493
20517
  }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
19494
20518
  }, {}, string, ComponentProvideOptions, true, {}, any>;
19495
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
+
19496
20536
  export declare const IFlex: DefineComponent<ExtractPropTypes< {
19497
20537
  /**
19498
20538
  * Set gap (gutter) between items.
@@ -20000,6 +21040,7 @@ declare interface IPopupListboxProps {
20000
21040
  anchor: HTMLElement | null;
20001
21041
  numOfItems: number;
20002
21042
  itemHeight?: number;
21043
+ activeElement?: HTMLElement | undefined;
20003
21044
  }
20004
21045
 
20005
21046
  export declare const IPopupMenu: DefineComponent<ExtractPropTypes< {
@@ -20736,6 +21777,21 @@ export declare function tableScrollClasses(val: TableScroll): string[];
20736
21777
  */
20737
21778
  export declare const TestPlugin: Plugin_2;
20738
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
+
20739
21795
  /* Excluded from this release type: tooltipAttachTo */
20740
21796
 
20741
21797
  /**
@@ -20796,6 +21852,20 @@ export declare const UNHANDLED_ERROR_EVENT: "unhandled-error";
20796
21852
  */
20797
21853
  export declare type UnknownItem = Record<string, unknown>;
20798
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
+
20799
21869
  /**
20800
21870
  * Composable to get access to modal functions.
20801
21871
  *
@@ -20854,6 +21924,26 @@ export declare interface UseSlotUtils {
20854
21924
  */
20855
21925
  export declare function useSlotUtils(): UseSlotUtils;
20856
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
+
20857
21947
  /**
20858
21948
  * Translation function.
20859
21949
  * @public