xref: /openbmc/phosphor-power/elog-errors.hpp (revision cd9ab087) 
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 {
1149 
1150 } // namespace _Shutdown
1151 
1152 struct Shutdown
1153 {
1154     static constexpr auto L = level::ERR;
1155     using metadata_types = std::tuple<>;
1156 };
1157 
1158 } // namespace Fault
1159 } // namespace Witherspoon
1160 } // namespace open_power
1161 } // namespace org
1162 
1163 namespace details
1164 {
1165 
1166 template <>
1167 struct map_exception_type<
1168     sdbusplus::org::open_power::Witherspoon::Fault::Error::Shutdown>
1169 {
1170     using type = org::open_power::Witherspoon::Fault::Shutdown;
1171 };
1172 
1173 } // namespace details
1174 
1175 namespace org
1176 {
1177 namespace open_power
1178 {
1179 namespace Witherspoon
1180 {
1181 namespace Fault
1182 {
1183 namespace _PowerOnFailure
1184 {
1185 
1186 } // namespace _PowerOnFailure
1187 
1188 struct PowerOnFailure
1189 {
1190     static constexpr auto L = level::ERR;
1191     using metadata_types = std::tuple<>;
1192 };
1193 
1194 } // namespace Fault
1195 } // namespace Witherspoon
1196 } // namespace open_power
1197 } // namespace org
1198 
1199 namespace details
1200 {
1201 
1202 template <>
1203 struct map_exception_type<
1204     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerOnFailure>
1205 {
1206     using type = org::open_power::Witherspoon::Fault::PowerOnFailure;
1207 };
1208 
1209 } // namespace details
1210 
1211 namespace org
1212 {
1213 namespace open_power
1214 {
1215 namespace Witherspoon
1216 {
1217 namespace Fault
1218 {
1219 namespace _ErrorCode0
1220 {
1221 
1222 } // namespace _ErrorCode0
1223 
1224 struct ErrorCode0
1225 {
1226     static constexpr auto L = level::ERR;
1227     using metadata_types = std::tuple<>;
1228 };
1229 
1230 } // namespace Fault
1231 } // namespace Witherspoon
1232 } // namespace open_power
1233 } // namespace org
1234 
1235 namespace details
1236 {
1237 
1238 template <>
1239 struct map_exception_type<
1240     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode0>
1241 {
1242     using type = org::open_power::Witherspoon::Fault::ErrorCode0;
1243 };
1244 
1245 } // namespace details
1246 
1247 namespace org
1248 {
1249 namespace open_power
1250 {
1251 namespace Witherspoon
1252 {
1253 namespace Fault
1254 {
1255 namespace _ErrorCode1
1256 {
1257 
1258 } // namespace _ErrorCode1
1259 
1260 struct ErrorCode1
1261 {
1262     static constexpr auto L = level::ERR;
1263     using metadata_types = std::tuple<>;
1264 };
1265 
1266 } // namespace Fault
1267 } // namespace Witherspoon
1268 } // namespace open_power
1269 } // namespace org
1270 
1271 namespace details
1272 {
1273 
1274 template <>
1275 struct map_exception_type<
1276     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode1>
1277 {
1278     using type = org::open_power::Witherspoon::Fault::ErrorCode1;
1279 };
1280 
1281 } // namespace details
1282 
1283 namespace org
1284 {
1285 namespace open_power
1286 {
1287 namespace Witherspoon
1288 {
1289 namespace Fault
1290 {
1291 namespace _ErrorCode2
1292 {
1293 
1294 } // namespace _ErrorCode2
1295 
1296 struct ErrorCode2
1297 {
1298     static constexpr auto L = level::ERR;
1299     using metadata_types = std::tuple<>;
1300 };
1301 
1302 } // namespace Fault
1303 } // namespace Witherspoon
1304 } // namespace open_power
1305 } // namespace org
1306 
1307 namespace details
1308 {
1309 
1310 template <>
1311 struct map_exception_type<
1312     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode2>
1313 {
1314     using type = org::open_power::Witherspoon::Fault::ErrorCode2;
1315 };
1316 
1317 } // namespace details
1318 
1319 namespace org
1320 {
1321 namespace open_power
1322 {
1323 namespace Witherspoon
1324 {
1325 namespace Fault
1326 {
1327 namespace _ErrorCode3
1328 {
1329 
1330 } // namespace _ErrorCode3
1331 
1332 struct ErrorCode3
1333 {
1334     static constexpr auto L = level::ERR;
1335     using metadata_types = std::tuple<>;
1336 };
1337 
1338 } // namespace Fault
1339 } // namespace Witherspoon
1340 } // namespace open_power
1341 } // namespace org
1342 
1343 namespace details
1344 {
1345 
1346 template <>
1347 struct map_exception_type<
1348     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode3>
1349 {
1350     using type = org::open_power::Witherspoon::Fault::ErrorCode3;
1351 };
1352 
1353 } // namespace details
1354 
1355 namespace org
1356 {
1357 namespace open_power
1358 {
1359 namespace Witherspoon
1360 {
1361 namespace Fault
1362 {
1363 namespace _ErrorCode4
1364 {
1365 
1366 } // namespace _ErrorCode4
1367 
1368 struct ErrorCode4
1369 {
1370     static constexpr auto L = level::ERR;
1371     using metadata_types = std::tuple<>;
1372 };
1373 
1374 } // namespace Fault
1375 } // namespace Witherspoon
1376 } // namespace open_power
1377 } // namespace org
1378 
1379 namespace details
1380 {
1381 
1382 template <>
1383 struct map_exception_type<
1384     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode4>
1385 {
1386     using type = org::open_power::Witherspoon::Fault::ErrorCode4;
1387 };
1388 
1389 } // namespace details
1390 
1391 namespace org
1392 {
1393 namespace open_power
1394 {
1395 namespace Witherspoon
1396 {
1397 namespace Fault
1398 {
1399 namespace _ErrorCode5
1400 {
1401 
1402 } // namespace _ErrorCode5
1403 
1404 struct ErrorCode5
1405 {
1406     static constexpr auto L = level::ERR;
1407     using metadata_types = std::tuple<>;
1408 };
1409 
1410 } // namespace Fault
1411 } // namespace Witherspoon
1412 } // namespace open_power
1413 } // namespace org
1414 
1415 namespace details
1416 {
1417 
1418 template <>
1419 struct map_exception_type<
1420     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode5>
1421 {
1422     using type = org::open_power::Witherspoon::Fault::ErrorCode5;
1423 };
1424 
1425 } // namespace details
1426 
1427 namespace org
1428 {
1429 namespace open_power
1430 {
1431 namespace Witherspoon
1432 {
1433 namespace Fault
1434 {
1435 namespace _ErrorCode6
1436 {
1437 
1438 } // namespace _ErrorCode6
1439 
1440 struct ErrorCode6
1441 {
1442     static constexpr auto L = level::ERR;
1443     using metadata_types = std::tuple<>;
1444 };
1445 
1446 } // namespace Fault
1447 } // namespace Witherspoon
1448 } // namespace open_power
1449 } // namespace org
1450 
1451 namespace details
1452 {
1453 
1454 template <>
1455 struct map_exception_type<
1456     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode6>
1457 {
1458     using type = org::open_power::Witherspoon::Fault::ErrorCode6;
1459 };
1460 
1461 } // namespace details
1462 
1463 namespace org
1464 {
1465 namespace open_power
1466 {
1467 namespace Witherspoon
1468 {
1469 namespace Fault
1470 {
1471 namespace _ErrorCode7
1472 {
1473 
1474 } // namespace _ErrorCode7
1475 
1476 struct ErrorCode7
1477 {
1478     static constexpr auto L = level::ERR;
1479     using metadata_types = std::tuple<>;
1480 };
1481 
1482 } // namespace Fault
1483 } // namespace Witherspoon
1484 } // namespace open_power
1485 } // namespace org
1486 
1487 namespace details
1488 {
1489 
1490 template <>
1491 struct map_exception_type<
1492     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode7>
1493 {
1494     using type = org::open_power::Witherspoon::Fault::ErrorCode7;
1495 };
1496 
1497 } // namespace details
1498 
1499 namespace org
1500 {
1501 namespace open_power
1502 {
1503 namespace Witherspoon
1504 {
1505 namespace Fault
1506 {
1507 namespace _ErrorCode8
1508 {
1509 
1510 } // namespace _ErrorCode8
1511 
1512 struct ErrorCode8
1513 {
1514     static constexpr auto L = level::ERR;
1515     using metadata_types = std::tuple<>;
1516 };
1517 
1518 } // namespace Fault
1519 } // namespace Witherspoon
1520 } // namespace open_power
1521 } // namespace org
1522 
1523 namespace details
1524 {
1525 
1526 template <>
1527 struct map_exception_type<
1528     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode8>
1529 {
1530     using type = org::open_power::Witherspoon::Fault::ErrorCode8;
1531 };
1532 
1533 } // namespace details
1534 
1535 namespace org
1536 {
1537 namespace open_power
1538 {
1539 namespace Witherspoon
1540 {
1541 namespace Fault
1542 {
1543 namespace _ErrorCode9
1544 {
1545 
1546 } // namespace _ErrorCode9
1547 
1548 struct ErrorCode9
1549 {
1550     static constexpr auto L = level::ERR;
1551     using metadata_types = std::tuple<>;
1552 };
1553 
1554 } // namespace Fault
1555 } // namespace Witherspoon
1556 } // namespace open_power
1557 } // namespace org
1558 
1559 namespace details
1560 {
1561 
1562 template <>
1563 struct map_exception_type<
1564     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode9>
1565 {
1566     using type = org::open_power::Witherspoon::Fault::ErrorCode9;
1567 };
1568 
1569 } // namespace details
1570 
1571 namespace org
1572 {
1573 namespace open_power
1574 {
1575 namespace Witherspoon
1576 {
1577 namespace Fault
1578 {
1579 namespace _ErrorCode10
1580 {
1581 
1582 } // namespace _ErrorCode10
1583 
1584 struct ErrorCode10
1585 {
1586     static constexpr auto L = level::ERR;
1587     using metadata_types = std::tuple<>;
1588 };
1589 
1590 } // namespace Fault
1591 } // namespace Witherspoon
1592 } // namespace open_power
1593 } // namespace org
1594 
1595 namespace details
1596 {
1597 
1598 template <>
1599 struct map_exception_type<
1600     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode10>
1601 {
1602     using type = org::open_power::Witherspoon::Fault::ErrorCode10;
1603 };
1604 
1605 } // namespace details
1606 
1607 namespace org
1608 {
1609 namespace open_power
1610 {
1611 namespace Witherspoon
1612 {
1613 namespace Fault
1614 {
1615 namespace _ErrorCode11
1616 {
1617 
1618 } // namespace _ErrorCode11
1619 
1620 struct ErrorCode11
1621 {
1622     static constexpr auto L = level::ERR;
1623     using metadata_types = std::tuple<>;
1624 };
1625 
1626 } // namespace Fault
1627 } // namespace Witherspoon
1628 } // namespace open_power
1629 } // namespace org
1630 
1631 namespace details
1632 {
1633 
1634 template <>
1635 struct map_exception_type<
1636     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode11>
1637 {
1638     using type = org::open_power::Witherspoon::Fault::ErrorCode11;
1639 };
1640 
1641 } // namespace details
1642 
1643 namespace org
1644 {
1645 namespace open_power
1646 {
1647 namespace Witherspoon
1648 {
1649 namespace Fault
1650 {
1651 namespace _ErrorCode12
1652 {
1653 
1654 } // namespace _ErrorCode12
1655 
1656 struct ErrorCode12
1657 {
1658     static constexpr auto L = level::ERR;
1659     using metadata_types = std::tuple<>;
1660 };
1661 
1662 } // namespace Fault
1663 } // namespace Witherspoon
1664 } // namespace open_power
1665 } // namespace org
1666 
1667 namespace details
1668 {
1669 
1670 template <>
1671 struct map_exception_type<
1672     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode12>
1673 {
1674     using type = org::open_power::Witherspoon::Fault::ErrorCode12;
1675 };
1676 
1677 } // namespace details
1678 
1679 namespace org
1680 {
1681 namespace open_power
1682 {
1683 namespace Witherspoon
1684 {
1685 namespace Fault
1686 {
1687 namespace _ErrorCode13
1688 {
1689 
1690 } // namespace _ErrorCode13
1691 
1692 struct ErrorCode13
1693 {
1694     static constexpr auto L = level::ERR;
1695     using metadata_types = std::tuple<>;
1696 };
1697 
1698 } // namespace Fault
1699 } // namespace Witherspoon
1700 } // namespace open_power
1701 } // namespace org
1702 
1703 namespace details
1704 {
1705 
1706 template <>
1707 struct map_exception_type<
1708     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode13>
1709 {
1710     using type = org::open_power::Witherspoon::Fault::ErrorCode13;
1711 };
1712 
1713 } // namespace details
1714 
1715 namespace org
1716 {
1717 namespace open_power
1718 {
1719 namespace Witherspoon
1720 {
1721 namespace Fault
1722 {
1723 namespace _ErrorCode14
1724 {
1725 
1726 } // namespace _ErrorCode14
1727 
1728 struct ErrorCode14
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::ErrorCode14>
1745 {
1746     using type = org::open_power::Witherspoon::Fault::ErrorCode14;
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 _ErrorCode15
1760 {
1761 
1762 } // namespace _ErrorCode15
1763 
1764 struct ErrorCode15
1765 {
1766     static constexpr auto L = level::ERR;
1767     using metadata_types = std::tuple<>;
1768 };
1769 
1770 } // namespace Fault
1771 } // namespace Witherspoon
1772 } // namespace open_power
1773 } // namespace org
1774 
1775 namespace details
1776 {
1777 
1778 template <>
1779 struct map_exception_type<
1780     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode15>
1781 {
1782     using type = org::open_power::Witherspoon::Fault::ErrorCode15;
1783 };
1784 
1785 } // namespace details
1786 
1787 namespace org
1788 {
1789 namespace open_power
1790 {
1791 namespace Witherspoon
1792 {
1793 namespace Fault
1794 {
1795 namespace _ErrorCode16
1796 {
1797 
1798 } // namespace _ErrorCode16
1799 
1800 struct ErrorCode16
1801 {
1802     static constexpr auto L = level::ERR;
1803     using metadata_types = std::tuple<>;
1804 };
1805 
1806 } // namespace Fault
1807 } // namespace Witherspoon
1808 } // namespace open_power
1809 } // namespace org
1810 
1811 namespace details
1812 {
1813 
1814 template <>
1815 struct map_exception_type<
1816     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode16>
1817 {
1818     using type = org::open_power::Witherspoon::Fault::ErrorCode16;
1819 };
1820 
1821 } // namespace details
1822 
1823 namespace org
1824 {
1825 namespace open_power
1826 {
1827 namespace Witherspoon
1828 {
1829 namespace Fault
1830 {
1831 namespace _ErrorCode17
1832 {
1833 
1834 } // namespace _ErrorCode17
1835 
1836 struct ErrorCode17
1837 {
1838     static constexpr auto L = level::ERR;
1839     using metadata_types = std::tuple<>;
1840 };
1841 
1842 } // namespace Fault
1843 } // namespace Witherspoon
1844 } // namespace open_power
1845 } // namespace org
1846 
1847 namespace details
1848 {
1849 
1850 template <>
1851 struct map_exception_type<
1852     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode17>
1853 {
1854     using type = org::open_power::Witherspoon::Fault::ErrorCode17;
1855 };
1856 
1857 } // namespace details
1858 
1859 namespace org
1860 {
1861 namespace open_power
1862 {
1863 namespace Witherspoon
1864 {
1865 namespace Fault
1866 {
1867 namespace _ErrorCode18
1868 {
1869 
1870 } // namespace _ErrorCode18
1871 
1872 struct ErrorCode18
1873 {
1874     static constexpr auto L = level::ERR;
1875     using metadata_types = std::tuple<>;
1876 };
1877 
1878 } // namespace Fault
1879 } // namespace Witherspoon
1880 } // namespace open_power
1881 } // namespace org
1882 
1883 namespace details
1884 {
1885 
1886 template <>
1887 struct map_exception_type<
1888     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode18>
1889 {
1890     using type = org::open_power::Witherspoon::Fault::ErrorCode18;
1891 };
1892 
1893 } // namespace details
1894 
1895 namespace org
1896 {
1897 namespace open_power
1898 {
1899 namespace Witherspoon
1900 {
1901 namespace Fault
1902 {
1903 namespace _ErrorCode19
1904 {
1905 
1906 } // namespace _ErrorCode19
1907 
1908 struct ErrorCode19
1909 {
1910     static constexpr auto L = level::ERR;
1911     using metadata_types = std::tuple<>;
1912 };
1913 
1914 } // namespace Fault
1915 } // namespace Witherspoon
1916 } // namespace open_power
1917 } // namespace org
1918 
1919 namespace details
1920 {
1921 
1922 template <>
1923 struct map_exception_type<
1924     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode19>
1925 {
1926     using type = org::open_power::Witherspoon::Fault::ErrorCode19;
1927 };
1928 
1929 } // namespace details
1930 
1931 namespace org
1932 {
1933 namespace open_power
1934 {
1935 namespace Witherspoon
1936 {
1937 namespace Fault
1938 {
1939 namespace _ErrorCode20
1940 {
1941 
1942 } // namespace _ErrorCode20
1943 
1944 struct ErrorCode20
1945 {
1946     static constexpr auto L = level::ERR;
1947     using metadata_types = std::tuple<>;
1948 };
1949 
1950 } // namespace Fault
1951 } // namespace Witherspoon
1952 } // namespace open_power
1953 } // namespace org
1954 
1955 namespace details
1956 {
1957 
1958 template <>
1959 struct map_exception_type<
1960     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode20>
1961 {
1962     using type = org::open_power::Witherspoon::Fault::ErrorCode20;
1963 };
1964 
1965 } // namespace details
1966 
1967 namespace org
1968 {
1969 namespace open_power
1970 {
1971 namespace Witherspoon
1972 {
1973 namespace Fault
1974 {
1975 namespace _ErrorCode21
1976 {
1977 
1978 } // namespace _ErrorCode21
1979 
1980 struct ErrorCode21
1981 {
1982     static constexpr auto L = level::ERR;
1983     using metadata_types = std::tuple<>;
1984 };
1985 
1986 } // namespace Fault
1987 } // namespace Witherspoon
1988 } // namespace open_power
1989 } // namespace org
1990 
1991 namespace details
1992 {
1993 
1994 template <>
1995 struct map_exception_type<
1996     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode21>
1997 {
1998     using type = org::open_power::Witherspoon::Fault::ErrorCode21;
1999 };
2000 
2001 } // namespace details
2002 
2003 namespace org
2004 {
2005 namespace open_power
2006 {
2007 namespace Witherspoon
2008 {
2009 namespace Fault
2010 {
2011 namespace _ErrorCode22
2012 {
2013 
2014 } // namespace _ErrorCode22
2015 
2016 struct ErrorCode22
2017 {
2018     static constexpr auto L = level::ERR;
2019     using metadata_types = std::tuple<>;
2020 };
2021 
2022 } // namespace Fault
2023 } // namespace Witherspoon
2024 } // namespace open_power
2025 } // namespace org
2026 
2027 namespace details
2028 {
2029 
2030 template <>
2031 struct map_exception_type<
2032     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode22>
2033 {
2034     using type = org::open_power::Witherspoon::Fault::ErrorCode22;
2035 };
2036 
2037 } // namespace details
2038 
2039 namespace org
2040 {
2041 namespace open_power
2042 {
2043 namespace Witherspoon
2044 {
2045 namespace Fault
2046 {
2047 namespace _ErrorCode23
2048 {
2049 
2050 } // namespace _ErrorCode23
2051 
2052 struct ErrorCode23
2053 {
2054     static constexpr auto L = level::ERR;
2055     using metadata_types = std::tuple<>;
2056 };
2057 
2058 } // namespace Fault
2059 } // namespace Witherspoon
2060 } // namespace open_power
2061 } // namespace org
2062 
2063 namespace details
2064 {
2065 
2066 template <>
2067 struct map_exception_type<
2068     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode23>
2069 {
2070     using type = org::open_power::Witherspoon::Fault::ErrorCode23;
2071 };
2072 
2073 } // namespace details
2074 
2075 namespace org
2076 {
2077 namespace open_power
2078 {
2079 namespace Witherspoon
2080 {
2081 namespace Fault
2082 {
2083 namespace _ErrorCode24
2084 {
2085 
2086 } // namespace _ErrorCode24
2087 
2088 struct ErrorCode24
2089 {
2090     static constexpr auto L = level::ERR;
2091     using metadata_types = std::tuple<>;
2092 };
2093 
2094 } // namespace Fault
2095 } // namespace Witherspoon
2096 } // namespace open_power
2097 } // namespace org
2098 
2099 namespace details
2100 {
2101 
2102 template <>
2103 struct map_exception_type<
2104     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode24>
2105 {
2106     using type = org::open_power::Witherspoon::Fault::ErrorCode24;
2107 };
2108 
2109 } // namespace details
2110 
2111 namespace org
2112 {
2113 namespace open_power
2114 {
2115 namespace Witherspoon
2116 {
2117 namespace Fault
2118 {
2119 namespace _ErrorCode25
2120 {
2121 
2122 } // namespace _ErrorCode25
2123 
2124 struct ErrorCode25
2125 {
2126     static constexpr auto L = level::ERR;
2127     using metadata_types = std::tuple<>;
2128 };
2129 
2130 } // namespace Fault
2131 } // namespace Witherspoon
2132 } // namespace open_power
2133 } // namespace org
2134 
2135 namespace details
2136 {
2137 
2138 template <>
2139 struct map_exception_type<
2140     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode25>
2141 {
2142     using type = org::open_power::Witherspoon::Fault::ErrorCode25;
2143 };
2144 
2145 } // namespace details
2146 
2147 namespace org
2148 {
2149 namespace open_power
2150 {
2151 namespace Witherspoon
2152 {
2153 namespace Fault
2154 {
2155 namespace _ErrorCode26
2156 {
2157 
2158 } // namespace _ErrorCode26
2159 
2160 struct ErrorCode26
2161 {
2162     static constexpr auto L = level::ERR;
2163     using metadata_types = std::tuple<>;
2164 };
2165 
2166 } // namespace Fault
2167 } // namespace Witherspoon
2168 } // namespace open_power
2169 } // namespace org
2170 
2171 namespace details
2172 {
2173 
2174 template <>
2175 struct map_exception_type<
2176     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode26>
2177 {
2178     using type = org::open_power::Witherspoon::Fault::ErrorCode26;
2179 };
2180 
2181 } // namespace details
2182 
2183 namespace org
2184 {
2185 namespace open_power
2186 {
2187 namespace Witherspoon
2188 {
2189 namespace Fault
2190 {
2191 namespace _ErrorCode27
2192 {
2193 
2194 } // namespace _ErrorCode27
2195 
2196 struct ErrorCode27
2197 {
2198     static constexpr auto L = level::ERR;
2199     using metadata_types = std::tuple<>;
2200 };
2201 
2202 } // namespace Fault
2203 } // namespace Witherspoon
2204 } // namespace open_power
2205 } // namespace org
2206 
2207 namespace details
2208 {
2209 
2210 template <>
2211 struct map_exception_type<
2212     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode27>
2213 {
2214     using type = org::open_power::Witherspoon::Fault::ErrorCode27;
2215 };
2216 
2217 } // namespace details
2218 
2219 namespace org
2220 {
2221 namespace open_power
2222 {
2223 namespace Witherspoon
2224 {
2225 namespace Fault
2226 {
2227 namespace _ErrorCode28
2228 {
2229 
2230 } // namespace _ErrorCode28
2231 
2232 struct ErrorCode28
2233 {
2234     static constexpr auto L = level::ERR;
2235     using metadata_types = std::tuple<>;
2236 };
2237 
2238 } // namespace Fault
2239 } // namespace Witherspoon
2240 } // namespace open_power
2241 } // namespace org
2242 
2243 namespace details
2244 {
2245 
2246 template <>
2247 struct map_exception_type<
2248     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode28>
2249 {
2250     using type = org::open_power::Witherspoon::Fault::ErrorCode28;
2251 };
2252 
2253 } // namespace details
2254 
2255 namespace org
2256 {
2257 namespace open_power
2258 {
2259 namespace Witherspoon
2260 {
2261 namespace Fault
2262 {
2263 namespace _ErrorCode29
2264 {
2265 
2266 } // namespace _ErrorCode29
2267 
2268 struct ErrorCode29
2269 {
2270     static constexpr auto L = level::ERR;
2271     using metadata_types = std::tuple<>;
2272 };
2273 
2274 } // namespace Fault
2275 } // namespace Witherspoon
2276 } // namespace open_power
2277 } // namespace org
2278 
2279 namespace details
2280 {
2281 
2282 template <>
2283 struct map_exception_type<
2284     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode29>
2285 {
2286     using type = org::open_power::Witherspoon::Fault::ErrorCode29;
2287 };
2288 
2289 } // namespace details
2290 
2291 namespace org
2292 {
2293 namespace open_power
2294 {
2295 namespace Witherspoon
2296 {
2297 namespace Fault
2298 {
2299 namespace _ErrorCode30
2300 {
2301 
2302 } // namespace _ErrorCode30
2303 
2304 struct ErrorCode30
2305 {
2306     static constexpr auto L = level::ERR;
2307     using metadata_types = std::tuple<>;
2308 };
2309 
2310 } // namespace Fault
2311 } // namespace Witherspoon
2312 } // namespace open_power
2313 } // namespace org
2314 
2315 namespace details
2316 {
2317 
2318 template <>
2319 struct map_exception_type<
2320     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode30>
2321 {
2322     using type = org::open_power::Witherspoon::Fault::ErrorCode30;
2323 };
2324 
2325 } // namespace details
2326 
2327 namespace org
2328 {
2329 namespace open_power
2330 {
2331 namespace Witherspoon
2332 {
2333 namespace Fault
2334 {
2335 namespace _ErrorCode31
2336 {
2337 
2338 } // namespace _ErrorCode31
2339 
2340 struct ErrorCode31
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::ErrorCode31>
2357 {
2358     using type = org::open_power::Witherspoon::Fault::ErrorCode31;
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 _ErrorCode32
2372 {
2373 
2374 } // namespace _ErrorCode32
2375 
2376 struct ErrorCode32
2377 {
2378     static constexpr auto L = level::ERR;
2379     using metadata_types = std::tuple<>;
2380 };
2381 
2382 } // namespace Fault
2383 } // namespace Witherspoon
2384 } // namespace open_power
2385 } // namespace org
2386 
2387 namespace details
2388 {
2389 
2390 template <>
2391 struct map_exception_type<
2392     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode32>
2393 {
2394     using type = org::open_power::Witherspoon::Fault::ErrorCode32;
2395 };
2396 
2397 } // namespace details
2398 
2399 namespace org
2400 {
2401 namespace open_power
2402 {
2403 namespace Witherspoon
2404 {
2405 namespace Fault
2406 {
2407 namespace _ErrorCode33
2408 {
2409 
2410 } // namespace _ErrorCode33
2411 
2412 struct ErrorCode33
2413 {
2414     static constexpr auto L = level::ERR;
2415     using metadata_types = std::tuple<>;
2416 };
2417 
2418 } // namespace Fault
2419 } // namespace Witherspoon
2420 } // namespace open_power
2421 } // namespace org
2422 
2423 namespace details
2424 {
2425 
2426 template <>
2427 struct map_exception_type<
2428     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode33>
2429 {
2430     using type = org::open_power::Witherspoon::Fault::ErrorCode33;
2431 };
2432 
2433 } // namespace details
2434 
2435 namespace org
2436 {
2437 namespace open_power
2438 {
2439 namespace Witherspoon
2440 {
2441 namespace Fault
2442 {
2443 namespace _ErrorCode34
2444 {
2445 
2446 } // namespace _ErrorCode34
2447 
2448 struct ErrorCode34
2449 {
2450     static constexpr auto L = level::ERR;
2451     using metadata_types = std::tuple<>;
2452 };
2453 
2454 } // namespace Fault
2455 } // namespace Witherspoon
2456 } // namespace open_power
2457 } // namespace org
2458 
2459 namespace details
2460 {
2461 
2462 template <>
2463 struct map_exception_type<
2464     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode34>
2465 {
2466     using type = org::open_power::Witherspoon::Fault::ErrorCode34;
2467 };
2468 
2469 } // namespace details
2470 
2471 namespace org
2472 {
2473 namespace open_power
2474 {
2475 namespace Witherspoon
2476 {
2477 namespace Fault
2478 {
2479 namespace _ErrorCode35
2480 {
2481 
2482 } // namespace _ErrorCode35
2483 
2484 struct ErrorCode35
2485 {
2486     static constexpr auto L = level::ERR;
2487     using metadata_types = std::tuple<>;
2488 };
2489 
2490 } // namespace Fault
2491 } // namespace Witherspoon
2492 } // namespace open_power
2493 } // namespace org
2494 
2495 namespace details
2496 {
2497 
2498 template <>
2499 struct map_exception_type<
2500     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode35>
2501 {
2502     using type = org::open_power::Witherspoon::Fault::ErrorCode35;
2503 };
2504 
2505 } // namespace details
2506 
2507 namespace org
2508 {
2509 namespace open_power
2510 {
2511 namespace Witherspoon
2512 {
2513 namespace Fault
2514 {
2515 namespace _ErrorCode36
2516 {
2517 
2518 } // namespace _ErrorCode36
2519 
2520 struct ErrorCode36
2521 {
2522     static constexpr auto L = level::ERR;
2523     using metadata_types = std::tuple<>;
2524 };
2525 
2526 } // namespace Fault
2527 } // namespace Witherspoon
2528 } // namespace open_power
2529 } // namespace org
2530 
2531 namespace details
2532 {
2533 
2534 template <>
2535 struct map_exception_type<
2536     sdbusplus::org::open_power::Witherspoon::Fault::Error::ErrorCode36>
2537 {
2538     using type = org::open_power::Witherspoon::Fault::ErrorCode36;
2539 };
2540 
2541 } // namespace details
2542 
2543 namespace org
2544 {
2545 namespace open_power
2546 {
2547 namespace Witherspoon
2548 {
2549 namespace Fault
2550 {
2551 namespace _PowerSequencerVoltageFault
2552 {
2553 
2554 struct RAIL
2555 {
2556     /*
2557      * We can't use -fsanitize=undefined if we declare a
2558      * 'static constexpr auto str' member, so don't. Instead, open-code the
2559      * mako template lookups.
2560      */
2561     static constexpr auto str_short = "RAIL";
2562     using type = std::tuple<std::decay_t<decltype("RAIL=%d")>, uint16_t>;
2563     explicit constexpr RAIL(uint16_t a) : _entry(entry("RAIL=%d", a)){};
2564     type _entry;
2565 };
2566 struct RAIL_NAME
2567 {
2568     /*
2569      * We can't use -fsanitize=undefined if we declare a
2570      * 'static constexpr auto str' member, so don't. Instead, open-code the
2571      * mako template lookups.
2572      */
2573     static constexpr auto str_short = "RAIL_NAME";
2574     using type =
2575         std::tuple<std::decay_t<decltype("RAIL_NAME=%s")>, const char*>;
2576     explicit constexpr RAIL_NAME(const char* a) :
2577         _entry(entry("RAIL_NAME=%s", a)){};
2578     type _entry;
2579 };
2580 struct RAW_STATUS
2581 {
2582     /*
2583      * We can't use -fsanitize=undefined if we declare a
2584      * 'static constexpr auto str' member, so don't. Instead, open-code the
2585      * mako template lookups.
2586      */
2587     static constexpr auto str_short = "RAW_STATUS";
2588     using type =
2589         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
2590     explicit constexpr RAW_STATUS(const char* a) :
2591         _entry(entry("RAW_STATUS=%s", a)){};
2592     type _entry;
2593 };
2594 
2595 } // namespace _PowerSequencerVoltageFault
2596 
2597 struct PowerSequencerVoltageFault
2598 {
2599     static constexpr auto L = level::ERR;
2600     using RAIL = _PowerSequencerVoltageFault::RAIL;
2601     using RAIL_NAME = _PowerSequencerVoltageFault::RAIL_NAME;
2602     using RAW_STATUS = _PowerSequencerVoltageFault::RAW_STATUS;
2603     using metadata_types = std::tuple<RAIL, RAIL_NAME, RAW_STATUS>;
2604 };
2605 
2606 } // namespace Fault
2607 } // namespace Witherspoon
2608 } // namespace open_power
2609 } // namespace org
2610 
2611 namespace details
2612 {
2613 
2614 template <>
2615 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
2616                               Error::PowerSequencerVoltageFault>
2617 {
2618     using type =
2619         org::open_power::Witherspoon::Fault::PowerSequencerVoltageFault;
2620 };
2621 
2622 } // namespace details
2623 
2624 namespace org
2625 {
2626 namespace open_power
2627 {
2628 namespace Witherspoon
2629 {
2630 namespace Fault
2631 {
2632 namespace _PowerSequencerPGOODFault
2633 {
2634 
2635 struct INPUT_NUM
2636 {
2637     /*
2638      * We can't use -fsanitize=undefined if we declare a
2639      * 'static constexpr auto str' member, so don't. Instead, open-code the
2640      * mako template lookups.
2641      */
2642     static constexpr auto str_short = "INPUT_NUM";
2643     using type = std::tuple<std::decay_t<decltype("INPUT_NUM=%d")>, uint16_t>;
2644     explicit constexpr INPUT_NUM(uint16_t a) :
2645         _entry(entry("INPUT_NUM=%d", a)){};
2646     type _entry;
2647 };
2648 struct INPUT_NAME
2649 {
2650     /*
2651      * We can't use -fsanitize=undefined if we declare a
2652      * 'static constexpr auto str' member, so don't. Instead, open-code the
2653      * mako template lookups.
2654      */
2655     static constexpr auto str_short = "INPUT_NAME";
2656     using type =
2657         std::tuple<std::decay_t<decltype("INPUT_NAME=%s")>, const char*>;
2658     explicit constexpr INPUT_NAME(const char* a) :
2659         _entry(entry("INPUT_NAME=%s", a)){};
2660     type _entry;
2661 };
2662 struct RAW_STATUS
2663 {
2664     /*
2665      * We can't use -fsanitize=undefined if we declare a
2666      * 'static constexpr auto str' member, so don't. Instead, open-code the
2667      * mako template lookups.
2668      */
2669     static constexpr auto str_short = "RAW_STATUS";
2670     using type =
2671         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
2672     explicit constexpr RAW_STATUS(const char* a) :
2673         _entry(entry("RAW_STATUS=%s", a)){};
2674     type _entry;
2675 };
2676 
2677 } // namespace _PowerSequencerPGOODFault
2678 
2679 struct PowerSequencerPGOODFault
2680 {
2681     static constexpr auto L = level::ERR;
2682     using INPUT_NUM = _PowerSequencerPGOODFault::INPUT_NUM;
2683     using INPUT_NAME = _PowerSequencerPGOODFault::INPUT_NAME;
2684     using RAW_STATUS = _PowerSequencerPGOODFault::RAW_STATUS;
2685     using metadata_types = std::tuple<INPUT_NUM, INPUT_NAME, RAW_STATUS>;
2686 };
2687 
2688 } // namespace Fault
2689 } // namespace Witherspoon
2690 } // namespace open_power
2691 } // namespace org
2692 
2693 namespace details
2694 {
2695 
2696 template <>
2697 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
2698                               Error::PowerSequencerPGOODFault>
2699 {
2700     using type = org::open_power::Witherspoon::Fault::PowerSequencerPGOODFault;
2701 };
2702 
2703 } // namespace details
2704 
2705 namespace org
2706 {
2707 namespace open_power
2708 {
2709 namespace Witherspoon
2710 {
2711 namespace Fault
2712 {
2713 namespace _PowerSequencerFault
2714 {
2715 
2716 struct RAW_STATUS
2717 {
2718     /*
2719      * We can't use -fsanitize=undefined if we declare a
2720      * 'static constexpr auto str' member, so don't. Instead, open-code the
2721      * mako template lookups.
2722      */
2723     static constexpr auto str_short = "RAW_STATUS";
2724     using type =
2725         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
2726     explicit constexpr RAW_STATUS(const char* a) :
2727         _entry(entry("RAW_STATUS=%s", a)){};
2728     type _entry;
2729 };
2730 
2731 } // namespace _PowerSequencerFault
2732 
2733 struct PowerSequencerFault
2734 {
2735     static constexpr auto L = level::ERR;
2736     using RAW_STATUS = _PowerSequencerFault::RAW_STATUS;
2737     using metadata_types = std::tuple<RAW_STATUS>;
2738 };
2739 
2740 } // namespace Fault
2741 } // namespace Witherspoon
2742 } // namespace open_power
2743 } // namespace org
2744 
2745 namespace details
2746 {
2747 
2748 template <>
2749 struct map_exception_type<
2750     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSequencerFault>
2751 {
2752     using type = org::open_power::Witherspoon::Fault::PowerSequencerFault;
2753 };
2754 
2755 } // namespace details
2756 
2757 namespace xyz
2758 {
2759 namespace openbmc_project
2760 {
2761 namespace Common
2762 {
2763 namespace Callout
2764 {
2765 namespace _Device
2766 {
2767 
2768 struct CALLOUT_ERRNO
2769 {
2770     /*
2771      * We can't use -fsanitize=undefined if we declare a
2772      * 'static constexpr auto str' member, so don't. Instead, open-code the
2773      * mako template lookups.
2774      */
2775     static constexpr auto str_short = "CALLOUT_ERRNO";
2776     using type =
2777         std::tuple<std::decay_t<decltype("CALLOUT_ERRNO=%d")>, int32_t>;
2778     explicit constexpr CALLOUT_ERRNO(int32_t a) :
2779         _entry(entry("CALLOUT_ERRNO=%d", a)){};
2780     type _entry;
2781 };
2782 struct CALLOUT_DEVICE_PATH
2783 {
2784     /*
2785      * We can't use -fsanitize=undefined if we declare a
2786      * 'static constexpr auto str' member, so don't. Instead, open-code the
2787      * mako template lookups.
2788      */
2789     static constexpr auto str_short = "CALLOUT_DEVICE_PATH";
2790     using type = std::tuple<std::decay_t<decltype("CALLOUT_DEVICE_PATH=%s")>,
2791                             const char*>;
2792     explicit constexpr CALLOUT_DEVICE_PATH(const char* a) :
2793         _entry(entry("CALLOUT_DEVICE_PATH=%s", a)){};
2794     type _entry;
2795 };
2796 
2797 } // namespace _Device
2798 
2799 struct Device
2800 {
2801     static constexpr auto L = level::ERR;
2802     using CALLOUT_ERRNO = _Device::CALLOUT_ERRNO;
2803     using CALLOUT_DEVICE_PATH = _Device::CALLOUT_DEVICE_PATH;
2804     using metadata_types = std::tuple<CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
2805 };
2806 
2807 } // namespace Callout
2808 } // namespace Common
2809 } // namespace openbmc_project
2810 } // namespace xyz
2811 
2812 namespace details
2813 {
2814 
2815 template <>
2816 struct map_exception_type<
2817     sdbusplus::xyz::openbmc_project::Common::Callout::Error::Device>
2818 {
2819     using type = xyz::openbmc_project::Common::Callout::Device;
2820 };
2821 
2822 } // namespace details
2823 
2824 namespace xyz
2825 {
2826 namespace openbmc_project
2827 {
2828 namespace Common
2829 {
2830 namespace Callout
2831 {
2832 namespace _GPIO
2833 {
2834 
2835 struct CALLOUT_GPIO_NUM
2836 {
2837     /*
2838      * We can't use -fsanitize=undefined if we declare a
2839      * 'static constexpr auto str' member, so don't. Instead, open-code the
2840      * mako template lookups.
2841      */
2842     static constexpr auto str_short = "CALLOUT_GPIO_NUM";
2843     using type =
2844         std::tuple<std::decay_t<decltype("CALLOUT_GPIO_NUM=%u")>, uint32_t>;
2845     explicit constexpr CALLOUT_GPIO_NUM(uint32_t a) :
2846         _entry(entry("CALLOUT_GPIO_NUM=%u", a)){};
2847     type _entry;
2848 };
2849 
2850 } // namespace _GPIO
2851 
2852 struct GPIO
2853 {
2854     static constexpr auto L = level::ERR;
2855     using CALLOUT_GPIO_NUM = _GPIO::CALLOUT_GPIO_NUM;
2856     using CALLOUT_ERRNO =
2857         xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO;
2858     using CALLOUT_DEVICE_PATH =
2859         xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH;
2860     using metadata_types =
2861         std::tuple<CALLOUT_GPIO_NUM, CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
2862 };
2863 
2864 } // namespace Callout
2865 } // namespace Common
2866 } // namespace openbmc_project
2867 } // namespace xyz
2868 
2869 namespace details
2870 {
2871 
2872 template <>
2873 struct map_exception_type<
2874     sdbusplus::xyz::openbmc_project::Common::Callout::Error::GPIO>
2875 {
2876     using type = xyz::openbmc_project::Common::Callout::GPIO;
2877 };
2878 
2879 } // namespace details
2880 
2881 namespace xyz
2882 {
2883 namespace openbmc_project
2884 {
2885 namespace Common
2886 {
2887 namespace Callout
2888 {
2889 namespace _IIC
2890 {
2891 
2892 struct CALLOUT_IIC_BUS
2893 {
2894     /*
2895      * We can't use -fsanitize=undefined if we declare a
2896      * 'static constexpr auto str' member, so don't. Instead, open-code the
2897      * mako template lookups.
2898      */
2899     static constexpr auto str_short = "CALLOUT_IIC_BUS";
2900     using type =
2901         std::tuple<std::decay_t<decltype("CALLOUT_IIC_BUS=%s")>, const char*>;
2902     explicit constexpr CALLOUT_IIC_BUS(const char* a) :
2903         _entry(entry("CALLOUT_IIC_BUS=%s", a)){};
2904     type _entry;
2905 };
2906 struct CALLOUT_IIC_ADDR
2907 {
2908     /*
2909      * We can't use -fsanitize=undefined if we declare a
2910      * 'static constexpr auto str' member, so don't. Instead, open-code the
2911      * mako template lookups.
2912      */
2913     static constexpr auto str_short = "CALLOUT_IIC_ADDR";
2914     using type =
2915         std::tuple<std::decay_t<decltype("CALLOUT_IIC_ADDR=0x%hx")>, uint16_t>;
2916     explicit constexpr CALLOUT_IIC_ADDR(uint16_t a) :
2917         _entry(entry("CALLOUT_IIC_ADDR=0x%hx", a)){};
2918     type _entry;
2919 };
2920 
2921 } // namespace _IIC
2922 
2923 struct IIC
2924 {
2925     static constexpr auto L = level::ERR;
2926     using CALLOUT_IIC_BUS = _IIC::CALLOUT_IIC_BUS;
2927     using CALLOUT_IIC_ADDR = _IIC::CALLOUT_IIC_ADDR;
2928     using CALLOUT_ERRNO =
2929         xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO;
2930     using CALLOUT_DEVICE_PATH =
2931         xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH;
2932     using metadata_types = std::tuple<CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR,
2933                                       CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
2934 };
2935 
2936 } // namespace Callout
2937 } // namespace Common
2938 } // namespace openbmc_project
2939 } // namespace xyz
2940 
2941 namespace details
2942 {
2943 
2944 template <>
2945 struct map_exception_type<
2946     sdbusplus::xyz::openbmc_project::Common::Callout::Error::IIC>
2947 {
2948     using type = xyz::openbmc_project::Common::Callout::IIC;
2949 };
2950 
2951 } // namespace details
2952 
2953 namespace xyz
2954 {
2955 namespace openbmc_project
2956 {
2957 namespace Common
2958 {
2959 namespace Callout
2960 {
2961 namespace _Inventory
2962 {
2963 
2964 struct CALLOUT_INVENTORY_PATH
2965 {
2966     /*
2967      * We can't use -fsanitize=undefined if we declare a
2968      * 'static constexpr auto str' member, so don't. Instead, open-code the
2969      * mako template lookups.
2970      */
2971     static constexpr auto str_short = "CALLOUT_INVENTORY_PATH";
2972     using type = std::tuple<std::decay_t<decltype("CALLOUT_INVENTORY_PATH=%s")>,
2973                             const char*>;
2974     explicit constexpr CALLOUT_INVENTORY_PATH(const char* a) :
2975         _entry(entry("CALLOUT_INVENTORY_PATH=%s", a)){};
2976     type _entry;
2977 };
2978 
2979 } // namespace _Inventory
2980 
2981 struct Inventory
2982 {
2983     static constexpr auto L = level::ERR;
2984     using CALLOUT_INVENTORY_PATH = _Inventory::CALLOUT_INVENTORY_PATH;
2985     using metadata_types = std::tuple<CALLOUT_INVENTORY_PATH>;
2986 };
2987 
2988 } // namespace Callout
2989 } // namespace Common
2990 } // namespace openbmc_project
2991 } // namespace xyz
2992 
2993 namespace details
2994 {
2995 
2996 template <>
2997 struct map_exception_type<
2998     sdbusplus::xyz::openbmc_project::Common::Callout::Error::Inventory>
2999 {
3000     using type = xyz::openbmc_project::Common::Callout::Inventory;
3001 };
3002 
3003 } // namespace details
3004 
3005 namespace xyz
3006 {
3007 namespace openbmc_project
3008 {
3009 namespace Common
3010 {
3011 namespace Callout
3012 {
3013 namespace _IPMISensor
3014 {
3015 
3016 struct CALLOUT_IPMI_SENSOR_NUM
3017 {
3018     /*
3019      * We can't use -fsanitize=undefined if we declare a
3020      * 'static constexpr auto str' member, so don't. Instead, open-code the
3021      * mako template lookups.
3022      */
3023     static constexpr auto str_short = "CALLOUT_IPMI_SENSOR_NUM";
3024     using type =
3025         std::tuple<std::decay_t<decltype("CALLOUT_IPMI_SENSOR_NUM=%u")>,
3026                    uint32_t>;
3027     explicit constexpr CALLOUT_IPMI_SENSOR_NUM(uint32_t a) :
3028         _entry(entry("CALLOUT_IPMI_SENSOR_NUM=%u", a)){};
3029     type _entry;
3030 };
3031 
3032 } // namespace _IPMISensor
3033 
3034 struct IPMISensor
3035 {
3036     static constexpr auto L = level::ERR;
3037     using CALLOUT_IPMI_SENSOR_NUM = _IPMISensor::CALLOUT_IPMI_SENSOR_NUM;
3038     using metadata_types = std::tuple<CALLOUT_IPMI_SENSOR_NUM>;
3039 };
3040 
3041 } // namespace Callout
3042 } // namespace Common
3043 } // namespace openbmc_project
3044 } // namespace xyz
3045 
3046 namespace details
3047 {
3048 
3049 template <>
3050 struct map_exception_type<
3051     sdbusplus::xyz::openbmc_project::Common::Callout::Error::IPMISensor>
3052 {
3053     using type = xyz::openbmc_project::Common::Callout::IPMISensor;
3054 };
3055 
3056 } // namespace details
3057 
3058 namespace org
3059 {
3060 namespace open_power
3061 {
3062 namespace Witherspoon
3063 {
3064 namespace Fault
3065 {
3066 namespace _PowerSupplyInputFault
3067 {
3068 
3069 struct RAW_STATUS
3070 {
3071     /*
3072      * We can't use -fsanitize=undefined if we declare a
3073      * 'static constexpr auto str' member, so don't. Instead, open-code the
3074      * mako template lookups.
3075      */
3076     static constexpr auto str_short = "RAW_STATUS";
3077     using type =
3078         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3079     explicit constexpr RAW_STATUS(const char* a) :
3080         _entry(entry("RAW_STATUS=%s", a)){};
3081     type _entry;
3082 };
3083 
3084 } // namespace _PowerSupplyInputFault
3085 
3086 struct PowerSupplyInputFault
3087 {
3088     static constexpr auto L = level::ERR;
3089     using RAW_STATUS = _PowerSupplyInputFault::RAW_STATUS;
3090     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3091         Inventory::CALLOUT_INVENTORY_PATH;
3092     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3093 };
3094 
3095 } // namespace Fault
3096 } // namespace Witherspoon
3097 } // namespace open_power
3098 } // namespace org
3099 
3100 namespace details
3101 {
3102 
3103 template <>
3104 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3105                               Error::PowerSupplyInputFault>
3106 {
3107     using type = org::open_power::Witherspoon::Fault::PowerSupplyInputFault;
3108 };
3109 
3110 } // namespace details
3111 
3112 namespace org
3113 {
3114 namespace open_power
3115 {
3116 namespace Witherspoon
3117 {
3118 namespace Fault
3119 {
3120 namespace _PowerSupplyShouldBeOn
3121 {
3122 
3123 struct RAW_STATUS
3124 {
3125     /*
3126      * We can't use -fsanitize=undefined if we declare a
3127      * 'static constexpr auto str' member, so don't. Instead, open-code the
3128      * mako template lookups.
3129      */
3130     static constexpr auto str_short = "RAW_STATUS";
3131     using type =
3132         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3133     explicit constexpr RAW_STATUS(const char* a) :
3134         _entry(entry("RAW_STATUS=%s", a)){};
3135     type _entry;
3136 };
3137 
3138 } // namespace _PowerSupplyShouldBeOn
3139 
3140 struct PowerSupplyShouldBeOn
3141 {
3142     static constexpr auto L = level::ERR;
3143     using RAW_STATUS = _PowerSupplyShouldBeOn::RAW_STATUS;
3144     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3145         Inventory::CALLOUT_INVENTORY_PATH;
3146     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3147 };
3148 
3149 } // namespace Fault
3150 } // namespace Witherspoon
3151 } // namespace open_power
3152 } // namespace org
3153 
3154 namespace details
3155 {
3156 
3157 template <>
3158 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3159                               Error::PowerSupplyShouldBeOn>
3160 {
3161     using type = org::open_power::Witherspoon::Fault::PowerSupplyShouldBeOn;
3162 };
3163 
3164 } // namespace details
3165 
3166 namespace org
3167 {
3168 namespace open_power
3169 {
3170 namespace Witherspoon
3171 {
3172 namespace Fault
3173 {
3174 namespace _PowerSupplyOutputOvercurrent
3175 {
3176 
3177 struct RAW_STATUS
3178 {
3179     /*
3180      * We can't use -fsanitize=undefined if we declare a
3181      * 'static constexpr auto str' member, so don't. Instead, open-code the
3182      * mako template lookups.
3183      */
3184     static constexpr auto str_short = "RAW_STATUS";
3185     using type =
3186         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3187     explicit constexpr RAW_STATUS(const char* a) :
3188         _entry(entry("RAW_STATUS=%s", a)){};
3189     type _entry;
3190 };
3191 
3192 } // namespace _PowerSupplyOutputOvercurrent
3193 
3194 struct PowerSupplyOutputOvercurrent
3195 {
3196     static constexpr auto L = level::ERR;
3197     using RAW_STATUS = _PowerSupplyOutputOvercurrent::RAW_STATUS;
3198     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3199         Inventory::CALLOUT_INVENTORY_PATH;
3200     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3201 };
3202 
3203 } // namespace Fault
3204 } // namespace Witherspoon
3205 } // namespace open_power
3206 } // namespace org
3207 
3208 namespace details
3209 {
3210 
3211 template <>
3212 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3213                               Error::PowerSupplyOutputOvercurrent>
3214 {
3215     using type =
3216         org::open_power::Witherspoon::Fault::PowerSupplyOutputOvercurrent;
3217 };
3218 
3219 } // namespace details
3220 
3221 namespace org
3222 {
3223 namespace open_power
3224 {
3225 namespace Witherspoon
3226 {
3227 namespace Fault
3228 {
3229 namespace _PowerSupplyOutputOvervoltage
3230 {
3231 
3232 struct RAW_STATUS
3233 {
3234     /*
3235      * We can't use -fsanitize=undefined if we declare a
3236      * 'static constexpr auto str' member, so don't. Instead, open-code the
3237      * mako template lookups.
3238      */
3239     static constexpr auto str_short = "RAW_STATUS";
3240     using type =
3241         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3242     explicit constexpr RAW_STATUS(const char* a) :
3243         _entry(entry("RAW_STATUS=%s", a)){};
3244     type _entry;
3245 };
3246 
3247 } // namespace _PowerSupplyOutputOvervoltage
3248 
3249 struct PowerSupplyOutputOvervoltage
3250 {
3251     static constexpr auto L = level::ERR;
3252     using RAW_STATUS = _PowerSupplyOutputOvervoltage::RAW_STATUS;
3253     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3254         Inventory::CALLOUT_INVENTORY_PATH;
3255     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3256 };
3257 
3258 } // namespace Fault
3259 } // namespace Witherspoon
3260 } // namespace open_power
3261 } // namespace org
3262 
3263 namespace details
3264 {
3265 
3266 template <>
3267 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3268                               Error::PowerSupplyOutputOvervoltage>
3269 {
3270     using type =
3271         org::open_power::Witherspoon::Fault::PowerSupplyOutputOvervoltage;
3272 };
3273 
3274 } // namespace details
3275 
3276 namespace org
3277 {
3278 namespace open_power
3279 {
3280 namespace Witherspoon
3281 {
3282 namespace Fault
3283 {
3284 namespace _PowerSupplyFanFault
3285 {
3286 
3287 struct RAW_STATUS
3288 {
3289     /*
3290      * We can't use -fsanitize=undefined if we declare a
3291      * 'static constexpr auto str' member, so don't. Instead, open-code the
3292      * mako template lookups.
3293      */
3294     static constexpr auto str_short = "RAW_STATUS";
3295     using type =
3296         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3297     explicit constexpr RAW_STATUS(const char* a) :
3298         _entry(entry("RAW_STATUS=%s", a)){};
3299     type _entry;
3300 };
3301 
3302 } // namespace _PowerSupplyFanFault
3303 
3304 struct PowerSupplyFanFault
3305 {
3306     static constexpr auto L = level::ERR;
3307     using RAW_STATUS = _PowerSupplyFanFault::RAW_STATUS;
3308     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3309         Inventory::CALLOUT_INVENTORY_PATH;
3310     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3311 };
3312 
3313 } // namespace Fault
3314 } // namespace Witherspoon
3315 } // namespace open_power
3316 } // namespace org
3317 
3318 namespace details
3319 {
3320 
3321 template <>
3322 struct map_exception_type<
3323     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSupplyFanFault>
3324 {
3325     using type = org::open_power::Witherspoon::Fault::PowerSupplyFanFault;
3326 };
3327 
3328 } // namespace details
3329 
3330 namespace org
3331 {
3332 namespace open_power
3333 {
3334 namespace Witherspoon
3335 {
3336 namespace Fault
3337 {
3338 namespace _PowerSupplyTemperatureFault
3339 {
3340 
3341 struct RAW_STATUS
3342 {
3343     /*
3344      * We can't use -fsanitize=undefined if we declare a
3345      * 'static constexpr auto str' member, so don't. Instead, open-code the
3346      * mako template lookups.
3347      */
3348     static constexpr auto str_short = "RAW_STATUS";
3349     using type =
3350         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3351     explicit constexpr RAW_STATUS(const char* a) :
3352         _entry(entry("RAW_STATUS=%s", a)){};
3353     type _entry;
3354 };
3355 
3356 } // namespace _PowerSupplyTemperatureFault
3357 
3358 struct PowerSupplyTemperatureFault
3359 {
3360     static constexpr auto L = level::ERR;
3361     using RAW_STATUS = _PowerSupplyTemperatureFault::RAW_STATUS;
3362     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3363         Inventory::CALLOUT_INVENTORY_PATH;
3364     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3365 };
3366 
3367 } // namespace Fault
3368 } // namespace Witherspoon
3369 } // namespace open_power
3370 } // namespace org
3371 
3372 namespace details
3373 {
3374 
3375 template <>
3376 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
3377                               Error::PowerSupplyTemperatureFault>
3378 {
3379     using type =
3380         org::open_power::Witherspoon::Fault::PowerSupplyTemperatureFault;
3381 };
3382 
3383 } // namespace details
3384 
3385 namespace org
3386 {
3387 namespace open_power
3388 {
3389 namespace Witherspoon
3390 {
3391 namespace Fault
3392 {
3393 namespace _GPUPowerFault
3394 {
3395 
3396 struct RAW_STATUS
3397 {
3398     /*
3399      * We can't use -fsanitize=undefined if we declare a
3400      * 'static constexpr auto str' member, so don't. Instead, open-code the
3401      * mako template lookups.
3402      */
3403     static constexpr auto str_short = "RAW_STATUS";
3404     using type =
3405         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3406     explicit constexpr RAW_STATUS(const char* a) :
3407         _entry(entry("RAW_STATUS=%s", a)){};
3408     type _entry;
3409 };
3410 
3411 } // namespace _GPUPowerFault
3412 
3413 struct GPUPowerFault
3414 {
3415     static constexpr auto L = level::ERR;
3416     using RAW_STATUS = _GPUPowerFault::RAW_STATUS;
3417     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3418         Inventory::CALLOUT_INVENTORY_PATH;
3419     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3420 };
3421 
3422 } // namespace Fault
3423 } // namespace Witherspoon
3424 } // namespace open_power
3425 } // namespace org
3426 
3427 namespace details
3428 {
3429 
3430 template <>
3431 struct map_exception_type<
3432     sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUPowerFault>
3433 {
3434     using type = org::open_power::Witherspoon::Fault::GPUPowerFault;
3435 };
3436 
3437 } // namespace details
3438 
3439 namespace org
3440 {
3441 namespace open_power
3442 {
3443 namespace Witherspoon
3444 {
3445 namespace Fault
3446 {
3447 namespace _GPUOverTemp
3448 {
3449 
3450 struct RAW_STATUS
3451 {
3452     /*
3453      * We can't use -fsanitize=undefined if we declare a
3454      * 'static constexpr auto str' member, so don't. Instead, open-code the
3455      * mako template lookups.
3456      */
3457     static constexpr auto str_short = "RAW_STATUS";
3458     using type =
3459         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3460     explicit constexpr RAW_STATUS(const char* a) :
3461         _entry(entry("RAW_STATUS=%s", a)){};
3462     type _entry;
3463 };
3464 
3465 } // namespace _GPUOverTemp
3466 
3467 struct GPUOverTemp
3468 {
3469     static constexpr auto L = level::ERR;
3470     using RAW_STATUS = _GPUOverTemp::RAW_STATUS;
3471     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3472         Inventory::CALLOUT_INVENTORY_PATH;
3473     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3474 };
3475 
3476 } // namespace Fault
3477 } // namespace Witherspoon
3478 } // namespace open_power
3479 } // namespace org
3480 
3481 namespace details
3482 {
3483 
3484 template <>
3485 struct map_exception_type<
3486     sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUOverTemp>
3487 {
3488     using type = org::open_power::Witherspoon::Fault::GPUOverTemp;
3489 };
3490 
3491 } // namespace details
3492 
3493 namespace org
3494 {
3495 namespace open_power
3496 {
3497 namespace Witherspoon
3498 {
3499 namespace Fault
3500 {
3501 namespace _MemoryPowerFault
3502 {
3503 
3504 struct RAW_STATUS
3505 {
3506     /*
3507      * We can't use -fsanitize=undefined if we declare a
3508      * 'static constexpr auto str' member, so don't. Instead, open-code the
3509      * mako template lookups.
3510      */
3511     static constexpr auto str_short = "RAW_STATUS";
3512     using type =
3513         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
3514     explicit constexpr RAW_STATUS(const char* a) :
3515         _entry(entry("RAW_STATUS=%s", a)){};
3516     type _entry;
3517 };
3518 
3519 } // namespace _MemoryPowerFault
3520 
3521 struct MemoryPowerFault
3522 {
3523     static constexpr auto L = level::ERR;
3524     using RAW_STATUS = _MemoryPowerFault::RAW_STATUS;
3525     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
3526         Inventory::CALLOUT_INVENTORY_PATH;
3527     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
3528 };
3529 
3530 } // namespace Fault
3531 } // namespace Witherspoon
3532 } // namespace open_power
3533 } // namespace org
3534 
3535 namespace details
3536 {
3537 
3538 template <>
3539 struct map_exception_type<
3540     sdbusplus::org::open_power::Witherspoon::Fault::Error::MemoryPowerFault>
3541 {
3542     using type = org::open_power::Witherspoon::Fault::MemoryPowerFault;
3543 };
3544 
3545 } // namespace details
3546 
3547 } // namespace logging
3548 
3549 } // namespace phosphor
3550