ondc-code-generator 0.0.1

package/generated/L1-validations/api-tests/on_search.ts

@@ -0,0 +1,1574 @@
+import payloadUtils from "../utils/json-path-utils";
+import validations from "../utils/validation-utils";
+import {
+    testFunctionArray,
+    validationInput,
+    validationOutput,
+} from "../types/test-config";
+
+export default function on_search(input: validationInput): validationOutput {
+    const scope = payloadUtils.getJsonPath(input.payload, "$");
+    let subResults: validationOutput = [];
+    let valid = true;
+    for (const testObj of scope) {
+        testObj._EXTERNAL = input.externalData;
+
+        function Attri_Required_1_CONTEXT_TIMESTAMP(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.timestamp",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_1_CONTEXT_TIMESTAMP**: $.context.timestamp must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_2_CONTEXT_BAP_ID(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.bap_id",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_2_CONTEXT_BAP_ID**: $.context.bap_id must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_3_CONTEXT_TRANSACTION_ID(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.transaction_id",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_3_CONTEXT_TRANSACTION_ID**: $.context.transaction_id must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_4_CONTEXT_MESSAGE_ID(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.message_id",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_4_CONTEXT_MESSAGE_ID**: $.context.message_id must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_5_CONTEXT_VERSION(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.version",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_5_CONTEXT_VERSION**: $.context.version must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_6_CONTEXT_BAP_URI(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.bap_uri",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_6_CONTEXT_BAP_URI**: $.context.bap_uri must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_7_CONTEXT_TTL(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(testObj, "$.context.ttl");
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_7_CONTEXT_TTL**: $.context.ttl must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_8_CONTEXT_BPP_ID(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.bpp_id",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_8_CONTEXT_BPP_ID**: $.context.bpp_id must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Attri_Required_9_CONTEXT_BPP_URI(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const attr = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.bpp_uri",
+                );
+
+                const validate = validations.arePresent(attr);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Attri_Required_9_CONTEXT_BPP_URI**: $.context.bpp_uri must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Enum_Required_19_CONTEXT_ACTION(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const enumList = ["on_search"];
+                const enumPath = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.action",
+                );
+
+                const validate =
+                    validations.allIn(enumPath, enumList) &&
+                    validations.arePresent(enumPath);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Enum_Required_19_CONTEXT_ACTION**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_19_CONTEXT_ACTION.1**: every element of $.context.action must be in ["on_search"]
+  - **condition Enum_Required_19_CONTEXT_ACTION.2**: $.context.action must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Enum_Required_20_COUNTRY_CODE(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const enumList = ["IND"];
+                const enumPath = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.location.country.code",
+                );
+
+                const validate =
+                    validations.allIn(enumPath, enumList) &&
+                    validations.arePresent(enumPath);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Enum_Required_20_COUNTRY_CODE**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_20_COUNTRY_CODE.1**: every element of $.context.location.country.code must be in ["IND"]
+  - **condition Enum_Required_20_COUNTRY_CODE.2**: $.context.location.country.code must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Enum_Required_21_CITY_CODE(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const enumPath = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.location.city.code",
+                );
+
+                const validate = validations.arePresent(enumPath);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Enum_Required_21_CITY_CODE**: $.context.location.city.code must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function Enum_Required_22_CONTEXT_DOMAIN(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const enumList = ["ONDC:TRV11"];
+                const enumPath = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.context.domain",
+                );
+
+                const validate =
+                    validations.allIn(enumPath, enumList) &&
+                    validations.arePresent(enumPath);
+
+                if (!validate) {
+                    return [
+                        {
+                            valid: false,
+                            code: 30000,
+                            description: `- **condition Enum_Required_22_CONTEXT_DOMAIN**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_22_CONTEXT_DOMAIN.1**: every element of $.context.domain must be in ["ONDC:TRV11"]
+  - **condition Enum_Required_22_CONTEXT_DOMAIN.2**: $.context.domain must be present in the payload`,
+                        },
+                    ];
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+        function on_search_Message_TESTS(
+            input: validationInput,
+        ): validationOutput {
+            const scope = payloadUtils.getJsonPath(input.payload, "$");
+            let subResults: validationOutput = [];
+            let valid = true;
+            for (const testObj of scope) {
+                testObj._EXTERNAL = input.externalData;
+                const errorBlock = payloadUtils.getJsonPath(
+                    testObj,
+                    "$.error.code",
+                );
+
+                const skipCheck = validations.arePresent(errorBlock);
+                if (skipCheck) continue;
+
+                function Attri_Required_10_DESCRIPTOR_NAME(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.descriptor.name",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_10_DESCRIPTOR_NAME**: $.message.catalog.descriptor.name must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_11_PROVIDERS_ID(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].id",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_11_PROVIDERS_ID**: $.message.catalog.providers[*].id must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_12_DESCRIPTOR_NAME(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].descriptor.name",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_12_DESCRIPTOR_NAME**: $.message.catalog.providers[*].descriptor.name must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_13_FULFILLMENTS_ID(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].id",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_13_FULFILLMENTS_ID**: $.message.catalog.providers[*].fulfillments[*].id must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_14_LOCATION_GPS(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].stops[*].location.gps",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_14_LOCATION_GPS**: $.message.catalog.providers[*].fulfillments[*].stops[*].location.gps must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_15_FULFILLMENTS_ID(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].id",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_15_FULFILLMENTS_ID**: $.message.catalog.providers[*].fulfillments[*].id must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_16_CATEGORIES_ID(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].categories[*].id",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_16_CATEGORIES_ID**: $.message.catalog.providers[*].categories[*].id must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_17_RANGE_START(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].time.range.start",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_17_RANGE_START**: $.message.catalog.providers[*].time.range.start must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Attri_Required_18_RANGE_END(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const attr = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].time.range.end",
+                        );
+
+                        const validate = validations.arePresent(attr);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Attri_Required_18_RANGE_END**: $.message.catalog.providers[*].time.range.end must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_23_DESCRIPTOR_CODE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["TICKET", "PASS"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].categories[*].descriptor.code",
+                        );
+
+                        const validate =
+                            validations.allIn(enumPath, enumList) &&
+                            validations.arePresent(enumPath);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_23_DESCRIPTOR_CODE**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_23_DESCRIPTOR_CODE.1**: every element of $.message.catalog.providers[*].categories[*].descriptor.code must be in ["TICKET", "PASS"]
+  - **condition Enum_Required_23_DESCRIPTOR_CODE.2**: $.message.catalog.providers[*].categories[*].descriptor.code must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_24_DESCRIPTOR_CODE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["SJT", "SFSJT", "RJT", "PASS"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].descriptor.code",
+                        );
+
+                        const skipCheck = !validations.arePresent(enumPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(enumPath, enumList);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_24_DESCRIPTOR_CODE**: every element of $.message.catalog.providers[*].descriptor.code must be in ["SJT", "SFSJT", "RJT", "PASS"]
+
+	> Note: **Condition Enum_Required_24_DESCRIPTOR_CODE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].descriptor.code must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_25_VEHICLE_CATEGORY(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["BUS", "METRO"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].vehicle.category",
+                        );
+
+                        const validate =
+                            validations.allIn(enumPath, enumList) &&
+                            validations.arePresent(enumPath);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_25_VEHICLE_CATEGORY**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_25_VEHICLE_CATEGORY.1**: every element of $.message.catalog.providers[*].fulfillments[*].vehicle.category must be in ["BUS", "METRO"]
+  - **condition Enum_Required_25_VEHICLE_CATEGORY.2**: $.message.catalog.providers[*].fulfillments[*].vehicle.category must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_26_FULFILLMENTS_TYPE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["ROUTE", "TRIP"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].type",
+                        );
+
+                        const validate =
+                            validations.allIn(enumPath, enumList) &&
+                            validations.arePresent(enumPath);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_26_FULFILLMENTS_TYPE**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_26_FULFILLMENTS_TYPE.1**: every element of $.message.catalog.providers[*].fulfillments[*].type must be in ["ROUTE", "TRIP"]
+  - **condition Enum_Required_26_FULFILLMENTS_TYPE.2**: $.message.catalog.providers[*].fulfillments[*].type must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_27_FULFILLMENTS_TYPE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = [
+                            "START",
+                            "END",
+                            "INTERMEDIATE_STOP",
+                            "TRANSIT_STOP",
+                        ];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].type",
+                        );
+
+                        const skipCheck = !validations.arePresent(enumPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(enumPath, enumList);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_27_FULFILLMENTS_TYPE**: every element of $.message.catalog.providers[*].fulfillments[*].type must be in ["START", "END", "INTERMEDIATE_STOP", "TRANSIT_STOP"]
+
+	> Note: **Condition Enum_Required_27_FULFILLMENTS_TYPE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].fulfillments[*].type must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_28_AUTHORIZATION_TYPE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["QR"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].stops[*].authorization.type",
+                        );
+
+                        const skipCheck = !validations.arePresent(enumPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(enumPath, enumList);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_28_AUTHORIZATION_TYPE**: every element of $.message.catalog.providers[*].fulfillments[*].stops[*].authorization.type must be in ["QR"]
+
+	> Note: **Condition Enum_Required_28_AUTHORIZATION_TYPE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].fulfillments[*].stops[*].authorization.type must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_29_AUTHORIZATION_STATUS(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["UNCLAIMED", "CLAIMED"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].stops[*].authorization.status",
+                        );
+
+                        const skipCheck = !validations.arePresent(enumPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(enumPath, enumList);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_29_AUTHORIZATION_STATUS**: every element of $.message.catalog.providers[*].fulfillments[*].stops[*].authorization.status must be in ["UNCLAIMED", "CLAIMED"]
+
+	> Note: **Condition Enum_Required_29_AUTHORIZATION_STATUS** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].fulfillments[*].stops[*].authorization.status must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_30_PAYMENTS_STATUS(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["NOT-PAID", "PAID"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].payments[*].status",
+                        );
+
+                        const skipCheck = !validations.arePresent(enumPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(enumPath, enumList);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_30_PAYMENTS_STATUS**: every element of $.message.catalog.providers[*].payments[*].status must be in ["NOT-PAID", "PAID"]
+
+	> Note: **Condition Enum_Required_30_PAYMENTS_STATUS** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].payments[*].status must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_31_PAYMENTS_COLLECTED_BY(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = ["BPP", "BAP"];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].payments[*].collected_by",
+                        );
+
+                        const validate =
+                            validations.allIn(enumPath, enumList) &&
+                            validations.arePresent(enumPath);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_31_PAYMENTS_COLLECTED_BY**: all of the following sub conditions must be met:
+
+  - **condition Enum_Required_31_PAYMENTS_COLLECTED_BY.1**: every element of $.message.catalog.providers[*].payments[*].collected_by must be in ["BPP", "BAP"]
+  - **condition Enum_Required_31_PAYMENTS_COLLECTED_BY.2**: $.message.catalog.providers[*].payments[*].collected_by must be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function Enum_Required_32_PAYMENTS_TYPE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const enumList = [
+                            "PRE-ORDER",
+                            "ON-FULFILLMENT",
+                            "POST-FULFILLMENT",
+                        ];
+                        const enumPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].payments[*].type",
+                        );
+
+                        const skipCheck = !validations.arePresent(enumPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(enumPath, enumList);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition Enum_Required_32_PAYMENTS_TYPE**: every element of $.message.catalog.providers[*].payments[*].type must be in ["PRE-ORDER", "ON-FULFILLMENT", "POST-FULFILLMENT"]
+
+	> Note: **Condition Enum_Required_32_PAYMENTS_TYPE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].payments[*].type must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function FARE_POLICY_Tag_Required_33_DESCRIPTOR_CODE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const validTags = ["FARE_POLICY"];
+                        const tagPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].items[*].tags[*].descriptor.code",
+                        );
+
+                        const skipCheck = !validations.arePresent(tagPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(tagPath, validTags);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition FARE_POLICY_Tag_Required_33_DESCRIPTOR_CODE**: every element of $.message.catalog.providers[*].items[*].tags[*].descriptor.code must be in ["FARE_POLICY"]
+
+	> Note: **Condition FARE_POLICY_Tag_Required_33_DESCRIPTOR_CODE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].items[*].tags[*].descriptor.code must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_0_FARE_POLICY(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].items[*].tags[?(@.descriptor.code=='FARE_POLICY')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = [
+                            "RESTRICTED_PERSON",
+                            "RESTRICTION_PROOF",
+                        ];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_0_FARE_POLICY**: every element of $.message.catalog.providers[*].items[*].tags[?(@.descriptor.code=='FARE_POLICY')].list[*].descriptor.code must be in ["RESTRICTED_PERSON", "RESTRICTION_PROOF"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function ROUTE_INFO_Tag_Required_35_DESCRIPTOR_CODE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const validTags = [
+                            "ROUTE_INFO",
+                            "TICKET_INFO",
+                            "TRIP_DETAILS",
+                        ];
+                        const tagPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].fulfillments[*].tags[*].descriptor.code",
+                        );
+
+                        const skipCheck = !validations.arePresent(tagPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(tagPath, validTags);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition ROUTE_INFO_Tag_Required_35_DESCRIPTOR_CODE**: every element of $.message.catalog.providers[*].fulfillments[*].tags[*].descriptor.code must be in ["ROUTE_INFO", "TICKET_INFO", "TRIP_DETAILS"]
+
+	> Note: **Condition ROUTE_INFO_Tag_Required_35_DESCRIPTOR_CODE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].fulfillments[*].tags[*].descriptor.code must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_1_ROUTE_INFO(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].fulfillments[*].tags[?(@.descriptor.code=='ROUTE_INFO')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = ["ROUTE_ID", "ROUTE_DIRECTION"];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_1_ROUTE_INFO**: every element of $.message.catalog.providers[*].fulfillments[*].tags[?(@.descriptor.code=='ROUTE_INFO')].list[*].descriptor.code must be in ["ROUTE_ID", "ROUTE_DIRECTION"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_1_TICKET_INFO(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].fulfillments[*].tags[?(@.descriptor.code=='TICKET_INFO')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = ["NUMBER"];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_1_TICKET_INFO**: every element of $.message.catalog.providers[*].fulfillments[*].tags[?(@.descriptor.code=='TICKET_INFO')].list[*].descriptor.code must be in ["NUMBER"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_1_TRIP_DETAILS(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].fulfillments[*].tags[?(@.descriptor.code=='TRIP_DETAILS')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = [
+                            "AVAILABLE_TRIPS",
+                            "UTILIZED_TRIPS",
+                        ];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_1_TRIP_DETAILS**: every element of $.message.catalog.providers[*].fulfillments[*].tags[?(@.descriptor.code=='TRIP_DETAILS')].list[*].descriptor.code must be in ["AVAILABLE_TRIPS", "UTILIZED_TRIPS"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function BUYER_FINDER_FEES_Tag_Required_39_DESCRIPTOR_CODE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const validTags = [
+                            "BUYER_FINDER_FEES",
+                            "SETTLEMENT_TERMS",
+                        ];
+                        const tagPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].payments[*].tags[*].descriptor.code",
+                        );
+
+                        const skipCheck = !validations.arePresent(tagPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(tagPath, validTags);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition BUYER_FINDER_FEES_Tag_Required_39_DESCRIPTOR_CODE**: every element of $.message.catalog.providers[*].payments[*].tags[*].descriptor.code must be in ["BUYER_FINDER_FEES", "SETTLEMENT_TERMS"]
+
+	> Note: **Condition BUYER_FINDER_FEES_Tag_Required_39_DESCRIPTOR_CODE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].payments[*].tags[*].descriptor.code must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_2_BUYER_FINDER_FEES(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].payments[*].tags[?(@.descriptor.code=='BUYER_FINDER_FEES')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = [
+                            "BUYER_FINDER_FEES_TYPE",
+                            "BUYER_FINDER_FEES_PERCENTAGE",
+                            "BUYER_FINDER_FEES_AMOUNT",
+                        ];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_2_BUYER_FINDER_FEES**: every element of $.message.catalog.providers[*].payments[*].tags[?(@.descriptor.code=='BUYER_FINDER_FEES')].list[*].descriptor.code must be in ["BUYER_FINDER_FEES_TYPE", "BUYER_FINDER_FEES_PERCENTAGE", "BUYER_FINDER_FEES_AMOUNT"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_2_SETTLEMENT_TERMS(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].payments[*].tags[?(@.descriptor.code=='SETTLEMENT_TERMS')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = [
+                            "SETTLEMENT_WINDOW",
+                            "SETTLEMENT_BASIS",
+                            "SETTLEMENT_TYPE",
+                            "MANDATORY_ARBITRATION",
+                            "COURT_JURISDICTION",
+                            "DELAY_INTEREST",
+                            "STATIC_TERMS",
+                            "SETTLEMENT_AMOUNT",
+                        ];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_2_SETTLEMENT_TERMS**: every element of $.message.catalog.providers[*].payments[*].tags[?(@.descriptor.code=='SETTLEMENT_TERMS')].list[*].descriptor.code must be in ["SETTLEMENT_WINDOW", "SETTLEMENT_BASIS", "SETTLEMENT_TYPE", "MANDATORY_ARBITRATION", "COURT_JURISDICTION", "DELAY_INTEREST", "STATIC_TERMS", "SETTLEMENT_AMOUNT"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function SCHEDULED_INFO_Tag_Required_42_DESCRIPTOR_CODE(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(input.payload, "$");
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const validTags = ["SCHEDULED_INFO"];
+                        const tagPath = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.message.catalog.providers[*].tags[*].descriptor.code",
+                        );
+
+                        const skipCheck = !validations.arePresent(tagPath);
+                        if (skipCheck) continue;
+
+                        const validate = validations.allIn(tagPath, validTags);
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition SCHEDULED_INFO_Tag_Required_42_DESCRIPTOR_CODE**: every element of $.message.catalog.providers[*].tags[*].descriptor.code must be in ["SCHEDULED_INFO"]
+
+	> Note: **Condition SCHEDULED_INFO_Tag_Required_42_DESCRIPTOR_CODE** can be skipped if the following conditions are met:
+	>
+	> - **condition B**: $.message.catalog.providers[*].tags[*].descriptor.code must **not** be present in the payload`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+                function validate_tag_3_SCHEDULED_INFO(
+                    input: validationInput,
+                ): validationOutput {
+                    const scope = payloadUtils.getJsonPath(
+                        input.payload,
+                        "$.message.catalog.providers[*].tags[?(@.descriptor.code=='SCHEDULED_INFO')]",
+                    );
+                    let subResults: validationOutput = [];
+                    let valid = true;
+                    for (const testObj of scope) {
+                        testObj._EXTERNAL = input.externalData;
+                        const subTags = payloadUtils.getJsonPath(
+                            testObj,
+                            "$.list[*].descriptor.code",
+                        );
+                        const validValues = ["GTFS"];
+
+                        const validate = validations.allIn(
+                            subTags,
+                            validValues,
+                        );
+
+                        if (!validate) {
+                            return [
+                                {
+                                    valid: false,
+                                    code: 30000,
+                                    description: `- **condition validate_tag_3_SCHEDULED_INFO**: every element of $.message.catalog.providers[*].tags[?(@.descriptor.code=='SCHEDULED_INFO')].list[*].descriptor.code must be in ["GTFS"]`,
+                                },
+                            ];
+                        }
+
+                        delete testObj._EXTERNAL;
+                    }
+                    return [{ valid: valid, code: 200 }, ...subResults];
+                }
+
+                const testFunctions: testFunctionArray = [
+                    Attri_Required_10_DESCRIPTOR_NAME,
+                    Attri_Required_11_PROVIDERS_ID,
+                    Attri_Required_12_DESCRIPTOR_NAME,
+                    Attri_Required_13_FULFILLMENTS_ID,
+                    Attri_Required_14_LOCATION_GPS,
+                    Attri_Required_15_FULFILLMENTS_ID,
+                    Attri_Required_16_CATEGORIES_ID,
+                    Attri_Required_17_RANGE_START,
+                    Attri_Required_18_RANGE_END,
+                    Enum_Required_23_DESCRIPTOR_CODE,
+                    Enum_Required_24_DESCRIPTOR_CODE,
+                    Enum_Required_25_VEHICLE_CATEGORY,
+                    Enum_Required_26_FULFILLMENTS_TYPE,
+                    Enum_Required_27_FULFILLMENTS_TYPE,
+                    Enum_Required_28_AUTHORIZATION_TYPE,
+                    Enum_Required_29_AUTHORIZATION_STATUS,
+                    Enum_Required_30_PAYMENTS_STATUS,
+                    Enum_Required_31_PAYMENTS_COLLECTED_BY,
+                    Enum_Required_32_PAYMENTS_TYPE,
+                    FARE_POLICY_Tag_Required_33_DESCRIPTOR_CODE,
+                    validate_tag_0_FARE_POLICY,
+                    ROUTE_INFO_Tag_Required_35_DESCRIPTOR_CODE,
+                    validate_tag_1_ROUTE_INFO,
+                    validate_tag_1_TICKET_INFO,
+                    validate_tag_1_TRIP_DETAILS,
+                    BUYER_FINDER_FEES_Tag_Required_39_DESCRIPTOR_CODE,
+                    validate_tag_2_BUYER_FINDER_FEES,
+                    validate_tag_2_SETTLEMENT_TERMS,
+                    SCHEDULED_INFO_Tag_Required_42_DESCRIPTOR_CODE,
+                    validate_tag_3_SCHEDULED_INFO,
+                ];
+
+                let invalidResults: validationOutput = [];
+                for (const fn of testFunctions) {
+                    const subResult = fn(input);
+                    // .filter(r => !r.valid);
+                    invalidResults = [...invalidResults, ...subResult];
+                    if (
+                        !input.config.runAllValidations &&
+                        invalidResults.length > 0
+                    ) {
+                        return invalidResults;
+                    }
+                }
+                if (invalidResults.length > 0) {
+                    // return invalidResults;
+                    subResults = invalidResults;
+                    valid = subResults.every((r) => r.valid);
+                }
+
+                delete testObj._EXTERNAL;
+            }
+            return [{ valid: valid, code: 200 }, ...subResults];
+        }
+
+        const testFunctions: testFunctionArray = [
+            Attri_Required_1_CONTEXT_TIMESTAMP,
+            Attri_Required_2_CONTEXT_BAP_ID,
+            Attri_Required_3_CONTEXT_TRANSACTION_ID,
+            Attri_Required_4_CONTEXT_MESSAGE_ID,
+            Attri_Required_5_CONTEXT_VERSION,
+            Attri_Required_6_CONTEXT_BAP_URI,
+            Attri_Required_7_CONTEXT_TTL,
+            Attri_Required_8_CONTEXT_BPP_ID,
+            Attri_Required_9_CONTEXT_BPP_URI,
+            Enum_Required_19_CONTEXT_ACTION,
+            Enum_Required_20_COUNTRY_CODE,
+            Enum_Required_21_CITY_CODE,
+            Enum_Required_22_CONTEXT_DOMAIN,
+            on_search_Message_TESTS,
+        ];
+
+        let invalidResults: validationOutput = [];
+        for (const fn of testFunctions) {
+            const subResult = fn(input);
+            // .filter(r => !r.valid);
+            invalidResults = [...invalidResults, ...subResult];
+            if (!input.config.runAllValidations && invalidResults.length > 0) {
+                return invalidResults;
+            }
+        }
+        if (invalidResults.length > 0) {
+            // return invalidResults;
+            subResults = invalidResults;
+            valid = subResults.every((r) => r.valid);
+        }
+
+        delete testObj._EXTERNAL;
+    }
+    return [{ valid: valid, code: 200 }, ...subResults];
+}