xref: /openbmc/phosphor-power/elog-errors.hpp (revision 48781aef) 
1 // This file was autogenerated.  Do not edit!
2 // See elog-gen.py for more details
3 #pragma once
4 
5 #include <phosphor-logging/elog.hpp>
6 #include <phosphor-logging/log.hpp>
7 #include <sdbusplus/exception.hpp>
8 
9 #include <string>
10 #include <tuple>
11 #include <type_traits>
12 
13 namespace sdbusplus
14 {
15 namespace org
16 {
17 namespace open_power
18 {
19 namespace Witherspoon
20 {
21 namespace Fault
22 {
23 namespace Error
24 {
25 struct MemoryPowerFault;
26 } // namespace Error
27 } // namespace Fault
28 } // namespace Witherspoon
29 } // namespace open_power
30 } // namespace org
31 } // namespace sdbusplus
32 
33 namespace sdbusplus
34 {
35 namespace org
36 {
37 namespace open_power
38 {
39 namespace Witherspoon
40 {
41 namespace Fault
42 {
43 namespace Error
44 {
45 struct GPUPowerFault;
46 } // namespace Error
47 } // namespace Fault
48 } // namespace Witherspoon
49 } // namespace open_power
50 } // namespace org
51 } // namespace sdbusplus
52 
53 namespace sdbusplus
54 {
55 namespace org
56 {
57 namespace open_power
58 {
59 namespace Witherspoon
60 {
61 namespace Fault
62 {
63 namespace Error
64 {
65 struct PowerSequencerPGOODFault;
66 } // namespace Error
67 } // namespace Fault
68 } // namespace Witherspoon
69 } // namespace open_power
70 } // namespace org
71 } // namespace sdbusplus
72 
73 namespace sdbusplus
74 {
75 namespace org
76 {
77 namespace open_power
78 {
79 namespace Witherspoon
80 {
81 namespace Fault
82 {
83 namespace Error
84 {
85 struct PowerSequencerVoltageFault;
86 } // namespace Error
87 } // namespace Fault
88 } // namespace Witherspoon
89 } // namespace open_power
90 } // namespace org
91 } // namespace sdbusplus
92 
93 namespace sdbusplus
94 {
95 namespace org
96 {
97 namespace open_power
98 {
99 namespace Witherspoon
100 {
101 namespace Fault
102 {
103 namespace Error
104 {
105 struct GPUOverTemp;
106 } // namespace Error
107 } // namespace Fault
108 } // namespace Witherspoon
109 } // namespace open_power
110 } // namespace org
111 } // namespace sdbusplus
112 
113 namespace sdbusplus
114 {
115 namespace xyz
116 {
117 namespace openbmc_project
118 {
119 namespace Common
120 {
121 namespace Callout
122 {
123 namespace Error
124 {
125 struct IPMISensor;
126 } // namespace Error
127 } // namespace Callout
128 } // namespace Common
129 } // namespace openbmc_project
130 } // namespace xyz
131 } // namespace sdbusplus
132 
133 namespace sdbusplus
134 {
135 namespace org
136 {
137 namespace open_power
138 {
139 namespace Witherspoon
140 {
141 namespace Fault
142 {
143 namespace Error
144 {
145 struct PowerOnFailure;
146 } // namespace Error
147 } // namespace Fault
148 } // namespace Witherspoon
149 } // namespace open_power
150 } // namespace org
151 } // namespace sdbusplus
152 
153 namespace sdbusplus
154 {
155 namespace org
156 {
157 namespace open_power
158 {
159 namespace Witherspoon
160 {
161 namespace Fault
162 {
163 namespace Error
164 {
165 struct Shutdown;
166 } // namespace Error
167 } // namespace Fault
168 } // namespace Witherspoon
169 } // namespace open_power
170 } // namespace org
171 } // namespace sdbusplus
172 
173 namespace sdbusplus
174 {
175 namespace org
176 {
177 namespace open_power
178 {
179 namespace Witherspoon
180 {
181 namespace Fault
182 {
183 namespace Error
184 {
185 struct PowerSupplyInputFault;
186 } // namespace Error
187 } // namespace Fault
188 } // namespace Witherspoon
189 } // namespace open_power
190 } // namespace org
191 } // namespace sdbusplus
192 
193 namespace sdbusplus
194 {
195 namespace xyz
196 {
197 namespace openbmc_project
198 {
199 namespace Common
200 {
201 namespace Callout
202 {
203 namespace Error
204 {
205 struct Device;
206 } // namespace Error
207 } // namespace Callout
208 } // namespace Common
209 } // namespace openbmc_project
210 } // namespace xyz
211 } // namespace sdbusplus
212 
213 namespace sdbusplus
214 {
215 namespace org
216 {
217 namespace open_power
218 {
219 namespace Witherspoon
220 {
221 namespace Fault
222 {
223 namespace Error
224 {
225 struct ErrorCode15;
226 } // namespace Error
227 } // namespace Fault
228 } // namespace Witherspoon
229 } // namespace open_power
230 } // namespace org
231 } // namespace sdbusplus
232 
233 namespace sdbusplus
234 {
235 namespace org
236 {
237 namespace open_power
238 {
239 namespace Witherspoon
240 {
241 namespace Fault
242 {
243 namespace Error
244 {
245 struct ErrorCode14;
246 } // namespace Error
247 } // namespace Fault
248 } // namespace Witherspoon
249 } // namespace open_power
250 } // namespace org
251 } // namespace sdbusplus
252 
253 namespace sdbusplus
254 {
255 namespace org
256 {
257 namespace open_power
258 {
259 namespace Witherspoon
260 {
261 namespace Fault
262 {
263 namespace Error
264 {
265 struct ErrorCode17;
266 } // namespace Error
267 } // namespace Fault
268 } // namespace Witherspoon
269 } // namespace open_power
270 } // namespace org
271 } // namespace sdbusplus
272 
273 namespace sdbusplus
274 {
275 namespace org
276 {
277 namespace open_power
278 {
279 namespace Witherspoon
280 {
281 namespace Fault
282 {
283 namespace Error
284 {
285 struct ErrorCode16;
286 } // namespace Error
287 } // namespace Fault
288 } // namespace Witherspoon
289 } // namespace open_power
290 } // namespace org
291 } // namespace sdbusplus
292 
293 namespace sdbusplus
294 {
295 namespace org
296 {
297 namespace open_power
298 {
299 namespace Witherspoon
300 {
301 namespace Fault
302 {
303 namespace Error
304 {
305 struct ErrorCode11;
306 } // namespace Error
307 } // namespace Fault
308 } // namespace Witherspoon
309 } // namespace open_power
310 } // namespace org
311 } // namespace sdbusplus
312 
313 namespace sdbusplus
314 {
315 namespace org
316 {
317 namespace open_power
318 {
319 namespace Witherspoon
320 {
321 namespace Fault
322 {
323 namespace Error
324 {
325 struct ErrorCode10;
326 } // namespace Error
327 } // namespace Fault
328 } // namespace Witherspoon
329 } // namespace open_power
330 } // namespace org
331 } // namespace sdbusplus
332 
333 namespace sdbusplus
334 {
335 namespace org
336 {
337 namespace open_power
338 {
339 namespace Witherspoon
340 {
341 namespace Fault
342 {
343 namespace Error
344 {
345 struct ErrorCode13;
346 } // namespace Error
347 } // namespace Fault
348 } // namespace Witherspoon
349 } // namespace open_power
350 } // namespace org
351 } // namespace sdbusplus
352 
353 namespace sdbusplus
354 {
355 namespace org
356 {
357 namespace open_power
358 {
359 namespace Witherspoon
360 {
361 namespace Fault
362 {
363 namespace Error
364 {
365 struct ErrorCode12;
366 } // namespace Error
367 } // namespace Fault
368 } // namespace Witherspoon
369 } // namespace open_power
370 } // namespace org
371 } // namespace sdbusplus
372 
373 namespace sdbusplus
374 {
375 namespace org
376 {
377 namespace open_power
378 {
379 namespace Witherspoon
380 {
381 namespace Fault
382 {
383 namespace Error
384 {
385 struct ErrorCode36;
386 } // namespace Error
387 } // namespace Fault
388 } // namespace Witherspoon
389 } // namespace open_power
390 } // namespace org
391 } // namespace sdbusplus
392 
393 namespace sdbusplus
394 {
395 namespace org
396 {
397 namespace open_power
398 {
399 namespace Witherspoon
400 {
401 namespace Fault
402 {
403 namespace Error
404 {
405 struct ErrorCode35;
406 } // namespace Error
407 } // namespace Fault
408 } // namespace Witherspoon
409 } // namespace open_power
410 } // namespace org
411 } // namespace sdbusplus
412 
413 namespace sdbusplus
414 {
415 namespace org
416 {
417 namespace open_power
418 {
419 namespace Witherspoon
420 {
421 namespace Fault
422 {
423 namespace Error
424 {
425 struct ErrorCode34;
426 } // namespace Error
427 } // namespace Fault
428 } // namespace Witherspoon
429 } // namespace open_power
430 } // namespace org
431 } // namespace sdbusplus
432 
433 namespace sdbusplus
434 {
435 namespace org
436 {
437 namespace open_power
438 {
439 namespace Witherspoon
440 {
441 namespace Fault
442 {
443 namespace Error
444 {
445 struct ErrorCode19;
446 } // namespace Error
447 } // namespace Fault
448 } // namespace Witherspoon
449 } // namespace open_power
450 } // namespace org
451 } // namespace sdbusplus
452 
453 namespace sdbusplus
454 {
455 namespace org
456 {
457 namespace open_power
458 {
459 namespace Witherspoon
460 {
461 namespace Fault
462 {
463 namespace Error
464 {
465 struct ErrorCode18;
466 } // namespace Error
467 } // namespace Fault
468 } // namespace Witherspoon
469 } // namespace open_power
470 } // namespace org
471 } // namespace sdbusplus
472 
473 namespace sdbusplus
474 {
475 namespace org
476 {
477 namespace open_power
478 {
479 namespace Witherspoon
480 {
481 namespace Fault
482 {
483 namespace Error
484 {
485 struct ErrorCode31;
486 } // namespace Error
487 } // namespace Fault
488 } // namespace Witherspoon
489 } // namespace open_power
490 } // namespace org
491 } // namespace sdbusplus
492 
493 namespace sdbusplus
494 {
495 namespace org
496 {
497 namespace open_power
498 {
499 namespace Witherspoon
500 {
501 namespace Fault
502 {
503 namespace Error
504 {
505 struct ErrorCode30;
506 } // namespace Error
507 } // namespace Fault
508 } // namespace Witherspoon
509 } // namespace open_power
510 } // namespace org
511 } // namespace sdbusplus
512 
513 namespace sdbusplus
514 {
515 namespace xyz
516 {
517 namespace openbmc_project
518 {
519 namespace Common
520 {
521 namespace Callout
522 {
523 namespace Error
524 {
525 struct GPIO;
526 } // namespace Error
527 } // namespace Callout
528 } // namespace Common
529 } // namespace openbmc_project
530 } // namespace xyz
531 } // namespace sdbusplus
532 
533 namespace sdbusplus
534 {
535 namespace xyz
536 {
537 namespace openbmc_project
538 {
539 namespace Common
540 {
541 namespace Callout
542 {
543 namespace Error
544 {
545 struct IIC;
546 } // namespace Error
547 } // namespace Callout
548 } // namespace Common
549 } // namespace openbmc_project
550 } // namespace xyz
551 } // namespace sdbusplus
552 
553 namespace sdbusplus
554 {
555 namespace org
556 {
557 namespace open_power
558 {
559 namespace Witherspoon
560 {
561 namespace Fault
562 {
563 namespace Error
564 {
565 struct ErrorCode32;
566 } // namespace Error
567 } // namespace Fault
568 } // namespace Witherspoon
569 } // namespace open_power
570 } // namespace org
571 } // namespace sdbusplus
572 
573 namespace sdbusplus
574 {
575 namespace org
576 {
577 namespace open_power
578 {
579 namespace Witherspoon
580 {
581 namespace Fault
582 {
583 namespace Error
584 {
585 struct PowerSupplyOutputOvercurrent;
586 } // namespace Error
587 } // namespace Fault
588 } // namespace Witherspoon
589 } // namespace open_power
590 } // namespace org
591 } // namespace sdbusplus
592 
593 namespace sdbusplus
594 {
595 namespace org
596 {
597 namespace open_power
598 {
599 namespace Witherspoon
600 {
601 namespace Fault
602 {
603 namespace Error
604 {
605 struct ErrorCode33;
606 } // namespace Error
607 } // namespace Fault
608 } // namespace Witherspoon
609 } // namespace open_power
610 } // namespace org
611 } // namespace sdbusplus
612 
613 namespace sdbusplus
614 {
615 namespace org
616 {
617 namespace open_power
618 {
619 namespace Witherspoon
620 {
621 namespace Fault
622 {
623 namespace Error
624 {
625 struct PowerSupplyTemperatureFault;
626 } // namespace Error
627 } // namespace Fault
628 } // namespace Witherspoon
629 } // namespace open_power
630 } // namespace org
631 } // namespace sdbusplus
632 
633 namespace sdbusplus
634 {
635 namespace org
636 {
637 namespace open_power
638 {
639 namespace Witherspoon
640 {
641 namespace Fault
642 {
643 namespace Error
644 {
645 struct PowerSequencerFault;
646 } // namespace Error
647 } // namespace Fault
648 } // namespace Witherspoon
649 } // namespace open_power
650 } // namespace org
651 } // namespace sdbusplus
652 
653 namespace sdbusplus
654 {
655 namespace org
656 {
657 namespace open_power
658 {
659 namespace Witherspoon
660 {
661 namespace Fault
662 {
663 namespace Error
664 {
665 struct PowerSupplyFanFault;
666 } // namespace Error
667 } // namespace Fault
668 } // namespace Witherspoon
669 } // namespace open_power
670 } // namespace org
671 } // namespace sdbusplus
672 
673 namespace sdbusplus
674 {
675 namespace org
676 {
677 namespace open_power
678 {
679 namespace Witherspoon
680 {
681 namespace Fault
682 {
683 namespace Error
684 {
685 struct PowerSupplyOutputOvervoltage;
686 } // namespace Error
687 } // namespace Fault
688 } // namespace Witherspoon
689 } // namespace open_power
690 } // namespace org
691 } // namespace sdbusplus
692 
693 namespace sdbusplus
694 {
695 namespace org
696 {
697 namespace open_power
698 {
699 namespace Witherspoon
700 {
701 namespace Fault
702 {
703 namespace Error
704 {
705 struct ErrorCode9;
706 } // namespace Error
707 } // namespace Fault
708 } // namespace Witherspoon
709 } // namespace open_power
710 } // namespace org
711 } // namespace sdbusplus
712 
713 namespace sdbusplus
714 {
715 namespace org
716 {
717 namespace open_power
718 {
719 namespace Witherspoon
720 {
721 namespace Fault
722 {
723 namespace Error
724 {
725 struct ErrorCode8;
726 } // namespace Error
727 } // namespace Fault
728 } // namespace Witherspoon
729 } // namespace open_power
730 } // namespace org
731 } // namespace sdbusplus
732 
733 namespace sdbusplus
734 {
735 namespace xyz
736 {
737 namespace openbmc_project
738 {
739 namespace Common
740 {
741 namespace Callout
742 {
743 namespace Error
744 {
745 struct Inventory;
746 } // namespace Error
747 } // namespace Callout
748 } // namespace Common
749 } // namespace openbmc_project
750 } // namespace xyz
751 } // namespace sdbusplus
752 
753 namespace sdbusplus
754 {
755 namespace org
756 {
757 namespace open_power
758 {
759 namespace Witherspoon
760 {
761 namespace Fault
762 {
763 namespace Error
764 {
765 struct ErrorCode5;
766 } // namespace Error
767 } // namespace Fault
768 } // namespace Witherspoon
769 } // namespace open_power
770 } // namespace org
771 } // namespace sdbusplus
772 
773 namespace sdbusplus
774 {
775 namespace org
776 {
777 namespace open_power
778 {
779 namespace Witherspoon
780 {
781 namespace Fault
782 {
783 namespace Error
784 {
785 struct ErrorCode4;
786 } // namespace Error
787 } // namespace Fault
788 } // namespace Witherspoon
789 } // namespace open_power
790 } // namespace org
791 } // namespace sdbusplus
792 
793 namespace sdbusplus
794 {
795 namespace org
796 {
797 namespace open_power
798 {
799 namespace Witherspoon
800 {
801 namespace Fault
802 {
803 namespace Error
804 {
805 struct ErrorCode7;
806 } // namespace Error
807 } // namespace Fault
808 } // namespace Witherspoon
809 } // namespace open_power
810 } // namespace org
811 } // namespace sdbusplus
812 
813 namespace sdbusplus
814 {
815 namespace org
816 {
817 namespace open_power
818 {
819 namespace Witherspoon
820 {
821 namespace Fault
822 {
823 namespace Error
824 {
825 struct ErrorCode6;
826 } // namespace Error
827 } // namespace Fault
828 } // namespace Witherspoon
829 } // namespace open_power
830 } // namespace org
831 } // namespace sdbusplus
832 
833 namespace sdbusplus
834 {
835 namespace org
836 {
837 namespace open_power
838 {
839 namespace Witherspoon
840 {
841 namespace Fault
842 {
843 namespace Error
844 {
845 struct ErrorCode1;
846 } // namespace Error
847 } // namespace Fault
848 } // namespace Witherspoon
849 } // namespace open_power
850 } // namespace org
851 } // namespace sdbusplus
852 
853 namespace sdbusplus
854 {
855 namespace org
856 {
857 namespace open_power
858 {
859 namespace Witherspoon
860 {
861 namespace Fault
862 {
863 namespace Error
864 {
865 struct ErrorCode0;
866 } // namespace Error
867 } // namespace Fault
868 } // namespace Witherspoon
869 } // namespace open_power
870 } // namespace org
871 } // namespace sdbusplus
872 
873 namespace sdbusplus
874 {
875 namespace org
876 {
877 namespace open_power
878 {
879 namespace Witherspoon
880 {
881 namespace Fault
882 {
883 namespace Error
884 {
885 struct ErrorCode3;
886 } // namespace Error
887 } // namespace Fault
888 } // namespace Witherspoon
889 } // namespace open_power
890 } // namespace org
891 } // namespace sdbusplus
892 
893 namespace sdbusplus
894 {
895 namespace org
896 {
897 namespace open_power
898 {
899 namespace Witherspoon
900 {
901 namespace Fault
902 {
903 namespace Error
904 {
905 struct ErrorCode2;
906 } // namespace Error
907 } // namespace Fault
908 } // namespace Witherspoon
909 } // namespace open_power
910 } // namespace org
911 } // namespace sdbusplus
912 
913 namespace sdbusplus
914 {
915 namespace org
916 {
917 namespace open_power
918 {
919 namespace Witherspoon
920 {
921 namespace Fault
922 {
923 namespace Error
924 {
925 struct ErrorCode28;
926 } // namespace Error
927 } // namespace Fault
928 } // namespace Witherspoon
929 } // namespace open_power
930 } // namespace org
931 } // namespace sdbusplus
932 
933 namespace sdbusplus
934 {
935 namespace org
936 {
937 namespace open_power
938 {
939 namespace Witherspoon
940 {
941 namespace Fault
942 {
943 namespace Error
944 {
945 struct ErrorCode29;
946 } // namespace Error
947 } // namespace Fault
948 } // namespace Witherspoon
949 } // namespace open_power
950 } // namespace org
951 } // namespace sdbusplus
952 
953 namespace sdbusplus
954 {
955 namespace org
956 {
957 namespace open_power
958 {
959 namespace Witherspoon
960 {
961 namespace Fault
962 {
963 namespace Error
964 {
965 struct PowerSupplyShouldBeOn;
966 } // namespace Error
967 } // namespace Fault
968 } // namespace Witherspoon
969 } // namespace open_power
970 } // namespace org
971 } // namespace sdbusplus
972 
973 namespace sdbusplus
974 {
975 namespace org
976 {
977 namespace open_power
978 {
979 namespace Witherspoon
980 {
981 namespace Fault
982 {
983 namespace Error
984 {
985 struct ErrorCode20;
986 } // namespace Error
987 } // namespace Fault
988 } // namespace Witherspoon
989 } // namespace open_power
990 } // namespace org
991 } // namespace sdbusplus
992 
993 namespace sdbusplus
994 {
995 namespace org
996 {
997 namespace open_power
998 {
999 namespace Witherspoon
1000 {
1001 namespace Fault
1002 {
1003 namespace Error
1004 {
1005 struct ErrorCode21;
1006 } // namespace Error
1007 } // namespace Fault
1008 } // namespace Witherspoon
1009 } // namespace open_power
1010 } // namespace org
1011 } // namespace sdbusplus
1012 
1013 namespace sdbusplus
1014 {
1015 namespace org
1016 {
1017 namespace open_power
1018 {
1019 namespace Witherspoon
1020 {
1021 namespace Fault
1022 {
1023 namespace Error
1024 {
1025 struct ErrorCode22;
1026 } // namespace Error
1027 } // namespace Fault
1028 } // namespace Witherspoon
1029 } // namespace open_power
1030 } // namespace org
1031 } // namespace sdbusplus
1032 
1033 namespace sdbusplus
1034 {
1035 namespace org
1036 {
1037 namespace open_power
1038 {
1039 namespace Witherspoon
1040 {
1041 namespace Fault
1042 {
1043 namespace Error
1044 {
1045 struct ErrorCode23;
1046 } // namespace Error
1047 } // namespace Fault
1048 } // namespace Witherspoon
1049 } // namespace open_power
1050 } // namespace org
1051 } // namespace sdbusplus
1052 
1053 namespace sdbusplus
1054 {
1055 namespace org
1056 {
1057 namespace open_power
1058 {
1059 namespace Witherspoon
1060 {
1061 namespace Fault
1062 {
1063 namespace Error
1064 {
1065 struct ErrorCode24;
1066 } // namespace Error
1067 } // namespace Fault
1068 } // namespace Witherspoon
1069 } // namespace open_power
1070 } // namespace org
1071 } // namespace sdbusplus
1072 
1073 namespace sdbusplus
1074 {
1075 namespace org
1076 {
1077 namespace open_power
1078 {
1079 namespace Witherspoon
1080 {
1081 namespace Fault
1082 {
1083 namespace Error
1084 {
1085 struct ErrorCode25;
1086 } // namespace Error
1087 } // namespace Fault
1088 } // namespace Witherspoon
1089 } // namespace open_power
1090 } // namespace org
1091 } // namespace sdbusplus
1092 
1093 namespace sdbusplus
1094 {
1095 namespace org
1096 {
1097 namespace open_power
1098 {
1099 namespace Witherspoon
1100 {
1101 namespace Fault
1102 {
1103 namespace Error
1104 {
1105 struct ErrorCode26;
1106 } // namespace Error
1107 } // namespace Fault
1108 } // namespace Witherspoon
1109 } // namespace open_power
1110 } // namespace org
1111 } // namespace sdbusplus
1112 
1113 namespace sdbusplus
1114 {
1115 namespace org
1116 {
1117 namespace open_power
1118 {
1119 namespace Witherspoon
1120 {
1121 namespace Fault
1122 {
1123 namespace Error
1124 {
1125 struct ErrorCode27;
1126 } // namespace Error
1127 } // namespace Fault
1128 } // namespace Witherspoon
1129 } // namespace open_power
1130 } // namespace org
1131 } // namespace sdbusplus
1132 
1133 namespace phosphor
1134 {
1135 
1136 namespace logging
1137 {
1138 
1139 namespace org
1140 {
1141 namespace open_power
1142 {
1143 namespace Witherspoon
1144 {
1145 namespace Fault
1146 {
1147 namespace _Shutdown
1148 {} // namespace _Shutdown
1149 
1150 struct Shutdown
1151 {
1152     static constexpr auto L = level::ERR;
1153     using metadata_types = std::tuple<>;
1154 };
1155 
1156 } // namespace Fault
1157 } // namespace Witherspoon
1158 } // namespace open_power
1159 } // namespace org
1160 
1161 namespace details
1162 {
1163 
1164 template <>
1165 struct map_exception_type<
1166     sdbusplus::org::open_power::Witherspoon::Fault::Error::Shutdown>
1167 {
1168     using type = org::open_power::Witherspoon::Fault::Shutdown;
1169 };
1170 
1171 } // namespace details
1172 
1173 namespace org
1174 {
1175 namespace open_power
1176 {
1177 namespace Witherspoon
1178 {
1179 namespace Fault
1180 {
1181 namespace _PowerOnFailure
1182 {} // namespace _PowerOnFailure
1183 
1184 struct PowerOnFailure
1185 {
1186     static constexpr auto L = level::ERR;
1187     using metadata_types = std::tuple<>;
1188 };
1189 
1190 } // namespace Fault
1191 } // namespace Witherspoon
1192 } // namespace open_power
1193 } // namespace org
1194 
1195 namespace details
1196 {
1197 
1198 template <>
1199 struct map_exception_type<
1200     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerOnFailure>
1201 {
1202     using type = org::open_power::Witherspoon::Fault::PowerOnFailure;
1203 };
1204 
1205 } // namespace details
1206 
1207 namespace org
1208 {
1209 namespace open_power
1210 {
1211 namespace Witherspoon
1212 {
1213 namespace Fault
1214 {
1215 namespace _ErrorCode0
1216 {} // namespace _ErrorCode0
1217 
1218 struct ErrorCode0
1219 {
1220     static constexpr auto L = level::ERR;
1221     using metadata_types = std::tuple<>;
1222 };
1223 
1224 } // namespace Fault
1225 } // namespace Witherspoon
1226 } // namespace open_power
1227 } // namespace org
1228 
1229 namespace details
1230 {
1231 
1232 template <>
1233 struct map_exception_type<
1234     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode0>
1235 {
1236     using type = org::open_power::Witherspoon::Fault::ErrorCode0;
1237 };
1238 
1239 } // namespace details
1240 
1241 namespace org
1242 {
1243 namespace open_power
1244 {
1245 namespace Witherspoon
1246 {
1247 namespace Fault
1248 {
1249 namespace _ErrorCode1
1250 {} // namespace _ErrorCode1
1251 
1252 struct ErrorCode1
1253 {
1254     static constexpr auto L = level::ERR;
1255     using metadata_types = std::tuple<>;
1256 };
1257 
1258 } // namespace Fault
1259 } // namespace Witherspoon
1260 } // namespace open_power
1261 } // namespace org
1262 
1263 namespace details
1264 {
1265 
1266 template <>
1267 struct map_exception_type<
1268     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode1>
1269 {
1270     using type = org::open_power::Witherspoon::Fault::ErrorCode1;
1271 };
1272 
1273 } // namespace details
1274 
1275 namespace org
1276 {
1277 namespace open_power
1278 {
1279 namespace Witherspoon
1280 {
1281 namespace Fault
1282 {
1283 namespace _ErrorCode2
1284 {} // namespace _ErrorCode2
1285 
1286 struct ErrorCode2
1287 {
1288     static constexpr auto L = level::ERR;
1289     using metadata_types = std::tuple<>;
1290 };
1291 
1292 } // namespace Fault
1293 } // namespace Witherspoon
1294 } // namespace open_power
1295 } // namespace org
1296 
1297 namespace details
1298 {
1299 
1300 template <>
1301 struct map_exception_type<
1302     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode2>
1303 {
1304     using type = org::open_power::Witherspoon::Fault::ErrorCode2;
1305 };
1306 
1307 } // namespace details
1308 
1309 namespace org
1310 {
1311 namespace open_power
1312 {
1313 namespace Witherspoon
1314 {
1315 namespace Fault
1316 {
1317 namespace _ErrorCode3
1318 {} // namespace _ErrorCode3
1319 
1320 struct ErrorCode3
1321 {
1322     static constexpr auto L = level::ERR;
1323     using metadata_types = std::tuple<>;
1324 };
1325 
1326 } // namespace Fault
1327 } // namespace Witherspoon
1328 } // namespace open_power
1329 } // namespace org
1330 
1331 namespace details
1332 {
1333 
1334 template <>
1335 struct map_exception_type<
1336     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode3>
1337 {
1338     using type = org::open_power::Witherspoon::Fault::ErrorCode3;
1339 };
1340 
1341 } // namespace details
1342 
1343 namespace org
1344 {
1345 namespace open_power
1346 {
1347 namespace Witherspoon
1348 {
1349 namespace Fault
1350 {
1351 namespace _ErrorCode4
1352 {} // namespace _ErrorCode4
1353 
1354 struct ErrorCode4
1355 {
1356     static constexpr auto L = level::ERR;
1357     using metadata_types = std::tuple<>;
1358 };
1359 
1360 } // namespace Fault
1361 } // namespace Witherspoon
1362 } // namespace open_power
1363 } // namespace org
1364 
1365 namespace details
1366 {
1367 
1368 template <>
1369 struct map_exception_type<
1370     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode4>
1371 {
1372     using type = org::open_power::Witherspoon::Fault::ErrorCode4;
1373 };
1374 
1375 } // namespace details
1376 
1377 namespace org
1378 {
1379 namespace open_power
1380 {
1381 namespace Witherspoon
1382 {
1383 namespace Fault
1384 {
1385 namespace _ErrorCode5
1386 {} // namespace _ErrorCode5
1387 
1388 struct ErrorCode5
1389 {
1390     static constexpr auto L = level::ERR;
1391     using metadata_types = std::tuple<>;
1392 };
1393 
1394 } // namespace Fault
1395 } // namespace Witherspoon
1396 } // namespace open_power
1397 } // namespace org
1398 
1399 namespace details
1400 {
1401 
1402 template <>
1403 struct map_exception_type<
1404     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode5>
1405 {
1406     using type = org::open_power::Witherspoon::Fault::ErrorCode5;
1407 };
1408 
1409 } // namespace details
1410 
1411 namespace org
1412 {
1413 namespace open_power
1414 {
1415 namespace Witherspoon
1416 {
1417 namespace Fault
1418 {
1419 namespace _ErrorCode6
1420 {} // namespace _ErrorCode6
1421 
1422 struct ErrorCode6
1423 {
1424     static constexpr auto L = level::ERR;
1425     using metadata_types = std::tuple<>;
1426 };
1427 
1428 } // namespace Fault
1429 } // namespace Witherspoon
1430 } // namespace open_power
1431 } // namespace org
1432 
1433 namespace details
1434 {
1435 
1436 template <>
1437 struct map_exception_type<
1438     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode6>
1439 {
1440     using type = org::open_power::Witherspoon::Fault::ErrorCode6;
1441 };
1442 
1443 } // namespace details
1444 
1445 namespace org
1446 {
1447 namespace open_power
1448 {
1449 namespace Witherspoon
1450 {
1451 namespace Fault
1452 {
1453 namespace _ErrorCode7
1454 {} // namespace _ErrorCode7
1455 
1456 struct ErrorCode7
1457 {
1458     static constexpr auto L = level::ERR;
1459     using metadata_types = std::tuple<>;
1460 };
1461 
1462 } // namespace Fault
1463 } // namespace Witherspoon
1464 } // namespace open_power
1465 } // namespace org
1466 
1467 namespace details
1468 {
1469 
1470 template <>
1471 struct map_exception_type<
1472     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode7>
1473 {
1474     using type = org::open_power::Witherspoon::Fault::ErrorCode7;
1475 };
1476 
1477 } // namespace details
1478 
1479 namespace org
1480 {
1481 namespace open_power
1482 {
1483 namespace Witherspoon
1484 {
1485 namespace Fault
1486 {
1487 namespace _ErrorCode8
1488 {} // namespace _ErrorCode8
1489 
1490 struct ErrorCode8
1491 {
1492     static constexpr auto L = level::ERR;
1493     using metadata_types = std::tuple<>;
1494 };
1495 
1496 } // namespace Fault
1497 } // namespace Witherspoon
1498 } // namespace open_power
1499 } // namespace org
1500 
1501 namespace details
1502 {
1503 
1504 template <>
1505 struct map_exception_type<
1506     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode8>
1507 {
1508     using type = org::open_power::Witherspoon::Fault::ErrorCode8;
1509 };
1510 
1511 } // namespace details
1512 
1513 namespace org
1514 {
1515 namespace open_power
1516 {
1517 namespace Witherspoon
1518 {
1519 namespace Fault
1520 {
1521 namespace _ErrorCode9
1522 {} // namespace _ErrorCode9
1523 
1524 struct ErrorCode9
1525 {
1526     static constexpr auto L = level::ERR;
1527     using metadata_types = std::tuple<>;
1528 };
1529 
1530 } // namespace Fault
1531 } // namespace Witherspoon
1532 } // namespace open_power
1533 } // namespace org
1534 
1535 namespace details
1536 {
1537 
1538 template <>
1539 struct map_exception_type<
1540     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode9>
1541 {
1542     using type = org::open_power::Witherspoon::Fault::ErrorCode9;
1543 };
1544 
1545 } // namespace details
1546 
1547 namespace org
1548 {
1549 namespace open_power
1550 {
1551 namespace Witherspoon
1552 {
1553 namespace Fault
1554 {
1555 namespace _ErrorCode10
1556 {} // namespace _ErrorCode10
1557 
1558 struct ErrorCode10
1559 {
1560     static constexpr auto L = level::ERR;
1561     using metadata_types = std::tuple<>;
1562 };
1563 
1564 } // namespace Fault
1565 } // namespace Witherspoon
1566 } // namespace open_power
1567 } // namespace org
1568 
1569 namespace details
1570 {
1571 
1572 template <>
1573 struct map_exception_type<
1574     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode10>
1575 {
1576     using type = org::open_power::Witherspoon::Fault::ErrorCode10;
1577 };
1578 
1579 } // namespace details
1580 
1581 namespace org
1582 {
1583 namespace open_power
1584 {
1585 namespace Witherspoon
1586 {
1587 namespace Fault
1588 {
1589 namespace _ErrorCode11
1590 {} // namespace _ErrorCode11
1591 
1592 struct ErrorCode11
1593 {
1594     static constexpr auto L = level::ERR;
1595     using metadata_types = std::tuple<>;
1596 };
1597 
1598 } // namespace Fault
1599 } // namespace Witherspoon
1600 } // namespace open_power
1601 } // namespace org
1602 
1603 namespace details
1604 {
1605 
1606 template <>
1607 struct map_exception_type<
1608     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode11>
1609 {
1610     using type = org::open_power::Witherspoon::Fault::ErrorCode11;
1611 };
1612 
1613 } // namespace details
1614 
1615 namespace org
1616 {
1617 namespace open_power
1618 {
1619 namespace Witherspoon
1620 {
1621 namespace Fault
1622 {
1623 namespace _ErrorCode12
1624 {} // namespace _ErrorCode12
1625 
1626 struct ErrorCode12
1627 {
1628     static constexpr auto L = level::ERR;
1629     using metadata_types = std::tuple<>;
1630 };
1631 
1632 } // namespace Fault
1633 } // namespace Witherspoon
1634 } // namespace open_power
1635 } // namespace org
1636 
1637 namespace details
1638 {
1639 
1640 template <>
1641 struct map_exception_type<
1642     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode12>
1643 {
1644     using type = org::open_power::Witherspoon::Fault::ErrorCode12;
1645 };
1646 
1647 } // namespace details
1648 
1649 namespace org
1650 {
1651 namespace open_power
1652 {
1653 namespace Witherspoon
1654 {
1655 namespace Fault
1656 {
1657 namespace _ErrorCode13
1658 {} // namespace _ErrorCode13
1659 
1660 struct ErrorCode13
1661 {
1662     static constexpr auto L = level::ERR;
1663     using metadata_types = std::tuple<>;
1664 };
1665 
1666 } // namespace Fault
1667 } // namespace Witherspoon
1668 } // namespace open_power
1669 } // namespace org
1670 
1671 namespace details
1672 {
1673 
1674 template <>
1675 struct map_exception_type<
1676     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode13>
1677 {
1678     using type = org::open_power::Witherspoon::Fault::ErrorCode13;
1679 };
1680 
1681 } // namespace details
1682 
1683 namespace org
1684 {
1685 namespace open_power
1686 {
1687 namespace Witherspoon
1688 {
1689 namespace Fault
1690 {
1691 namespace _ErrorCode14
1692 {} // namespace _ErrorCode14
1693 
1694 struct ErrorCode14
1695 {
1696     static constexpr auto L = level::ERR;
1697     using metadata_types = std::tuple<>;
1698 };
1699 
1700 } // namespace Fault
1701 } // namespace Witherspoon
1702 } // namespace open_power
1703 } // namespace org
1704 
1705 namespace details
1706 {
1707 
1708 template <>
1709 struct map_exception_type<
1710     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode14>
1711 {
1712     using type = org::open_power::Witherspoon::Fault::ErrorCode14;
1713 };
1714 
1715 } // namespace details
1716 
1717 namespace org
1718 {
1719 namespace open_power
1720 {
1721 namespace Witherspoon
1722 {
1723 namespace Fault
1724 {
1725 namespace _ErrorCode15
1726 {} // namespace _ErrorCode15
1727 
1728 struct ErrorCode15
1729 {
1730     static constexpr auto L = level::ERR;
1731     using metadata_types = std::tuple<>;
1732 };
1733 
1734 } // namespace Fault
1735 } // namespace Witherspoon
1736 } // namespace open_power
1737 } // namespace org
1738 
1739 namespace details
1740 {
1741 
1742 template <>
1743 struct map_exception_type<
1744     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode15>
1745 {
1746     using type = org::open_power::Witherspoon::Fault::ErrorCode15;
1747 };
1748 
1749 } // namespace details
1750 
1751 namespace org
1752 {
1753 namespace open_power
1754 {
1755 namespace Witherspoon
1756 {
1757 namespace Fault
1758 {
1759 namespace _ErrorCode16
1760 {} // namespace _ErrorCode16
1761 
1762 struct ErrorCode16
1763 {
1764     static constexpr auto L = level::ERR;
1765     using metadata_types = std::tuple<>;
1766 };
1767 
1768 } // namespace Fault
1769 } // namespace Witherspoon
1770 } // namespace open_power
1771 } // namespace org
1772 
1773 namespace details
1774 {
1775 
1776 template <>
1777 struct map_exception_type<
1778     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode16>
1779 {
1780     using type = org::open_power::Witherspoon::Fault::ErrorCode16;
1781 };
1782 
1783 } // namespace details
1784 
1785 namespace org
1786 {
1787 namespace open_power
1788 {
1789 namespace Witherspoon
1790 {
1791 namespace Fault
1792 {
1793 namespace _ErrorCode17
1794 {} // namespace _ErrorCode17
1795 
1796 struct ErrorCode17
1797 {
1798     static constexpr auto L = level::ERR;
1799     using metadata_types = std::tuple<>;
1800 };
1801 
1802 } // namespace Fault
1803 } // namespace Witherspoon
1804 } // namespace open_power
1805 } // namespace org
1806 
1807 namespace details
1808 {
1809 
1810 template <>
1811 struct map_exception_type<
1812     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode17>
1813 {
1814     using type = org::open_power::Witherspoon::Fault::ErrorCode17;
1815 };
1816 
1817 } // namespace details
1818 
1819 namespace org
1820 {
1821 namespace open_power
1822 {
1823 namespace Witherspoon
1824 {
1825 namespace Fault
1826 {
1827 namespace _ErrorCode18
1828 {} // namespace _ErrorCode18
1829 
1830 struct ErrorCode18
1831 {
1832     static constexpr auto L = level::ERR;
1833     using metadata_types = std::tuple<>;
1834 };
1835 
1836 } // namespace Fault
1837 } // namespace Witherspoon
1838 } // namespace open_power
1839 } // namespace org
1840 
1841 namespace details
1842 {
1843 
1844 template <>
1845 struct map_exception_type<
1846     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode18>
1847 {
1848     using type = org::open_power::Witherspoon::Fault::ErrorCode18;
1849 };
1850 
1851 } // namespace details
1852 
1853 namespace org
1854 {
1855 namespace open_power
1856 {
1857 namespace Witherspoon
1858 {
1859 namespace Fault
1860 {
1861 namespace _ErrorCode19
1862 {} // namespace _ErrorCode19
1863 
1864 struct ErrorCode19
1865 {
1866     static constexpr auto L = level::ERR;
1867     using metadata_types = std::tuple<>;
1868 };
1869 
1870 } // namespace Fault
1871 } // namespace Witherspoon
1872 } // namespace open_power
1873 } // namespace org
1874 
1875 namespace details
1876 {
1877 
1878 template <>
1879 struct map_exception_type<
1880     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode19>
1881 {
1882     using type = org::open_power::Witherspoon::Fault::ErrorCode19;
1883 };
1884 
1885 } // namespace details
1886 
1887 namespace org
1888 {
1889 namespace open_power
1890 {
1891 namespace Witherspoon
1892 {
1893 namespace Fault
1894 {
1895 namespace _ErrorCode20
1896 {} // namespace _ErrorCode20
1897 
1898 struct ErrorCode20
1899 {
1900     static constexpr auto L = level::ERR;
1901     using metadata_types = std::tuple<>;
1902 };
1903 
1904 } // namespace Fault
1905 } // namespace Witherspoon
1906 } // namespace open_power
1907 } // namespace org
1908 
1909 namespace details
1910 {
1911 
1912 template <>
1913 struct map_exception_type<
1914     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode20>
1915 {
1916     using type = org::open_power::Witherspoon::Fault::ErrorCode20;
1917 };
1918 
1919 } // namespace details
1920 
1921 namespace org
1922 {
1923 namespace open_power
1924 {
1925 namespace Witherspoon
1926 {
1927 namespace Fault
1928 {
1929 namespace _ErrorCode21
1930 {} // namespace _ErrorCode21
1931 
1932 struct ErrorCode21
1933 {
1934     static constexpr auto L = level::ERR;
1935     using metadata_types = std::tuple<>;
1936 };
1937 
1938 } // namespace Fault
1939 } // namespace Witherspoon
1940 } // namespace open_power
1941 } // namespace org
1942 
1943 namespace details
1944 {
1945 
1946 template <>
1947 struct map_exception_type<
1948     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode21>
1949 {
1950     using type = org::open_power::Witherspoon::Fault::ErrorCode21;
1951 };
1952 
1953 } // namespace details
1954 
1955 namespace org
1956 {
1957 namespace open_power
1958 {
1959 namespace Witherspoon
1960 {
1961 namespace Fault
1962 {
1963 namespace _ErrorCode22
1964 {} // namespace _ErrorCode22
1965 
1966 struct ErrorCode22
1967 {
1968     static constexpr auto L = level::ERR;
1969     using metadata_types = std::tuple<>;
1970 };
1971 
1972 } // namespace Fault
1973 } // namespace Witherspoon
1974 } // namespace open_power
1975 } // namespace org
1976 
1977 namespace details
1978 {
1979 
1980 template <>
1981 struct map_exception_type<
1982     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode22>
1983 {
1984     using type = org::open_power::Witherspoon::Fault::ErrorCode22;
1985 };
1986 
1987 } // namespace details
1988 
1989 namespace org
1990 {
1991 namespace open_power
1992 {
1993 namespace Witherspoon
1994 {
1995 namespace Fault
1996 {
1997 namespace _ErrorCode23
1998 {} // namespace _ErrorCode23
1999 
2000 struct ErrorCode23
2001 {
2002     static constexpr auto L = level::ERR;
2003     using metadata_types = std::tuple<>;
2004 };
2005 
2006 } // namespace Fault
2007 } // namespace Witherspoon
2008 } // namespace open_power
2009 } // namespace org
2010 
2011 namespace details
2012 {
2013 
2014 template <>
2015 struct map_exception_type<
2016     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode23>
2017 {
2018     using type = org::open_power::Witherspoon::Fault::ErrorCode23;
2019 };
2020 
2021 } // namespace details
2022 
2023 namespace org
2024 {
2025 namespace open_power
2026 {
2027 namespace Witherspoon
2028 {
2029 namespace Fault
2030 {
2031 namespace _ErrorCode24
2032 {} // namespace _ErrorCode24
2033 
2034 struct ErrorCode24
2035 {
2036     static constexpr auto L = level::ERR;
2037     using metadata_types = std::tuple<>;
2038 };
2039 
2040 } // namespace Fault
2041 } // namespace Witherspoon
2042 } // namespace open_power
2043 } // namespace org
2044 
2045 namespace details
2046 {
2047 
2048 template <>
2049 struct map_exception_type<
2050     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode24>
2051 {
2052     using type = org::open_power::Witherspoon::Fault::ErrorCode24;
2053 };
2054 
2055 } // namespace details
2056 
2057 namespace org
2058 {
2059 namespace open_power
2060 {
2061 namespace Witherspoon
2062 {
2063 namespace Fault
2064 {
2065 namespace _ErrorCode25
2066 {} // namespace _ErrorCode25
2067 
2068 struct ErrorCode25
2069 {
2070     static constexpr auto L = level::ERR;
2071     using metadata_types = std::tuple<>;
2072 };
2073 
2074 } // namespace Fault
2075 } // namespace Witherspoon
2076 } // namespace open_power
2077 } // namespace org
2078 
2079 namespace details
2080 {
2081 
2082 template <>
2083 struct map_exception_type<
2084     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode25>
2085 {
2086     using type = org::open_power::Witherspoon::Fault::ErrorCode25;
2087 };
2088 
2089 } // namespace details
2090 
2091 namespace org
2092 {
2093 namespace open_power
2094 {
2095 namespace Witherspoon
2096 {
2097 namespace Fault
2098 {
2099 namespace _ErrorCode26
2100 {} // namespace _ErrorCode26
2101 
2102 struct ErrorCode26
2103 {
2104     static constexpr auto L = level::ERR;
2105     using metadata_types = std::tuple<>;
2106 };
2107 
2108 } // namespace Fault
2109 } // namespace Witherspoon
2110 } // namespace open_power
2111 } // namespace org
2112 
2113 namespace details
2114 {
2115 
2116 template <>
2117 struct map_exception_type<
2118     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode26>
2119 {
2120     using type = org::open_power::Witherspoon::Fault::ErrorCode26;
2121 };
2122 
2123 } // namespace details
2124 
2125 namespace org
2126 {
2127 namespace open_power
2128 {
2129 namespace Witherspoon
2130 {
2131 namespace Fault
2132 {
2133 namespace _ErrorCode27
2134 {} // namespace _ErrorCode27
2135 
2136 struct ErrorCode27
2137 {
2138     static constexpr auto L = level::ERR;
2139     using metadata_types = std::tuple<>;
2140 };
2141 
2142 } // namespace Fault
2143 } // namespace Witherspoon
2144 } // namespace open_power
2145 } // namespace org
2146 
2147 namespace details
2148 {
2149 
2150 template <>
2151 struct map_exception_type<
2152     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode27>
2153 {
2154     using type = org::open_power::Witherspoon::Fault::ErrorCode27;
2155 };
2156 
2157 } // namespace details
2158 
2159 namespace org
2160 {
2161 namespace open_power
2162 {
2163 namespace Witherspoon
2164 {
2165 namespace Fault
2166 {
2167 namespace _ErrorCode28
2168 {} // namespace _ErrorCode28
2169 
2170 struct ErrorCode28
2171 {
2172     static constexpr auto L = level::ERR;
2173     using metadata_types = std::tuple<>;
2174 };
2175 
2176 } // namespace Fault
2177 } // namespace Witherspoon
2178 } // namespace open_power
2179 } // namespace org
2180 
2181 namespace details
2182 {
2183 
2184 template <>
2185 struct map_exception_type<
2186     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode28>
2187 {
2188     using type = org::open_power::Witherspoon::Fault::ErrorCode28;
2189 };
2190 
2191 } // namespace details
2192 
2193 namespace org
2194 {
2195 namespace open_power
2196 {
2197 namespace Witherspoon
2198 {
2199 namespace Fault
2200 {
2201 namespace _ErrorCode29
2202 {} // namespace _ErrorCode29
2203 
2204 struct ErrorCode29
2205 {
2206     static constexpr auto L = level::ERR;
2207     using metadata_types = std::tuple<>;
2208 };
2209 
2210 } // namespace Fault
2211 } // namespace Witherspoon
2212 } // namespace open_power
2213 } // namespace org
2214 
2215 namespace details
2216 {
2217 
2218 template <>
2219 struct map_exception_type<
2220     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode29>
2221 {
2222     using type = org::open_power::Witherspoon::Fault::ErrorCode29;
2223 };
2224 
2225 } // namespace details
2226 
2227 namespace org
2228 {
2229 namespace open_power
2230 {
2231 namespace Witherspoon
2232 {
2233 namespace Fault
2234 {
2235 namespace _ErrorCode30
2236 {} // namespace _ErrorCode30
2237 
2238 struct ErrorCode30
2239 {
2240     static constexpr auto L = level::ERR;
2241     using metadata_types = std::tuple<>;
2242 };
2243 
2244 } // namespace Fault
2245 } // namespace Witherspoon
2246 } // namespace open_power
2247 } // namespace org
2248 
2249 namespace details
2250 {
2251 
2252 template <>
2253 struct map_exception_type<
2254     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode30>
2255 {
2256     using type = org::open_power::Witherspoon::Fault::ErrorCode30;
2257 };
2258 
2259 } // namespace details
2260 
2261 namespace org
2262 {
2263 namespace open_power
2264 {
2265 namespace Witherspoon
2266 {
2267 namespace Fault
2268 {
2269 namespace _ErrorCode31
2270 {} // namespace _ErrorCode31
2271 
2272 struct ErrorCode31
2273 {
2274     static constexpr auto L = level::ERR;
2275     using metadata_types = std::tuple<>;
2276 };
2277 
2278 } // namespace Fault
2279 } // namespace Witherspoon
2280 } // namespace open_power
2281 } // namespace org
2282 
2283 namespace details
2284 {
2285 
2286 template <>
2287 struct map_exception_type<
2288     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode31>
2289 {
2290     using type = org::open_power::Witherspoon::Fault::ErrorCode31;
2291 };
2292 
2293 } // namespace details
2294 
2295 namespace org
2296 {
2297 namespace open_power
2298 {
2299 namespace Witherspoon
2300 {
2301 namespace Fault
2302 {
2303 namespace _ErrorCode32
2304 {} // namespace _ErrorCode32
2305 
2306 struct ErrorCode32
2307 {
2308     static constexpr auto L = level::ERR;
2309     using metadata_types = std::tuple<>;
2310 };
2311 
2312 } // namespace Fault
2313 } // namespace Witherspoon
2314 } // namespace open_power
2315 } // namespace org
2316 
2317 namespace details
2318 {
2319 
2320 template <>
2321 struct map_exception_type<
2322     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode32>
2323 {
2324     using type = org::open_power::Witherspoon::Fault::ErrorCode32;
2325 };
2326 
2327 } // namespace details
2328 
2329 namespace org
2330 {
2331 namespace open_power
2332 {
2333 namespace Witherspoon
2334 {
2335 namespace Fault
2336 {
2337 namespace _ErrorCode33
2338 {} // namespace _ErrorCode33
2339 
2340 struct ErrorCode33
2341 {
2342     static constexpr auto L = level::ERR;
2343     using metadata_types = std::tuple<>;
2344 };
2345 
2346 } // namespace Fault
2347 } // namespace Witherspoon
2348 } // namespace open_power
2349 } // namespace org
2350 
2351 namespace details
2352 {
2353 
2354 template <>
2355 struct map_exception_type<
2356     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode33>
2357 {
2358     using type = org::open_power::Witherspoon::Fault::ErrorCode33;
2359 };
2360 
2361 } // namespace details
2362 
2363 namespace org
2364 {
2365 namespace open_power
2366 {
2367 namespace Witherspoon
2368 {
2369 namespace Fault
2370 {
2371 namespace _ErrorCode34
2372 {} // namespace _ErrorCode34
2373 
2374 struct ErrorCode34
2375 {
2376     static constexpr auto L = level::ERR;
2377     using metadata_types = std::tuple<>;
2378 };
2379 
2380 } // namespace Fault
2381 } // namespace Witherspoon
2382 } // namespace open_power
2383 } // namespace org
2384 
2385 namespace details
2386 {
2387 
2388 template <>
2389 struct map_exception_type<
2390     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode34>
2391 {
2392     using type = org::open_power::Witherspoon::Fault::ErrorCode34;
2393 };
2394 
2395 } // namespace details
2396 
2397 namespace org
2398 {
2399 namespace open_power
2400 {
2401 namespace Witherspoon
2402 {
2403 namespace Fault
2404 {
2405 namespace _ErrorCode35
2406 {} // namespace _ErrorCode35
2407 
2408 struct ErrorCode35
2409 {
2410     static constexpr auto L = level::ERR;
2411     using metadata_types = std::tuple<>;
2412 };
2413 
2414 } // namespace Fault
2415 } // namespace Witherspoon
2416 } // namespace open_power
2417 } // namespace org
2418 
2419 namespace details
2420 {
2421 
2422 template <>
2423 struct map_exception_type<
2424     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode35>
2425 {
2426     using type = org::open_power::Witherspoon::Fault::ErrorCode35;
2427 };
2428 
2429 } // namespace details
2430 
2431 namespace org
2432 {
2433 namespace open_power
2434 {
2435 namespace Witherspoon
2436 {
2437 namespace Fault
2438 {
2439 namespace _ErrorCode36
2440 {} // namespace _ErrorCode36
2441 
2442 struct ErrorCode36
2443 {
2444     static constexpr auto L = level::ERR;
2445     using metadata_types = std::tuple<>;
2446 };
2447 
2448 } // namespace Fault
2449 } // namespace Witherspoon
2450 } // namespace open_power
2451 } // namespace org
2452 
2453 namespace details
2454 {
2455 
2456 template <>
2457 struct map_exception_type<
2458     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode36>
2459 {
2460     using type = org::open_power::Witherspoon::Fault::ErrorCode36;
2461 };
2462 
2463 } // namespace details
2464 
2465 namespace org
2466 {
2467 namespace open_power
2468 {
2469 namespace Witherspoon
2470 {
2471 namespace Fault
2472 {
2473 namespace _PowerSequencerVoltageFault
2474 {
2475 
2476 struct RAIL
2477 {
2478     /*
2479      * We can't use -fsanitize=undefined if we declare a
2480      * 'static constexpr auto str' member, so don't. Instead, open-code the
2481      * mako template lookups.
2482      */
2483     static constexpr auto str_short = "RAIL";
2484     using type = std::tuple<std::decay_t<decltype("RAIL=%d")>, uint16_t>;
2485     explicit constexpr RAIL(uint16_t a) : _entry(entry("RAIL=%d", a)){};
2486     type _entry;
2487 };
2488 struct RAIL_NAME
2489 {
2490     /*
2491      * We can't use -fsanitize=undefined if we declare a
2492      * 'static constexpr auto str' member, so don't. Instead, open-code the
2493      * mako template lookups.
2494      */
2495     static constexpr auto str_short = "RAIL_NAME";
2496     using type =
2497         std::tuple<std::decay_t<decltype("RAIL_NAME=%s")>, const char*>;
2498     explicit constexpr RAIL_NAME(const char* a) :
2499         _entry(entry("RAIL_NAME=%s", a)){};
2500     type _entry;
2501 };
2502 struct RAW_STATUS
2503 {
2504     /*
2505      * We can't use -fsanitize=undefined if we declare a
2506      * 'static constexpr auto str' member, so don't. Instead, open-code the
2507      * mako template lookups.
2508      */
2509     static constexpr auto str_short = "RAW_STATUS";
2510     using type =
2511         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
2512     explicit constexpr RAW_STATUS(const char* a) :
2513         _entry(entry("RAW_STATUS=%s", a)){};
2514     type _entry;
2515 };
2516 
2517 } // namespace _PowerSequencerVoltageFault
2518 
2519 struct PowerSequencerVoltageFault
2520 {
2521     static constexpr auto L = level::ERR;
2522     using RAIL = _PowerSequencerVoltageFault::RAIL;
2523     using RAIL_NAME = _PowerSequencerVoltageFault::RAIL_NAME;
2524     using RAW_STATUS = _PowerSequencerVoltageFault::RAW_STATUS;
2525     using metadata_types = std::tuple<RAIL, RAIL_NAME, RAW_STATUS>;
2526 };
2527 
2528 } // namespace Fault
2529 } // namespace Witherspoon
2530 } // namespace open_power
2531 } // namespace org
2532 
2533 namespace details
2534 {
2535 
2536 template <>
2537 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
2538                               Error::PowerSequencerVoltageFault>
2539 {
2540     using type =
2541         org::open_power::Witherspoon::Fault::PowerSequencerVoltageFault;
2542 };
2543 
2544 } // namespace details
2545 
2546 namespace org
2547 {
2548 namespace open_power
2549 {
2550 namespace Witherspoon
2551 {
2552 namespace Fault
2553 {
2554 namespace _PowerSequencerPGOODFault
2555 {
2556 
2557 struct INPUT_NUM
2558 {
2559     /*
2560      * We can't use -fsanitize=undefined if we declare a
2561      * 'static constexpr auto str' member, so don't. Instead, open-code the
2562      * mako template lookups.
2563      */
2564     static constexpr auto str_short = "INPUT_NUM";
2565     using type = std::tuple<std::decay_t<decltype("INPUT_NUM=%d")>, uint16_t>;
2566     explicit constexpr INPUT_NUM(uint16_t a) :
2567         _entry(entry("INPUT_NUM=%d", a)){};
2568     type _entry;
2569 };
2570 struct INPUT_NAME
2571 {
2572     /*
2573      * We can't use -fsanitize=undefined if we declare a
2574      * 'static constexpr auto str' member, so don't. Instead, open-code the
2575      * mako template lookups.
2576      */
2577     static constexpr auto str_short = "INPUT_NAME";
2578     using type =
2579         std::tuple<std::decay_t<decltype("INPUT_NAME=%s")>, const char*>;
2580     explicit constexpr INPUT_NAME(const char* a) :
2581         _entry(entry("INPUT_NAME=%s", a)){};
2582     type _entry;
2583 };
2584 struct RAW_STATUS
2585 {
2586     /*
2587      * We can't use -fsanitize=undefined if we declare a
2588      * 'static constexpr auto str' member, so don't. Instead, open-code the
2589      * mako template lookups.
2590      */
2591     static constexpr auto str_short = "RAW_STATUS";
2592     using type =
2593         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
2594     explicit constexpr RAW_STATUS(const char* a) :
2595         _entry(entry("RAW_STATUS=%s", a)){};
2596     type _entry;
2597 };
2598 
2599 } // namespace _PowerSequencerPGOODFault
2600 
2601 struct PowerSequencerPGOODFault
2602 {
2603     static constexpr auto L = level::ERR;
2604     using INPUT_NUM = _PowerSequencerPGOODFault::INPUT_NUM;
2605     using INPUT_NAME = _PowerSequencerPGOODFault::INPUT_NAME;
2606     using RAW_STATUS = _PowerSequencerPGOODFault::RAW_STATUS;
2607     using metadata_types = std::tuple<INPUT_NUM, INPUT_NAME, RAW_STATUS>;
2608 };
2609 
2610 } // namespace Fault
2611 } // namespace Witherspoon
2612 } // namespace open_power
2613 } // namespace org
2614 
2615 namespace details
2616 {
2617 
2618 template <>
2619 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
2620                               Error::PowerSequencerPGOODFault>
2621 {
2622     using type = org::open_power::Witherspoon::Fault::PowerSequencerPGOODFault;
2623 };
2624 
2625 } // namespace details
2626 
2627 namespace org
2628 {
2629 namespace open_power
2630 {
2631 namespace Witherspoon
2632 {
2633 namespace Fault
2634 {
2635 namespace _PowerSequencerFault
2636 {
2637 
2638 struct RAW_STATUS
2639 {
2640     /*
2641      * We can't use -fsanitize=undefined if we declare a
2642      * 'static constexpr auto str' member, so don't. Instead, open-code the
2643      * mako template lookups.
2644      */
2645     static constexpr auto str_short = "RAW_STATUS";
2646     using type =
2647         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
2648     explicit constexpr RAW_STATUS(const char* a) :
2649         _entry(entry("RAW_STATUS=%s", a)){};
2650     type _entry;
2651 };
2652 
2653 } // namespace _PowerSequencerFault
2654 
2655 struct PowerSequencerFault
2656 {
2657     static constexpr auto L = level::ERR;
2658     using RAW_STATUS = _PowerSequencerFault::RAW_STATUS;
2659     using metadata_types = std::tuple<RAW_STATUS>;
2660 };
2661 
2662 } // namespace Fault
2663 } // namespace Witherspoon
2664 } // namespace open_power
2665 } // namespace org
2666 
2667 namespace details
2668 {
2669 
2670 template <>
2671 struct map_exception_type<
2672     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSequencerFault>
2673 {
2674     using type = org::open_power::Witherspoon::Fault::PowerSequencerFault;
2675 };
2676 
2677 } // namespace details
2678 
2679 namespace xyz
2680 {
2681 namespace openbmc_project
2682 {
2683 namespace Common
2684 {
2685 namespace Callout
2686 {
2687 namespace _Device
2688 {
2689 
2690 struct CALLOUT_ERRNO
2691 {
2692     /*
2693      * We can't use -fsanitize=undefined if we declare a
2694      * 'static constexpr auto str' member, so don't. Instead, open-code the
2695      * mako template lookups.
2696      */
2697     static constexpr auto str_short = "CALLOUT_ERRNO";
2698     using type =
2699         std::tuple<std::decay_t<decltype("CALLOUT_ERRNO=%d")>, int32_t>;
2700     explicit constexpr CALLOUT_ERRNO(int32_t a) :
2701         _entry(entry("CALLOUT_ERRNO=%d", a)){};
2702     type _entry;
2703 };
2704 struct CALLOUT_DEVICE_PATH
2705 {
2706     /*
2707      * We can't use -fsanitize=undefined if we declare a
2708      * 'static constexpr auto str' member, so don't. Instead, open-code the
2709      * mako template lookups.
2710      */
2711     static constexpr auto str_short = "CALLOUT_DEVICE_PATH";
2712     using type = std::tuple<std::decay_t<decltype("CALLOUT_DEVICE_PATH=%s")>,
2713                             const char*>;
2714     explicit constexpr CALLOUT_DEVICE_PATH(const char* a) :
2715         _entry(entry("CALLOUT_DEVICE_PATH=%s", a)){};
2716     type _entry;
2717 };
2718 
2719 } // namespace _Device
2720 
2721 struct Device
2722 {
2723     static constexpr auto L = level::ERR;
2724     using CALLOUT_ERRNO = _Device::CALLOUT_ERRNO;
2725     using CALLOUT_DEVICE_PATH = _Device::CALLOUT_DEVICE_PATH;
2726     using metadata_types = std::tuple<CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
2727 };
2728 
2729 } // namespace Callout
2730 } // namespace Common
2731 } // namespace openbmc_project
2732 } // namespace xyz
2733 
2734 namespace details
2735 {
2736 
2737 template <>
2738 struct map_exception_type<
2739     sdbusplus::xyz::openbmc_project::Common::Callout::Error::Device>
2740 {
2741     using type = xyz::openbmc_project::Common::Callout::Device;
2742 };
2743 
2744 } // namespace details
2745 
2746 namespace xyz
2747 {
2748 namespace openbmc_project
2749 {
2750 namespace Common
2751 {
2752 namespace Callout
2753 {
2754 namespace _GPIO
2755 {
2756 
2757 struct CALLOUT_GPIO_NUM
2758 {
2759     /*
2760      * We can't use -fsanitize=undefined if we declare a
2761      * 'static constexpr auto str' member, so don't. Instead, open-code the
2762      * mako template lookups.
2763      */
2764     static constexpr auto str_short = "CALLOUT_GPIO_NUM";
2765     using type =
2766         std::tuple<std::decay_t<decltype("CALLOUT_GPIO_NUM=%u")>, uint32_t>;
2767     explicit constexpr CALLOUT_GPIO_NUM(uint32_t a) :
2768         _entry(entry("CALLOUT_GPIO_NUM=%u", a)){};
2769     type _entry;
2770 };
2771 
2772 } // namespace _GPIO
2773 
2774 struct GPIO
2775 {
2776     static constexpr auto L = level::ERR;
2777     using CALLOUT_GPIO_NUM = _GPIO::CALLOUT_GPIO_NUM;
2778     using CALLOUT_ERRNO =
2779         xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO;
2780     using CALLOUT_DEVICE_PATH =
2781         xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH;
2782     using metadata_types =
2783         std::tuple<CALLOUT_GPIO_NUM, CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
2784 };
2785 
2786 } // namespace Callout
2787 } // namespace Common
2788 } // namespace openbmc_project
2789 } // namespace xyz
2790 
2791 namespace details
2792 {
2793 
2794 template <>
2795 struct map_exception_type<
2796     sdbusplus::xyz::openbmc_project::Common::Callout::Error::GPIO>
2797 {
2798     using type = xyz::openbmc_project::Common::Callout::GPIO;
2799 };
2800 
2801 } // namespace details
2802 
2803 namespace xyz
2804 {
2805 namespace openbmc_project
2806 {
2807 namespace Common
2808 {
2809 namespace Callout
2810 {
2811 namespace _IIC
2812 {
2813 
2814 struct CALLOUT_IIC_BUS
2815 {
2816     /*
2817      * We can't use -fsanitize=undefined if we declare a
2818      * 'static constexpr auto str' member, so don't. Instead, open-code the
2819      * mako template lookups.
2820      */
2821     static constexpr auto str_short = "CALLOUT_IIC_BUS";
2822     using type =
2823         std::tuple<std::decay_t<decltype("CALLOUT_IIC_BUS=%s")>, const char*>;
2824     explicit constexpr CALLOUT_IIC_BUS(const char* a) :
2825         _entry(entry("CALLOUT_IIC_BUS=%s", a)){};
2826     type _entry;
2827 };
2828 struct CALLOUT_IIC_ADDR
2829 {
2830     /*
2831      * We can't use -fsanitize=undefined if we declare a
2832      * 'static constexpr auto str' member, so don't. Instead, open-code the
2833      * mako template lookups.
2834      */
2835     static constexpr auto str_short = "CALLOUT_IIC_ADDR";
2836     using type =
2837         std::tuple<std::decay_t<decltype("CALLOUT_IIC_ADDR=0x%hx")>, uint16_t>;
2838     explicit constexpr CALLOUT_IIC_ADDR(uint16_t a) :
2839         _entry(entry("CALLOUT_IIC_ADDR=0x%hx", a)){};
2840     type _entry;
2841 };
2842 
2843 } // namespace _IIC
2844 
2845 struct IIC
2846 {
2847     static constexpr auto L = level::ERR;
2848     using CALLOUT_IIC_BUS = _IIC::CALLOUT_IIC_BUS;
2849     using CALLOUT_IIC_ADDR = _IIC::CALLOUT_IIC_ADDR;
2850     using CALLOUT_ERRNO =
2851         xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO;
2852     using CALLOUT_DEVICE_PATH =
2853         xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH;
2854     using metadata_types = std::tuple<CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR,
2855                                       CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
2856 };
2857 
2858 } // namespace Callout
2859 } // namespace Common
2860 } // namespace openbmc_project
2861 } // namespace xyz
2862 
2863 namespace details
2864 {
2865 
2866 template <>
2867 struct map_exception_type<
2868     sdbusplus::xyz::openbmc_project::Common::Callout::Error::IIC>
2869 {
2870     using type = xyz::openbmc_project::Common::Callout::IIC;
2871 };
2872 
2873 } // namespace details
2874 
2875 namespace xyz
2876 {
2877 namespace openbmc_project
2878 {
2879 namespace Common
2880 {
2881 namespace Callout
2882 {
2883 namespace _Inventory
2884 {
2885 
2886 struct CALLOUT_INVENTORY_PATH
2887 {
2888     /*
2889      * We can't use -fsanitize=undefined if we declare a
2890      * 'static constexpr auto str' member, so don't. Instead, open-code the
2891      * mako template lookups.
2892      */
2893     static constexpr auto str_short = "CALLOUT_INVENTORY_PATH";
2894     using type = std::tuple<std::decay_t<decltype("CALLOUT_INVENTORY_PATH=%s")>,
2895                             const char*>;
2896     explicit constexpr CALLOUT_INVENTORY_PATH(const char* a) :
2897         _entry(entry("CALLOUT_INVENTORY_PATH=%s", a)){};
2898     type _entry;
2899 };
2900 
2901 } // namespace _Inventory
2902 
2903 struct Inventory
2904 {
2905     static constexpr auto L = level::ERR;
2906     using CALLOUT_INVENTORY_PATH = _Inventory::CALLOUT_INVENTORY_PATH;
2907     using metadata_types = std::tuple<CALLOUT_INVENTORY_PATH>;
2908 };
2909 
2910 } // namespace Callout
2911 } // namespace Common
2912 } // namespace openbmc_project
2913 } // namespace xyz
2914 
2915 namespace details
2916 {
2917 
2918 template <>
2919 struct map_exception_type<
2920     sdbusplus::xyz::openbmc_project::Common::Callout::Error::Inventory>
2921 {
2922     using type = xyz::openbmc_project::Common::Callout::Inventory;
2923 };
2924 
2925 } // namespace details
2926 
2927 namespace xyz
2928 {
2929 namespace openbmc_project
2930 {
2931 namespace Common
2932 {
2933 namespace Callout
2934 {
2935 namespace _IPMISensor
2936 {
2937 
2938 struct CALLOUT_IPMI_SENSOR_NUM
2939 {
2940     /*
2941      * We can't use -fsanitize=undefined if we declare a
2942      * 'static constexpr auto str' member, so don't. Instead, open-code the
2943      * mako template lookups.
2944      */
2945     static constexpr auto str_short = "CALLOUT_IPMI_SENSOR_NUM";
2946     using type =
2947         std::tuple<std::decay_t<decltype("CALLOUT_IPMI_SENSOR_NUM=%u")>,
2948                    uint32_t>;
2949     explicit constexpr CALLOUT_IPMI_SENSOR_NUM(uint32_t a) :
2950         _entry(entry("CALLOUT_IPMI_SENSOR_NUM=%u", a)){};
2951     type _entry;
2952 };
2953 
2954 } // namespace _IPMISensor
2955 
2956 struct IPMISensor
2957 {
2958     static constexpr auto L = level::ERR;
2959     using CALLOUT_IPMI_SENSOR_NUM = _IPMISensor::CALLOUT_IPMI_SENSOR_NUM;
2960     using metadata_types = std::tuple<CALLOUT_IPMI_SENSOR_NUM>;
2961 };
2962 
2963 } // namespace Callout
2964 } // namespace Common
2965 } // namespace openbmc_project
2966 } // namespace xyz
2967 
2968 namespace details
2969 {
2970 
2971 template <>
2972 struct map_exception_type<
2973     sdbusplus::xyz::openbmc_project::Common::Callout::Error::IPMISensor>
2974 {
2975     using type = xyz::openbmc_project::Common::Callout::IPMISensor;
2976 };
2977 
2978 } // namespace details
2979 
2980 namespace org
2981 {
2982 namespace open_power
2983 {
2984 namespace Witherspoon
2985 {
2986 namespace Fault
2987 {
2988 namespace _PowerSupplyInputFault
2989 {
2990 
2991 struct RAW_STATUS
2992 {
2993     /*
2994      * We can't use -fsanitize=undefined if we declare a
2995      * 'static constexpr auto str' member, so don't. Instead, open-code the
2996      * mako template lookups.
2997      */
2998     static constexpr auto str_short = "RAW_STATUS";
2999     using type =
3000         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3001     explicit constexpr RAW_STATUS(const char* a) :
3002         _entry(entry("RAW_STATUS=%s", a)){};
3003     type _entry;
3004 };
3005 
3006 } // namespace _PowerSupplyInputFault
3007 
3008 struct PowerSupplyInputFault
3009 {
3010     static constexpr auto L = level::ERR;
3011     using RAW_STATUS = _PowerSupplyInputFault::RAW_STATUS;
3012     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3013         Inventory::CALLOUT_INVENTORY_PATH;
3014     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3015 };
3016 
3017 } // namespace Fault
3018 } // namespace Witherspoon
3019 } // namespace open_power
3020 } // namespace org
3021 
3022 namespace details
3023 {
3024 
3025 template <>
3026 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3027                               Error::PowerSupplyInputFault>
3028 {
3029     using type = org::open_power::Witherspoon::Fault::PowerSupplyInputFault;
3030 };
3031 
3032 } // namespace details
3033 
3034 namespace org
3035 {
3036 namespace open_power
3037 {
3038 namespace Witherspoon
3039 {
3040 namespace Fault
3041 {
3042 namespace _PowerSupplyShouldBeOn
3043 {
3044 
3045 struct RAW_STATUS
3046 {
3047     /*
3048      * We can't use -fsanitize=undefined if we declare a
3049      * 'static constexpr auto str' member, so don't. Instead, open-code the
3050      * mako template lookups.
3051      */
3052     static constexpr auto str_short = "RAW_STATUS";
3053     using type =
3054         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3055     explicit constexpr RAW_STATUS(const char* a) :
3056         _entry(entry("RAW_STATUS=%s", a)){};
3057     type _entry;
3058 };
3059 
3060 } // namespace _PowerSupplyShouldBeOn
3061 
3062 struct PowerSupplyShouldBeOn
3063 {
3064     static constexpr auto L = level::ERR;
3065     using RAW_STATUS = _PowerSupplyShouldBeOn::RAW_STATUS;
3066     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3067         Inventory::CALLOUT_INVENTORY_PATH;
3068     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3069 };
3070 
3071 } // namespace Fault
3072 } // namespace Witherspoon
3073 } // namespace open_power
3074 } // namespace org
3075 
3076 namespace details
3077 {
3078 
3079 template <>
3080 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3081                               Error::PowerSupplyShouldBeOn>
3082 {
3083     using type = org::open_power::Witherspoon::Fault::PowerSupplyShouldBeOn;
3084 };
3085 
3086 } // namespace details
3087 
3088 namespace org
3089 {
3090 namespace open_power
3091 {
3092 namespace Witherspoon
3093 {
3094 namespace Fault
3095 {
3096 namespace _PowerSupplyOutputOvercurrent
3097 {
3098 
3099 struct RAW_STATUS
3100 {
3101     /*
3102      * We can't use -fsanitize=undefined if we declare a
3103      * 'static constexpr auto str' member, so don't. Instead, open-code the
3104      * mako template lookups.
3105      */
3106     static constexpr auto str_short = "RAW_STATUS";
3107     using type =
3108         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3109     explicit constexpr RAW_STATUS(const char* a) :
3110         _entry(entry("RAW_STATUS=%s", a)){};
3111     type _entry;
3112 };
3113 
3114 } // namespace _PowerSupplyOutputOvercurrent
3115 
3116 struct PowerSupplyOutputOvercurrent
3117 {
3118     static constexpr auto L = level::ERR;
3119     using RAW_STATUS = _PowerSupplyOutputOvercurrent::RAW_STATUS;
3120     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3121         Inventory::CALLOUT_INVENTORY_PATH;
3122     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3123 };
3124 
3125 } // namespace Fault
3126 } // namespace Witherspoon
3127 } // namespace open_power
3128 } // namespace org
3129 
3130 namespace details
3131 {
3132 
3133 template <>
3134 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3135                               Error::PowerSupplyOutputOvercurrent>
3136 {
3137     using type =
3138         org::open_power::Witherspoon::Fault::PowerSupplyOutputOvercurrent;
3139 };
3140 
3141 } // namespace details
3142 
3143 namespace org
3144 {
3145 namespace open_power
3146 {
3147 namespace Witherspoon
3148 {
3149 namespace Fault
3150 {
3151 namespace _PowerSupplyOutputOvervoltage
3152 {
3153 
3154 struct RAW_STATUS
3155 {
3156     /*
3157      * We can't use -fsanitize=undefined if we declare a
3158      * 'static constexpr auto str' member, so don't. Instead, open-code the
3159      * mako template lookups.
3160      */
3161     static constexpr auto str_short = "RAW_STATUS";
3162     using type =
3163         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3164     explicit constexpr RAW_STATUS(const char* a) :
3165         _entry(entry("RAW_STATUS=%s", a)){};
3166     type _entry;
3167 };
3168 
3169 } // namespace _PowerSupplyOutputOvervoltage
3170 
3171 struct PowerSupplyOutputOvervoltage
3172 {
3173     static constexpr auto L = level::ERR;
3174     using RAW_STATUS = _PowerSupplyOutputOvervoltage::RAW_STATUS;
3175     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3176         Inventory::CALLOUT_INVENTORY_PATH;
3177     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3178 };
3179 
3180 } // namespace Fault
3181 } // namespace Witherspoon
3182 } // namespace open_power
3183 } // namespace org
3184 
3185 namespace details
3186 {
3187 
3188 template <>
3189 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3190                               Error::PowerSupplyOutputOvervoltage>
3191 {
3192     using type =
3193         org::open_power::Witherspoon::Fault::PowerSupplyOutputOvervoltage;
3194 };
3195 
3196 } // namespace details
3197 
3198 namespace org
3199 {
3200 namespace open_power
3201 {
3202 namespace Witherspoon
3203 {
3204 namespace Fault
3205 {
3206 namespace _PowerSupplyFanFault
3207 {
3208 
3209 struct RAW_STATUS
3210 {
3211     /*
3212      * We can't use -fsanitize=undefined if we declare a
3213      * 'static constexpr auto str' member, so don't. Instead, open-code the
3214      * mako template lookups.
3215      */
3216     static constexpr auto str_short = "RAW_STATUS";
3217     using type =
3218         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3219     explicit constexpr RAW_STATUS(const char* a) :
3220         _entry(entry("RAW_STATUS=%s", a)){};
3221     type _entry;
3222 };
3223 
3224 } // namespace _PowerSupplyFanFault
3225 
3226 struct PowerSupplyFanFault
3227 {
3228     static constexpr auto L = level::ERR;
3229     using RAW_STATUS = _PowerSupplyFanFault::RAW_STATUS;
3230     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3231         Inventory::CALLOUT_INVENTORY_PATH;
3232     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3233 };
3234 
3235 } // namespace Fault
3236 } // namespace Witherspoon
3237 } // namespace open_power
3238 } // namespace org
3239 
3240 namespace details
3241 {
3242 
3243 template <>
3244 struct map_exception_type<
3245     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSupplyFanFault>
3246 {
3247     using type = org::open_power::Witherspoon::Fault::PowerSupplyFanFault;
3248 };
3249 
3250 } // namespace details
3251 
3252 namespace org
3253 {
3254 namespace open_power
3255 {
3256 namespace Witherspoon
3257 {
3258 namespace Fault
3259 {
3260 namespace _PowerSupplyTemperatureFault
3261 {
3262 
3263 struct RAW_STATUS
3264 {
3265     /*
3266      * We can't use -fsanitize=undefined if we declare a
3267      * 'static constexpr auto str' member, so don't. Instead, open-code the
3268      * mako template lookups.
3269      */
3270     static constexpr auto str_short = "RAW_STATUS";
3271     using type =
3272         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3273     explicit constexpr RAW_STATUS(const char* a) :
3274         _entry(entry("RAW_STATUS=%s", a)){};
3275     type _entry;
3276 };
3277 
3278 } // namespace _PowerSupplyTemperatureFault
3279 
3280 struct PowerSupplyTemperatureFault
3281 {
3282     static constexpr auto L = level::ERR;
3283     using RAW_STATUS = _PowerSupplyTemperatureFault::RAW_STATUS;
3284     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3285         Inventory::CALLOUT_INVENTORY_PATH;
3286     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3287 };
3288 
3289 } // namespace Fault
3290 } // namespace Witherspoon
3291 } // namespace open_power
3292 } // namespace org
3293 
3294 namespace details
3295 {
3296 
3297 template <>
3298 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3299                               Error::PowerSupplyTemperatureFault>
3300 {
3301     using type =
3302         org::open_power::Witherspoon::Fault::PowerSupplyTemperatureFault;
3303 };
3304 
3305 } // namespace details
3306 
3307 namespace org
3308 {
3309 namespace open_power
3310 {
3311 namespace Witherspoon
3312 {
3313 namespace Fault
3314 {
3315 namespace _GPUPowerFault
3316 {
3317 
3318 struct RAW_STATUS
3319 {
3320     /*
3321      * We can't use -fsanitize=undefined if we declare a
3322      * 'static constexpr auto str' member, so don't. Instead, open-code the
3323      * mako template lookups.
3324      */
3325     static constexpr auto str_short = "RAW_STATUS";
3326     using type =
3327         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3328     explicit constexpr RAW_STATUS(const char* a) :
3329         _entry(entry("RAW_STATUS=%s", a)){};
3330     type _entry;
3331 };
3332 
3333 } // namespace _GPUPowerFault
3334 
3335 struct GPUPowerFault
3336 {
3337     static constexpr auto L = level::ERR;
3338     using RAW_STATUS = _GPUPowerFault::RAW_STATUS;
3339     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3340         Inventory::CALLOUT_INVENTORY_PATH;
3341     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3342 };
3343 
3344 } // namespace Fault
3345 } // namespace Witherspoon
3346 } // namespace open_power
3347 } // namespace org
3348 
3349 namespace details
3350 {
3351 
3352 template <>
3353 struct map_exception_type<
3354     sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUPowerFault>
3355 {
3356     using type = org::open_power::Witherspoon::Fault::GPUPowerFault;
3357 };
3358 
3359 } // namespace details
3360 
3361 namespace org
3362 {
3363 namespace open_power
3364 {
3365 namespace Witherspoon
3366 {
3367 namespace Fault
3368 {
3369 namespace _GPUOverTemp
3370 {
3371 
3372 struct RAW_STATUS
3373 {
3374     /*
3375      * We can't use -fsanitize=undefined if we declare a
3376      * 'static constexpr auto str' member, so don't. Instead, open-code the
3377      * mako template lookups.
3378      */
3379     static constexpr auto str_short = "RAW_STATUS";
3380     using type =
3381         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3382     explicit constexpr RAW_STATUS(const char* a) :
3383         _entry(entry("RAW_STATUS=%s", a)){};
3384     type _entry;
3385 };
3386 
3387 } // namespace _GPUOverTemp
3388 
3389 struct GPUOverTemp
3390 {
3391     static constexpr auto L = level::ERR;
3392     using RAW_STATUS = _GPUOverTemp::RAW_STATUS;
3393     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3394         Inventory::CALLOUT_INVENTORY_PATH;
3395     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3396 };
3397 
3398 } // namespace Fault
3399 } // namespace Witherspoon
3400 } // namespace open_power
3401 } // namespace org
3402 
3403 namespace details
3404 {
3405 
3406 template <>
3407 struct map_exception_type<
3408     sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUOverTemp>
3409 {
3410     using type = org::open_power::Witherspoon::Fault::GPUOverTemp;
3411 };
3412 
3413 } // namespace details
3414 
3415 namespace org
3416 {
3417 namespace open_power
3418 {
3419 namespace Witherspoon
3420 {
3421 namespace Fault
3422 {
3423 namespace _MemoryPowerFault
3424 {
3425 
3426 struct RAW_STATUS
3427 {
3428     /*
3429      * We can't use -fsanitize=undefined if we declare a
3430      * 'static constexpr auto str' member, so don't. Instead, open-code the
3431      * mako template lookups.
3432      */
3433     static constexpr auto str_short = "RAW_STATUS";
3434     using type =
3435         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3436     explicit constexpr RAW_STATUS(const char* a) :
3437         _entry(entry("RAW_STATUS=%s", a)){};
3438     type _entry;
3439 };
3440 
3441 } // namespace _MemoryPowerFault
3442 
3443 struct MemoryPowerFault
3444 {
3445     static constexpr auto L = level::ERR;
3446     using RAW_STATUS = _MemoryPowerFault::RAW_STATUS;
3447     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3448         Inventory::CALLOUT_INVENTORY_PATH;
3449     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3450 };
3451 
3452 } // namespace Fault
3453 } // namespace Witherspoon
3454 } // namespace open_power
3455 } // namespace org
3456 
3457 namespace details
3458 {
3459 
3460 template <>
3461 struct map_exception_type<
3462     sdbusplus::org::open_power::Witherspoon::Fault::Error::MemoryPowerFault>
3463 {
3464     using type = org::open_power::Witherspoon::Fault::MemoryPowerFault;
3465 };
3466 
3467 } // namespace details
3468 
3469 } // namespace logging
3470 
3471 } // namespace phosphor
3472