@hew-lang/sandbox-vm 0.10.0-rc1 → 0.10.0

package/dist/interpreter/v1/package-validator.generated.js

@@ -4923,7 +4923,6 @@ const schema19 = {
         Supervisor: {
             description: "One demanded supervisor: its restart policy and the children it starts.",
             properties: {
-                backoff: { type: "boolean" },
                 children: { items: { $ref: "#/$defs/SupervisorChild" }, type: "array" },
                 id: {
                     format: "uint32",
@@ -4954,6 +4953,10 @@ const schema19 = {
         },
         SupervisorChild: {
             properties: {
+                backoff: {
+                    description: "Construction transfers this child's effective restart delay as an\n`(initial, maximum)` argument pair after the config, in declaration order.",
+                    type: "boolean",
+                },
                 dependencies: {
                     items: { format: "uint", minimum: 0, type: "integer" },
                     type: "array",
@@ -5822,15 +5825,25 @@ const schema19 = {
         TimerSendPolicy: { enum: ["reject", "drop_newest"], type: "string" },
         TimestampBinaryOp: { enum: ["Add", "Subtract"], type: "string" },
         TrapName: {
-            enum: [
-                "heap_exceeded",
-                "integer_overflow",
-                "divide_by_zero",
-                "shift_out_of_range",
-                "vector_bounds",
-                "actor_refused",
+            oneOf: [
+                {
+                    enum: [
+                        "heap_exceeded",
+                        "integer_overflow",
+                        "divide_by_zero",
+                        "signed_min_div_neg_one",
+                        "shift_out_of_range",
+                        "vector_bounds",
+                        "actor_refused",
+                    ],
+                    type: "string",
+                },
+                {
+                    const: "stack_overflow",
+                    description: "Raised by a function's entry safepoint when its activation is deeper\nthan the VM's frame limit, never named by an emitted package.",
+                    type: "string",
+                },
             ],
-            type: "string",
         },
         ValueCapabilityPlan: {
             description: "The checker's selection for one `(type, capability)` pair.\n\n`callable` names a user implementation; its absence is the derived\nstructural operation, which the VM performs over its own value\nrepresentation.",
@@ -6092,6 +6105,12 @@ const schema19 = {
                             minimum: 0,
                             type: "integer",
                         },
+                        CrashKindStackOverflow: {
+                            format: "uint32",
+                            maximum: 4294967295,
+                            minimum: 0,
+                            type: "integer",
+                        },
                         CrashKindTimerOverdue: {
                             format: "uint32",
                             maximum: 4294967295,
@@ -26648,15 +26667,25 @@ const schema51 = {
     type: "object",
 };
 const schema52 = {
-    enum: [
-        "heap_exceeded",
-        "integer_overflow",
-        "divide_by_zero",
-        "shift_out_of_range",
-        "vector_bounds",
-        "actor_refused",
+    oneOf: [
+        {
+            enum: [
+                "heap_exceeded",
+                "integer_overflow",
+                "divide_by_zero",
+                "signed_min_div_neg_one",
+                "shift_out_of_range",
+                "vector_bounds",
+                "actor_refused",
+            ],
+            type: "string",
+        },
+        {
+            const: "stack_overflow",
+            description: "Raised by a function's entry safepoint when its activation is deeper\nthan the VM's frame limit, never named by an emitted package.",
+            type: "string",
+        },
     ],
-    type: "string",
 };
 function validate129(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {}, } = {}) {
     let vErrors = null;
@@ -26668,35 +26697,126 @@ function validate129(data, { instancePath = "", parentData, parentDataProperty,
     if (evaluated0.dynamicItems) {
         evaluated0.items = undefined;
     }
+    const _errs0 = errors;
+    let valid0 = false;
+    let passing0 = null;
+    const _errs1 = errors;
     if (typeof data !== "string") {
-        validate129.errors = [
-            {
-                instancePath,
-                schemaPath: "#/type",
-                keyword: "type",
-                params: { type: "string" },
-                message: "must be string",
-            },
-        ];
-        return false;
+        const err0 = {
+            instancePath,
+            schemaPath: "#/oneOf/0/type",
+            keyword: "type",
+            params: { type: "string" },
+            message: "must be string",
+        };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
     }
     if (!(data === "heap_exceeded" ||
         data === "integer_overflow" ||
         data === "divide_by_zero" ||
+        data === "signed_min_div_neg_one" ||
         data === "shift_out_of_range" ||
         data === "vector_bounds" ||
         data === "actor_refused")) {
-        validate129.errors = [
-            {
-                instancePath,
-                schemaPath: "#/enum",
-                keyword: "enum",
-                params: { allowedValues: schema52.enum },
-                message: "must be equal to one of the allowed values",
-            },
-        ];
+        const err1 = {
+            instancePath,
+            schemaPath: "#/oneOf/0/enum",
+            keyword: "enum",
+            params: { allowedValues: schema52.oneOf[0].enum },
+            message: "must be equal to one of the allowed values",
+        };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    var _valid0 = _errs1 === errors;
+    if (_valid0) {
+        valid0 = true;
+        passing0 = 0;
+    }
+    const _errs3 = errors;
+    if (typeof data !== "string") {
+        const err2 = {
+            instancePath,
+            schemaPath: "#/oneOf/1/type",
+            keyword: "type",
+            params: { type: "string" },
+            message: "must be string",
+        };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    if ("stack_overflow" !== data) {
+        const err3 = {
+            instancePath,
+            schemaPath: "#/oneOf/1/const",
+            keyword: "const",
+            params: { allowedValue: "stack_overflow" },
+            message: "must be equal to constant",
+        };
+        if (vErrors === null) {
+            vErrors = [err3];
+        }
+        else {
+            vErrors.push(err3);
+        }
+        errors++;
+    }
+    var _valid0 = _errs3 === errors;
+    if (_valid0 && valid0) {
+        valid0 = false;
+        passing0 = [passing0, 1];
+    }
+    else {
+        if (_valid0) {
+            valid0 = true;
+            passing0 = 1;
+        }
+    }
+    if (!valid0) {
+        const err4 = {
+            instancePath,
+            schemaPath: "#/oneOf",
+            keyword: "oneOf",
+            params: { passingSchemas: passing0 },
+            message: "must match exactly one schema in oneOf",
+        };
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+        validate129.errors = vErrors;
         return false;
     }
+    else {
+        errors = _errs0;
+        if (vErrors !== null) {
+            if (_errs0) {
+                vErrors.length = _errs0;
+            }
+            else {
+                vErrors = null;
+            }
+        }
+    }
     validate129.errors = vErrors;
     return errors === 0;
 }
@@ -70524,7 +70644,6 @@ validate319.evaluated = { dynamicProps: true, dynamicItems: false };
 const schema112 = {
     description: "One demanded supervisor: its restart policy and the children it starts.",
     properties: {
-        backoff: { type: "boolean" },
         children: { items: { $ref: "#/$defs/SupervisorChild" }, type: "array" },
         id: { format: "uint32", maximum: 4294967295, minimum: 0, type: "integer" },
         max_restarts: {
@@ -70550,6 +70669,10 @@ const schema112 = {
 };
 const schema113 = {
     properties: {
+        backoff: {
+            description: "Construction transfers this child's effective restart delay as an\n`(initial, maximum)` argument pair after the config, in declaration order.",
+            type: "boolean",
+        },
         dependencies: {
             items: { format: "uint", minimum: 0, type: "integer" },
             type: "array",
@@ -70992,65 +71115,19 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                 return false;
             }
             else {
-                if (data.dependencies !== undefined) {
-                    let data0 = data.dependencies;
+                if (data.backoff !== undefined) {
                     const _errs1 = errors;
-                    if (errors === _errs1) {
-                        if (Array.isArray(data0)) {
-                            var valid1 = true;
-                            const len0 = data0.length;
-                            for (let i0 = 0; i0 < len0; i0++) {
-                                let data1 = data0[i0];
-                                const _errs3 = errors;
-                                if (!(typeof data1 == "number" &&
-                                    !(data1 % 1) &&
-                                    !isNaN(data1) &&
-                                    isFinite(data1))) {
-                                    validate329.errors = [
-                                        {
-                                            instancePath: instancePath + "/dependencies/" + i0,
-                                            schemaPath: "#/properties/dependencies/items/type",
-                                            keyword: "type",
-                                            params: { type: "integer" },
-                                            message: "must be integer",
-                                        },
-                                    ];
-                                    return false;
-                                }
-                                if (errors === _errs3) {
-                                    if (typeof data1 == "number" && isFinite(data1)) {
-                                        if (data1 < 0 || isNaN(data1)) {
-                                            validate329.errors = [
-                                                {
-                                                    instancePath: instancePath + "/dependencies/" + i0,
-                                                    schemaPath: "#/properties/dependencies/items/minimum",
-                                                    keyword: "minimum",
-                                                    params: { comparison: ">=", limit: 0 },
-                                                    message: "must be >= 0",
-                                                },
-                                            ];
-                                            return false;
-                                        }
-                                    }
-                                }
-                                var valid1 = _errs3 === errors;
-                                if (!valid1) {
-                                    break;
-                                }
-                            }
-                        }
-                        else {
-                            validate329.errors = [
-                                {
-                                    instancePath: instancePath + "/dependencies",
-                                    schemaPath: "#/properties/dependencies/type",
-                                    keyword: "type",
-                                    params: { type: "array" },
-                                    message: "must be array",
-                                },
-                            ];
-                            return false;
-                        }
+                    if (typeof data.backoff !== "boolean") {
+                        validate329.errors = [
+                            {
+                                instancePath: instancePath + "/backoff",
+                                schemaPath: "#/properties/backoff/type",
+                                keyword: "type",
+                                params: { type: "boolean" },
+                                message: "must be boolean",
+                            },
+                        ];
+                        return false;
                     }
                     var valid0 = _errs1 === errors;
                 }
@@ -71058,36 +71135,82 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                     var valid0 = true;
                 }
                 if (valid0) {
-                    if (data.is_pool !== undefined) {
-                        const _errs5 = errors;
-                        if (typeof data.is_pool !== "boolean") {
-                            validate329.errors = [
-                                {
-                                    instancePath: instancePath + "/is_pool",
-                                    schemaPath: "#/properties/is_pool/type",
-                                    keyword: "type",
-                                    params: { type: "boolean" },
-                                    message: "must be boolean",
-                                },
-                            ];
-                            return false;
+                    if (data.dependencies !== undefined) {
+                        let data1 = data.dependencies;
+                        const _errs3 = errors;
+                        if (errors === _errs3) {
+                            if (Array.isArray(data1)) {
+                                var valid1 = true;
+                                const len0 = data1.length;
+                                for (let i0 = 0; i0 < len0; i0++) {
+                                    let data2 = data1[i0];
+                                    const _errs5 = errors;
+                                    if (!(typeof data2 == "number" &&
+                                        !(data2 % 1) &&
+                                        !isNaN(data2) &&
+                                        isFinite(data2))) {
+                                        validate329.errors = [
+                                            {
+                                                instancePath: instancePath + "/dependencies/" + i0,
+                                                schemaPath: "#/properties/dependencies/items/type",
+                                                keyword: "type",
+                                                params: { type: "integer" },
+                                                message: "must be integer",
+                                            },
+                                        ];
+                                        return false;
+                                    }
+                                    if (errors === _errs5) {
+                                        if (typeof data2 == "number" && isFinite(data2)) {
+                                            if (data2 < 0 || isNaN(data2)) {
+                                                validate329.errors = [
+                                                    {
+                                                        instancePath: instancePath + "/dependencies/" + i0,
+                                                        schemaPath: "#/properties/dependencies/items/minimum",
+                                                        keyword: "minimum",
+                                                        params: { comparison: ">=", limit: 0 },
+                                                        message: "must be >= 0",
+                                                    },
+                                                ];
+                                                return false;
+                                            }
+                                        }
+                                    }
+                                    var valid1 = _errs5 === errors;
+                                    if (!valid1) {
+                                        break;
+                                    }
+                                }
+                            }
+                            else {
+                                validate329.errors = [
+                                    {
+                                        instancePath: instancePath + "/dependencies",
+                                        schemaPath: "#/properties/dependencies/type",
+                                        keyword: "type",
+                                        params: { type: "array" },
+                                        message: "must be array",
+                                    },
+                                ];
+                                return false;
+                            }
                         }
-                        var valid0 = _errs5 === errors;
+                        var valid0 = _errs3 === errors;
                     }
                     else {
                         var valid0 = true;
                     }
                     if (valid0) {
-                        if (data.name !== undefined) {
+                        if (data.is_pool !== undefined) {
                             const _errs7 = errors;
-                            if (typeof data.name !== "string") {
+                            if (typeof data.is_pool !== "boolean") {
                                 validate329.errors = [
                                     {
-                                        instancePath: instancePath + "/name",
-                                        schemaPath: "#/properties/name/type",
+                                        instancePath: instancePath + "/is_pool",
+                                        schemaPath: "#/properties/is_pool/type",
                                         keyword: "type",
-                                        params: { type: "string" },
-                                        message: "must be string",
+                                        params: { type: "boolean" },
+                                        message: "must be boolean",
                                     },
                                 ];
                                 return false;
@@ -71098,20 +71221,19 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                             var valid0 = true;
                         }
                         if (valid0) {
-                            if (data.restart !== undefined) {
+                            if (data.name !== undefined) {
                                 const _errs9 = errors;
-                                if (!validate330(data.restart, {
-                                    instancePath: instancePath + "/restart",
-                                    parentData: data,
-                                    parentDataProperty: "restart",
-                                    rootData,
-                                    dynamicAnchors,
-                                })) {
-                                    vErrors =
-                                        vErrors === null
-                                            ? validate330.errors
-                                            : vErrors.concat(validate330.errors);
-                                    errors = vErrors.length;
+                                if (typeof data.name !== "string") {
+                                    validate329.errors = [
+                                        {
+                                            instancePath: instancePath + "/name",
+                                            schemaPath: "#/properties/name/type",
+                                            keyword: "type",
+                                            params: { type: "string" },
+                                            message: "must be string",
+                                        },
+                                    ];
+                                    return false;
                                 }
                                 var valid0 = _errs9 === errors;
                             }
@@ -71119,116 +71241,94 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                                 var valid0 = true;
                             }
                             if (valid0) {
-                                if (data.role !== undefined) {
-                                    const _errs10 = errors;
-                                    if (!validate332(data.role, {
-                                        instancePath: instancePath + "/role",
+                                if (data.restart !== undefined) {
+                                    const _errs11 = errors;
+                                    if (!validate330(data.restart, {
+                                        instancePath: instancePath + "/restart",
                                         parentData: data,
-                                        parentDataProperty: "role",
+                                        parentDataProperty: "restart",
                                         rootData,
                                         dynamicAnchors,
                                     })) {
                                         vErrors =
                                             vErrors === null
-                                                ? validate332.errors
-                                                : vErrors.concat(validate332.errors);
+                                                ? validate330.errors
+                                                : vErrors.concat(validate330.errors);
                                         errors = vErrors.length;
                                     }
-                                    var valid0 = _errs10 === errors;
+                                    var valid0 = _errs11 === errors;
                                 }
                                 else {
                                     var valid0 = true;
                                 }
                                 if (valid0) {
-                                    if (data.spawn !== undefined) {
-                                        let data6 = data.spawn;
-                                        const _errs11 = errors;
-                                        if (!(typeof data6 == "number" &&
-                                            !(data6 % 1) &&
-                                            !isNaN(data6) &&
-                                            isFinite(data6))) {
-                                            validate329.errors = [
-                                                {
-                                                    instancePath: instancePath + "/spawn",
-                                                    schemaPath: "#/properties/spawn/type",
-                                                    keyword: "type",
-                                                    params: { type: "integer" },
-                                                    message: "must be integer",
-                                                },
-                                            ];
-                                            return false;
-                                        }
-                                        if (errors === _errs11) {
-                                            if (typeof data6 == "number" && isFinite(data6)) {
-                                                if (data6 > 4294967295 || isNaN(data6)) {
-                                                    validate329.errors = [
-                                                        {
-                                                            instancePath: instancePath + "/spawn",
-                                                            schemaPath: "#/properties/spawn/maximum",
-                                                            keyword: "maximum",
-                                                            params: { comparison: "<=", limit: 4294967295 },
-                                                            message: "must be <= 4294967295",
-                                                        },
-                                                    ];
-                                                    return false;
-                                                }
-                                                else {
-                                                    if (data6 < 0 || isNaN(data6)) {
-                                                        validate329.errors = [
-                                                            {
-                                                                instancePath: instancePath + "/spawn",
-                                                                schemaPath: "#/properties/spawn/minimum",
-                                                                keyword: "minimum",
-                                                                params: { comparison: ">=", limit: 0 },
-                                                                message: "must be >= 0",
-                                                            },
-                                                        ];
-                                                        return false;
-                                                    }
-                                                }
-                                            }
+                                    if (data.role !== undefined) {
+                                        const _errs12 = errors;
+                                        if (!validate332(data.role, {
+                                            instancePath: instancePath + "/role",
+                                            parentData: data,
+                                            parentDataProperty: "role",
+                                            rootData,
+                                            dynamicAnchors,
+                                        })) {
+                                            vErrors =
+                                                vErrors === null
+                                                    ? validate332.errors
+                                                    : vErrors.concat(validate332.errors);
+                                            errors = vErrors.length;
                                         }
-                                        var valid0 = _errs11 === errors;
+                                        var valid0 = _errs12 === errors;
                                     }
                                     else {
                                         var valid0 = true;
                                     }
                                     if (valid0) {
-                                        if (data.stop_config !== undefined) {
-                                            let data7 = data.stop_config;
+                                        if (data.spawn !== undefined) {
+                                            let data7 = data.spawn;
                                             const _errs13 = errors;
                                             if (!(typeof data7 == "number" &&
                                                 !(data7 % 1) &&
                                                 !isNaN(data7) &&
-                                                isFinite(data7)) &&
-                                                data7 !== null) {
+                                                isFinite(data7))) {
                                                 validate329.errors = [
                                                     {
-                                                        instancePath: instancePath + "/stop_config",
-                                                        schemaPath: "#/properties/stop_config/type",
+                                                        instancePath: instancePath + "/spawn",
+                                                        schemaPath: "#/properties/spawn/type",
                                                         keyword: "type",
-                                                        params: {
-                                                            type: schema113.properties.stop_config.type,
-                                                        },
-                                                        message: "must be integer,null",
+                                                        params: { type: "integer" },
+                                                        message: "must be integer",
                                                     },
                                                 ];
                                                 return false;
                                             }
                                             if (errors === _errs13) {
                                                 if (typeof data7 == "number" && isFinite(data7)) {
-                                                    if (data7 < 0 || isNaN(data7)) {
+                                                    if (data7 > 4294967295 || isNaN(data7)) {
                                                         validate329.errors = [
                                                             {
-                                                                instancePath: instancePath + "/stop_config",
-                                                                schemaPath: "#/properties/stop_config/minimum",
-                                                                keyword: "minimum",
-                                                                params: { comparison: ">=", limit: 0 },
-                                                                message: "must be >= 0",
+                                                                instancePath: instancePath + "/spawn",
+                                                                schemaPath: "#/properties/spawn/maximum",
+                                                                keyword: "maximum",
+                                                                params: { comparison: "<=", limit: 4294967295 },
+                                                                message: "must be <= 4294967295",
                                                             },
                                                         ];
                                                         return false;
                                                     }
+                                                    else {
+                                                        if (data7 < 0 || isNaN(data7)) {
+                                                            validate329.errors = [
+                                                                {
+                                                                    instancePath: instancePath + "/spawn",
+                                                                    schemaPath: "#/properties/spawn/minimum",
+                                                                    keyword: "minimum",
+                                                                    params: { comparison: ">=", limit: 0 },
+                                                                    message: "must be >= 0",
+                                                                },
+                                                            ];
+                                                            return false;
+                                                        }
+                                                    }
                                                 }
                                             }
                                             var valid0 = _errs13 === errors;
@@ -71237,8 +71337,8 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                                             var valid0 = true;
                                         }
                                         if (valid0) {
-                                            if (data.stop_ns !== undefined) {
-                                                let data8 = data.stop_ns;
+                                            if (data.stop_config !== undefined) {
+                                                let data8 = data.stop_config;
                                                 const _errs15 = errors;
                                                 if (!(typeof data8 == "number" &&
                                                     !(data8 % 1) &&
@@ -71247,11 +71347,11 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                                                     data8 !== null) {
                                                     validate329.errors = [
                                                         {
-                                                            instancePath: instancePath + "/stop_ns",
-                                                            schemaPath: "#/properties/stop_ns/type",
+                                                            instancePath: instancePath + "/stop_config",
+                                                            schemaPath: "#/properties/stop_config/type",
                                                             keyword: "type",
                                                             params: {
-                                                                type: schema113.properties.stop_ns.type,
+                                                                type: schema113.properties.stop_config.type,
                                                             },
                                                             message: "must be integer,null",
                                                         },
@@ -71260,41 +71360,85 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
                                                 }
                                                 if (errors === _errs15) {
                                                     if (typeof data8 == "number" && isFinite(data8)) {
-                                                        if (data8 > 9223372036854776000 || isNaN(data8)) {
+                                                        if (data8 < 0 || isNaN(data8)) {
                                                             validate329.errors = [
                                                                 {
-                                                                    instancePath: instancePath + "/stop_ns",
-                                                                    schemaPath: "#/properties/stop_ns/maximum",
-                                                                    keyword: "maximum",
-                                                                    params: {
-                                                                        comparison: "<=",
-                                                                        limit: 9223372036854776000,
-                                                                    },
-                                                                    message: "must be <= 9223372036854776000",
+                                                                    instancePath: instancePath + "/stop_config",
+                                                                    schemaPath: "#/properties/stop_config/minimum",
+                                                                    keyword: "minimum",
+                                                                    params: { comparison: ">=", limit: 0 },
+                                                                    message: "must be >= 0",
                                                                 },
                                                             ];
                                                             return false;
                                                         }
-                                                        else {
-                                                            if (data8 < 0 || isNaN(data8)) {
+                                                    }
+                                                }
+                                                var valid0 = _errs15 === errors;
+                                            }
+                                            else {
+                                                var valid0 = true;
+                                            }
+                                            if (valid0) {
+                                                if (data.stop_ns !== undefined) {
+                                                    let data9 = data.stop_ns;
+                                                    const _errs17 = errors;
+                                                    if (!(typeof data9 == "number" &&
+                                                        !(data9 % 1) &&
+                                                        !isNaN(data9) &&
+                                                        isFinite(data9)) &&
+                                                        data9 !== null) {
+                                                        validate329.errors = [
+                                                            {
+                                                                instancePath: instancePath + "/stop_ns",
+                                                                schemaPath: "#/properties/stop_ns/type",
+                                                                keyword: "type",
+                                                                params: {
+                                                                    type: schema113.properties.stop_ns.type,
+                                                                },
+                                                                message: "must be integer,null",
+                                                            },
+                                                        ];
+                                                        return false;
+                                                    }
+                                                    if (errors === _errs17) {
+                                                        if (typeof data9 == "number" && isFinite(data9)) {
+                                                            if (data9 > 9223372036854776000 || isNaN(data9)) {
                                                                 validate329.errors = [
                                                                     {
                                                                         instancePath: instancePath + "/stop_ns",
-                                                                        schemaPath: "#/properties/stop_ns/minimum",
-                                                                        keyword: "minimum",
-                                                                        params: { comparison: ">=", limit: 0 },
-                                                                        message: "must be >= 0",
+                                                                        schemaPath: "#/properties/stop_ns/maximum",
+                                                                        keyword: "maximum",
+                                                                        params: {
+                                                                            comparison: "<=",
+                                                                            limit: 9223372036854776000,
+                                                                        },
+                                                                        message: "must be <= 9223372036854776000",
                                                                     },
                                                                 ];
                                                                 return false;
                                                             }
+                                                            else {
+                                                                if (data9 < 0 || isNaN(data9)) {
+                                                                    validate329.errors = [
+                                                                        {
+                                                                            instancePath: instancePath + "/stop_ns",
+                                                                            schemaPath: "#/properties/stop_ns/minimum",
+                                                                            keyword: "minimum",
+                                                                            params: { comparison: ">=", limit: 0 },
+                                                                            message: "must be >= 0",
+                                                                        },
+                                                                    ];
+                                                                    return false;
+                                                                }
+                                                            }
                                                         }
                                                     }
+                                                    var valid0 = _errs17 === errors;
+                                                }
+                                                else {
+                                                    var valid0 = true;
                                                 }
-                                                var valid0 = _errs15 === errors;
-                                            }
-                                            else {
-                                                var valid0 = true;
                                             }
                                         }
                                     }
@@ -71323,6 +71467,7 @@ function validate329(data, { instancePath = "", parentData, parentDataProperty,
 }
 validate329.evaluated = {
     props: {
+        backoff: true,
         dependencies: true,
         is_pool: true,
         name: true,
@@ -71410,19 +71555,46 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                 return false;
             }
             else {
-                if (data.backoff !== undefined) {
+                if (data.children !== undefined) {
+                    let data0 = data.children;
                     const _errs1 = errors;
-                    if (typeof data.backoff !== "boolean") {
-                        validate328.errors = [
-                            {
-                                instancePath: instancePath + "/backoff",
-                                schemaPath: "#/properties/backoff/type",
-                                keyword: "type",
-                                params: { type: "boolean" },
-                                message: "must be boolean",
-                            },
-                        ];
-                        return false;
+                    if (errors === _errs1) {
+                        if (Array.isArray(data0)) {
+                            var valid1 = true;
+                            const len0 = data0.length;
+                            for (let i0 = 0; i0 < len0; i0++) {
+                                const _errs3 = errors;
+                                if (!validate329(data0[i0], {
+                                    instancePath: instancePath + "/children/" + i0,
+                                    parentData: data0,
+                                    parentDataProperty: i0,
+                                    rootData,
+                                    dynamicAnchors,
+                                })) {
+                                    vErrors =
+                                        vErrors === null
+                                            ? validate329.errors
+                                            : vErrors.concat(validate329.errors);
+                                    errors = vErrors.length;
+                                }
+                                var valid1 = _errs3 === errors;
+                                if (!valid1) {
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            validate328.errors = [
+                                {
+                                    instancePath: instancePath + "/children",
+                                    schemaPath: "#/properties/children/type",
+                                    keyword: "type",
+                                    params: { type: "array" },
+                                    message: "must be array",
+                                },
+                            ];
+                            return false;
+                        }
                     }
                     var valid0 = _errs1 === errors;
                 }
@@ -71430,55 +71602,62 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                     var valid0 = true;
                 }
                 if (valid0) {
-                    if (data.children !== undefined) {
-                        let data1 = data.children;
-                        const _errs3 = errors;
-                        if (errors === _errs3) {
-                            if (Array.isArray(data1)) {
-                                var valid1 = true;
-                                const len0 = data1.length;
-                                for (let i0 = 0; i0 < len0; i0++) {
-                                    const _errs5 = errors;
-                                    if (!validate329(data1[i0], {
-                                        instancePath: instancePath + "/children/" + i0,
-                                        parentData: data1,
-                                        parentDataProperty: i0,
-                                        rootData,
-                                        dynamicAnchors,
-                                    })) {
-                                        vErrors =
-                                            vErrors === null
-                                                ? validate329.errors
-                                                : vErrors.concat(validate329.errors);
-                                        errors = vErrors.length;
-                                    }
-                                    var valid1 = _errs5 === errors;
-                                    if (!valid1) {
-                                        break;
+                    if (data.id !== undefined) {
+                        let data2 = data.id;
+                        const _errs4 = errors;
+                        if (!(typeof data2 == "number" &&
+                            !(data2 % 1) &&
+                            !isNaN(data2) &&
+                            isFinite(data2))) {
+                            validate328.errors = [
+                                {
+                                    instancePath: instancePath + "/id",
+                                    schemaPath: "#/properties/id/type",
+                                    keyword: "type",
+                                    params: { type: "integer" },
+                                    message: "must be integer",
+                                },
+                            ];
+                            return false;
+                        }
+                        if (errors === _errs4) {
+                            if (typeof data2 == "number" && isFinite(data2)) {
+                                if (data2 > 4294967295 || isNaN(data2)) {
+                                    validate328.errors = [
+                                        {
+                                            instancePath: instancePath + "/id",
+                                            schemaPath: "#/properties/id/maximum",
+                                            keyword: "maximum",
+                                            params: { comparison: "<=", limit: 4294967295 },
+                                            message: "must be <= 4294967295",
+                                        },
+                                    ];
+                                    return false;
+                                }
+                                else {
+                                    if (data2 < 0 || isNaN(data2)) {
+                                        validate328.errors = [
+                                            {
+                                                instancePath: instancePath + "/id",
+                                                schemaPath: "#/properties/id/minimum",
+                                                keyword: "minimum",
+                                                params: { comparison: ">=", limit: 0 },
+                                                message: "must be >= 0",
+                                            },
+                                        ];
+                                        return false;
                                     }
                                 }
                             }
-                            else {
-                                validate328.errors = [
-                                    {
-                                        instancePath: instancePath + "/children",
-                                        schemaPath: "#/properties/children/type",
-                                        keyword: "type",
-                                        params: { type: "array" },
-                                        message: "must be array",
-                                    },
-                                ];
-                                return false;
-                            }
                         }
-                        var valid0 = _errs3 === errors;
+                        var valid0 = _errs4 === errors;
                     }
                     else {
                         var valid0 = true;
                     }
                     if (valid0) {
-                        if (data.id !== undefined) {
-                            let data3 = data.id;
+                        if (data.max_restarts !== undefined) {
+                            let data3 = data.max_restarts;
                             const _errs6 = errors;
                             if (!(typeof data3 == "number" &&
                                 !(data3 % 1) &&
@@ -71486,8 +71665,8 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                                 isFinite(data3))) {
                                 validate328.errors = [
                                     {
-                                        instancePath: instancePath + "/id",
-                                        schemaPath: "#/properties/id/type",
+                                        instancePath: instancePath + "/max_restarts",
+                                        schemaPath: "#/properties/max_restarts/type",
                                         keyword: "type",
                                         params: { type: "integer" },
                                         message: "must be integer",
@@ -71500,8 +71679,8 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                                     if (data3 > 4294967295 || isNaN(data3)) {
                                         validate328.errors = [
                                             {
-                                                instancePath: instancePath + "/id",
-                                                schemaPath: "#/properties/id/maximum",
+                                                instancePath: instancePath + "/max_restarts",
+                                                schemaPath: "#/properties/max_restarts/maximum",
                                                 keyword: "maximum",
                                                 params: { comparison: "<=", limit: 4294967295 },
                                                 message: "must be <= 4294967295",
@@ -71513,8 +71692,8 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                                         if (data3 < 0 || isNaN(data3)) {
                                             validate328.errors = [
                                                 {
-                                                    instancePath: instancePath + "/id",
-                                                    schemaPath: "#/properties/id/minimum",
+                                                    instancePath: instancePath + "/max_restarts",
+                                                    schemaPath: "#/properties/max_restarts/minimum",
                                                     keyword: "minimum",
                                                     params: { comparison: ">=", limit: 0 },
                                                     message: "must be >= 0",
@@ -71531,53 +71710,65 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                             var valid0 = true;
                         }
                         if (valid0) {
-                            if (data.max_restarts !== undefined) {
-                                let data4 = data.max_restarts;
+                            if (data.startup_order !== undefined) {
+                                let data4 = data.startup_order;
                                 const _errs8 = errors;
-                                if (!(typeof data4 == "number" &&
-                                    !(data4 % 1) &&
-                                    !isNaN(data4) &&
-                                    isFinite(data4))) {
-                                    validate328.errors = [
-                                        {
-                                            instancePath: instancePath + "/max_restarts",
-                                            schemaPath: "#/properties/max_restarts/type",
-                                            keyword: "type",
-                                            params: { type: "integer" },
-                                            message: "must be integer",
-                                        },
-                                    ];
-                                    return false;
-                                }
                                 if (errors === _errs8) {
-                                    if (typeof data4 == "number" && isFinite(data4)) {
-                                        if (data4 > 4294967295 || isNaN(data4)) {
-                                            validate328.errors = [
-                                                {
-                                                    instancePath: instancePath + "/max_restarts",
-                                                    schemaPath: "#/properties/max_restarts/maximum",
-                                                    keyword: "maximum",
-                                                    params: { comparison: "<=", limit: 4294967295 },
-                                                    message: "must be <= 4294967295",
-                                                },
-                                            ];
-                                            return false;
-                                        }
-                                        else {
-                                            if (data4 < 0 || isNaN(data4)) {
+                                    if (Array.isArray(data4)) {
+                                        var valid2 = true;
+                                        const len1 = data4.length;
+                                        for (let i1 = 0; i1 < len1; i1++) {
+                                            let data5 = data4[i1];
+                                            const _errs10 = errors;
+                                            if (!(typeof data5 == "number" &&
+                                                !(data5 % 1) &&
+                                                !isNaN(data5) &&
+                                                isFinite(data5))) {
                                                 validate328.errors = [
                                                     {
-                                                        instancePath: instancePath + "/max_restarts",
-                                                        schemaPath: "#/properties/max_restarts/minimum",
-                                                        keyword: "minimum",
-                                                        params: { comparison: ">=", limit: 0 },
-                                                        message: "must be >= 0",
+                                                        instancePath: instancePath + "/startup_order/" + i1,
+                                                        schemaPath: "#/properties/startup_order/items/type",
+                                                        keyword: "type",
+                                                        params: { type: "integer" },
+                                                        message: "must be integer",
                                                     },
                                                 ];
                                                 return false;
                                             }
+                                            if (errors === _errs10) {
+                                                if (typeof data5 == "number" && isFinite(data5)) {
+                                                    if (data5 < 0 || isNaN(data5)) {
+                                                        validate328.errors = [
+                                                            {
+                                                                instancePath: instancePath + "/startup_order/" + i1,
+                                                                schemaPath: "#/properties/startup_order/items/minimum",
+                                                                keyword: "minimum",
+                                                                params: { comparison: ">=", limit: 0 },
+                                                                message: "must be >= 0",
+                                                            },
+                                                        ];
+                                                        return false;
+                                                    }
+                                                }
+                                            }
+                                            var valid2 = _errs10 === errors;
+                                            if (!valid2) {
+                                                break;
+                                            }
                                         }
                                     }
+                                    else {
+                                        validate328.errors = [
+                                            {
+                                                instancePath: instancePath + "/startup_order",
+                                                schemaPath: "#/properties/startup_order/type",
+                                                keyword: "type",
+                                                params: { type: "array" },
+                                                message: "must be array",
+                                            },
+                                        ];
+                                        return false;
+                                    }
                                 }
                                 var valid0 = _errs8 === errors;
                             }
@@ -71585,146 +71776,79 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
                                 var valid0 = true;
                             }
                             if (valid0) {
-                                if (data.startup_order !== undefined) {
-                                    let data5 = data.startup_order;
-                                    const _errs10 = errors;
-                                    if (errors === _errs10) {
-                                        if (Array.isArray(data5)) {
-                                            var valid2 = true;
-                                            const len1 = data5.length;
-                                            for (let i1 = 0; i1 < len1; i1++) {
-                                                let data6 = data5[i1];
-                                                const _errs12 = errors;
-                                                if (!(typeof data6 == "number" &&
-                                                    !(data6 % 1) &&
-                                                    !isNaN(data6) &&
-                                                    isFinite(data6))) {
-                                                    validate328.errors = [
-                                                        {
-                                                            instancePath: instancePath + "/startup_order/" + i1,
-                                                            schemaPath: "#/properties/startup_order/items/type",
-                                                            keyword: "type",
-                                                            params: { type: "integer" },
-                                                            message: "must be integer",
-                                                        },
-                                                    ];
-                                                    return false;
-                                                }
-                                                if (errors === _errs12) {
-                                                    if (typeof data6 == "number" && isFinite(data6)) {
-                                                        if (data6 < 0 || isNaN(data6)) {
-                                                            validate328.errors = [
-                                                                {
-                                                                    instancePath: instancePath + "/startup_order/" + i1,
-                                                                    schemaPath: "#/properties/startup_order/items/minimum",
-                                                                    keyword: "minimum",
-                                                                    params: { comparison: ">=", limit: 0 },
-                                                                    message: "must be >= 0",
-                                                                },
-                                                            ];
-                                                            return false;
-                                                        }
-                                                    }
-                                                }
-                                                var valid2 = _errs12 === errors;
-                                                if (!valid2) {
-                                                    break;
-                                                }
-                                            }
-                                        }
-                                        else {
-                                            validate328.errors = [
-                                                {
-                                                    instancePath: instancePath + "/startup_order",
-                                                    schemaPath: "#/properties/startup_order/type",
-                                                    keyword: "type",
-                                                    params: { type: "array" },
-                                                    message: "must be array",
-                                                },
-                                            ];
-                                            return false;
-                                        }
+                                if (data.strategy !== undefined) {
+                                    const _errs12 = errors;
+                                    if (!validate335(data.strategy, {
+                                        instancePath: instancePath + "/strategy",
+                                        parentData: data,
+                                        parentDataProperty: "strategy",
+                                        rootData,
+                                        dynamicAnchors,
+                                    })) {
+                                        vErrors =
+                                            vErrors === null
+                                                ? validate335.errors
+                                                : vErrors.concat(validate335.errors);
+                                        errors = vErrors.length;
                                     }
-                                    var valid0 = _errs10 === errors;
+                                    var valid0 = _errs12 === errors;
                                 }
                                 else {
                                     var valid0 = true;
                                 }
                                 if (valid0) {
-                                    if (data.strategy !== undefined) {
-                                        const _errs14 = errors;
-                                        if (!validate335(data.strategy, {
-                                            instancePath: instancePath + "/strategy",
-                                            parentData: data,
-                                            parentDataProperty: "strategy",
-                                            rootData,
-                                            dynamicAnchors,
-                                        })) {
-                                            vErrors =
-                                                vErrors === null
-                                                    ? validate335.errors
-                                                    : vErrors.concat(validate335.errors);
-                                            errors = vErrors.length;
+                                    if (data.window_secs !== undefined) {
+                                        let data7 = data.window_secs;
+                                        const _errs13 = errors;
+                                        if (!(typeof data7 == "number" &&
+                                            !(data7 % 1) &&
+                                            !isNaN(data7) &&
+                                            isFinite(data7))) {
+                                            validate328.errors = [
+                                                {
+                                                    instancePath: instancePath + "/window_secs",
+                                                    schemaPath: "#/properties/window_secs/type",
+                                                    keyword: "type",
+                                                    params: { type: "integer" },
+                                                    message: "must be integer",
+                                                },
+                                            ];
+                                            return false;
                                         }
-                                        var valid0 = _errs14 === errors;
-                                    }
-                                    else {
-                                        var valid0 = true;
-                                    }
-                                    if (valid0) {
-                                        if (data.window_secs !== undefined) {
-                                            let data8 = data.window_secs;
-                                            const _errs15 = errors;
-                                            if (!(typeof data8 == "number" &&
-                                                !(data8 % 1) &&
-                                                !isNaN(data8) &&
-                                                isFinite(data8))) {
-                                                validate328.errors = [
-                                                    {
-                                                        instancePath: instancePath + "/window_secs",
-                                                        schemaPath: "#/properties/window_secs/type",
-                                                        keyword: "type",
-                                                        params: { type: "integer" },
-                                                        message: "must be integer",
-                                                    },
-                                                ];
-                                                return false;
-                                            }
-                                            if (errors === _errs15) {
-                                                if (typeof data8 == "number" && isFinite(data8)) {
-                                                    if (data8 > 4294967295 || isNaN(data8)) {
+                                        if (errors === _errs13) {
+                                            if (typeof data7 == "number" && isFinite(data7)) {
+                                                if (data7 > 4294967295 || isNaN(data7)) {
+                                                    validate328.errors = [
+                                                        {
+                                                            instancePath: instancePath + "/window_secs",
+                                                            schemaPath: "#/properties/window_secs/maximum",
+                                                            keyword: "maximum",
+                                                            params: { comparison: "<=", limit: 4294967295 },
+                                                            message: "must be <= 4294967295",
+                                                        },
+                                                    ];
+                                                    return false;
+                                                }
+                                                else {
+                                                    if (data7 < 0 || isNaN(data7)) {
                                                         validate328.errors = [
                                                             {
                                                                 instancePath: instancePath + "/window_secs",
-                                                                schemaPath: "#/properties/window_secs/maximum",
-                                                                keyword: "maximum",
-                                                                params: { comparison: "<=", limit: 4294967295 },
-                                                                message: "must be <= 4294967295",
+                                                                schemaPath: "#/properties/window_secs/minimum",
+                                                                keyword: "minimum",
+                                                                params: { comparison: ">=", limit: 0 },
+                                                                message: "must be >= 0",
                                                             },
                                                         ];
                                                         return false;
                                                     }
-                                                    else {
-                                                        if (data8 < 0 || isNaN(data8)) {
-                                                            validate328.errors = [
-                                                                {
-                                                                    instancePath: instancePath + "/window_secs",
-                                                                    schemaPath: "#/properties/window_secs/minimum",
-                                                                    keyword: "minimum",
-                                                                    params: { comparison: ">=", limit: 0 },
-                                                                    message: "must be >= 0",
-                                                                },
-                                                            ];
-                                                            return false;
-                                                        }
-                                                    }
                                                 }
                                             }
-                                            var valid0 = _errs15 === errors;
-                                        }
-                                        else {
-                                            var valid0 = true;
                                         }
+                                        var valid0 = _errs13 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
                                     }
                                 }
                             }
@@ -71751,7 +71875,6 @@ function validate328(data, { instancePath = "", parentData, parentDataProperty,
 }
 validate328.evaluated = {
     props: {
-        backoff: true,
         children: true,
         id: true,
         max_restarts: true,
@@ -72888,6 +73011,12 @@ const schema122 = {
                     minimum: 0,
                     type: "integer",
                 },
+                CrashKindStackOverflow: {
+                    format: "uint32",
+                    maximum: 4294967295,
+                    minimum: 0,
+                    type: "integer",
+                },
                 CrashKindTimerOverdue: {
                     format: "uint32",
                     maximum: 4294967295,
@@ -74681,9 +74810,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                             var valid2 = true;
                                                                                                                         }
                                                                                                                         if (valid2) {
-                                                                                                                            if (data4.CrashKindTimerOverdue !==
+                                                                                                                            if (data4.CrashKindStackOverflow !==
                                                                                                                                 undefined) {
-                                                                                                                                let data25 = data4.CrashKindTimerOverdue;
+                                                                                                                                let data25 = data4.CrashKindStackOverflow;
                                                                                                                                 const _errs51 = errors;
                                                                                                                                 if (!(typeof data25 ==
                                                                                                                                     "number" &&
@@ -74694,8 +74823,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                         [
                                                                                                                                             {
                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                    "/runtime_tags/CrashKindTimerOverdue",
-                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/CrashKindTimerOverdue/type",
+                                                                                                                                                    "/runtime_tags/CrashKindStackOverflow",
+                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/CrashKindStackOverflow/type",
                                                                                                                                                 keyword: "type",
                                                                                                                                                 params: {
                                                                                                                                                     type: "integer",
@@ -74717,8 +74846,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                 [
                                                                                                                                                     {
                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                            "/runtime_tags/CrashKindTimerOverdue",
-                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/CrashKindTimerOverdue/maximum",
+                                                                                                                                                            "/runtime_tags/CrashKindStackOverflow",
+                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/CrashKindStackOverflow/maximum",
                                                                                                                                                         keyword: "maximum",
                                                                                                                                                         params: {
                                                                                                                                                             comparison: "<=",
@@ -74737,8 +74866,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                     [
                                                                                                                                                         {
                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                "/runtime_tags/CrashKindTimerOverdue",
-                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/CrashKindTimerOverdue/minimum",
+                                                                                                                                                                "/runtime_tags/CrashKindStackOverflow",
+                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/CrashKindStackOverflow/minimum",
                                                                                                                                                             keyword: "minimum",
                                                                                                                                                             params: {
                                                                                                                                                                 comparison: ">=",
@@ -74759,9 +74888,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                 var valid2 = true;
                                                                                                                             }
                                                                                                                             if (valid2) {
-                                                                                                                                if (data4.DeliveryAccepted !==
+                                                                                                                                if (data4.CrashKindTimerOverdue !==
                                                                                                                                     undefined) {
-                                                                                                                                    let data26 = data4.DeliveryAccepted;
+                                                                                                                                    let data26 = data4.CrashKindTimerOverdue;
                                                                                                                                     const _errs53 = errors;
                                                                                                                                     if (!(typeof data26 ==
                                                                                                                                         "number" &&
@@ -74773,8 +74902,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                             [
                                                                                                                                                 {
                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                        "/runtime_tags/DeliveryAccepted",
-                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/DeliveryAccepted/type",
+                                                                                                                                                        "/runtime_tags/CrashKindTimerOverdue",
+                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/CrashKindTimerOverdue/type",
                                                                                                                                                     keyword: "type",
                                                                                                                                                     params: {
                                                                                                                                                         type: "integer",
@@ -74796,8 +74925,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                     [
                                                                                                                                                         {
                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                "/runtime_tags/DeliveryAccepted",
-                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/DeliveryAccepted/maximum",
+                                                                                                                                                                "/runtime_tags/CrashKindTimerOverdue",
+                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/CrashKindTimerOverdue/maximum",
                                                                                                                                                             keyword: "maximum",
                                                                                                                                                             params: {
                                                                                                                                                                 comparison: "<=",
@@ -74816,8 +74945,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                         [
                                                                                                                                                             {
                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                    "/runtime_tags/DeliveryAccepted",
-                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/DeliveryAccepted/minimum",
+                                                                                                                                                                    "/runtime_tags/CrashKindTimerOverdue",
+                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/CrashKindTimerOverdue/minimum",
                                                                                                                                                                 keyword: "minimum",
                                                                                                                                                                 params: {
                                                                                                                                                                     comparison: ">=",
@@ -74838,9 +74967,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                     var valid2 = true;
                                                                                                                                 }
                                                                                                                                 if (valid2) {
-                                                                                                                                    if (data4.DeliveryDiscarded !==
+                                                                                                                                    if (data4.DeliveryAccepted !==
                                                                                                                                         undefined) {
-                                                                                                                                        let data27 = data4.DeliveryDiscarded;
+                                                                                                                                        let data27 = data4.DeliveryAccepted;
                                                                                                                                         const _errs55 = errors;
                                                                                                                                         if (!(typeof data27 ==
                                                                                                                                             "number" &&
@@ -74852,8 +74981,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                 [
                                                                                                                                                     {
                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                            "/runtime_tags/DeliveryDiscarded",
-                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/DeliveryDiscarded/type",
+                                                                                                                                                            "/runtime_tags/DeliveryAccepted",
+                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/DeliveryAccepted/type",
                                                                                                                                                         keyword: "type",
                                                                                                                                                         params: {
                                                                                                                                                             type: "integer",
@@ -74875,8 +75004,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                         [
                                                                                                                                                             {
                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                    "/runtime_tags/DeliveryDiscarded",
-                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/DeliveryDiscarded/maximum",
+                                                                                                                                                                    "/runtime_tags/DeliveryAccepted",
+                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/DeliveryAccepted/maximum",
                                                                                                                                                                 keyword: "maximum",
                                                                                                                                                                 params: {
                                                                                                                                                                     comparison: "<=",
@@ -74895,8 +75024,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                             [
                                                                                                                                                                 {
                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                        "/runtime_tags/DeliveryDiscarded",
-                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/DeliveryDiscarded/minimum",
+                                                                                                                                                                        "/runtime_tags/DeliveryAccepted",
+                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/DeliveryAccepted/minimum",
                                                                                                                                                                     keyword: "minimum",
                                                                                                                                                                     params: {
                                                                                                                                                                         comparison: ">=",
@@ -74917,9 +75046,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                         var valid2 = true;
                                                                                                                                     }
                                                                                                                                     if (valid2) {
-                                                                                                                                        if (data4.LinkErrorNoContext !==
+                                                                                                                                        if (data4.DeliveryDiscarded !==
                                                                                                                                             undefined) {
-                                                                                                                                            let data28 = data4.LinkErrorNoContext;
+                                                                                                                                            let data28 = data4.DeliveryDiscarded;
                                                                                                                                             const _errs57 = errors;
                                                                                                                                             if (!(typeof data28 ==
                                                                                                                                                 "number" &&
@@ -74931,8 +75060,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                     [
                                                                                                                                                         {
                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                "/runtime_tags/LinkErrorNoContext",
-                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/LinkErrorNoContext/type",
+                                                                                                                                                                "/runtime_tags/DeliveryDiscarded",
+                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/DeliveryDiscarded/type",
                                                                                                                                                             keyword: "type",
                                                                                                                                                             params: {
                                                                                                                                                                 type: "integer",
@@ -74954,8 +75083,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                             [
                                                                                                                                                                 {
                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                        "/runtime_tags/LinkErrorNoContext",
-                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/LinkErrorNoContext/maximum",
+                                                                                                                                                                        "/runtime_tags/DeliveryDiscarded",
+                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/DeliveryDiscarded/maximum",
                                                                                                                                                                     keyword: "maximum",
                                                                                                                                                                     params: {
                                                                                                                                                                         comparison: "<=",
@@ -74974,8 +75103,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                 [
                                                                                                                                                                     {
                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                            "/runtime_tags/LinkErrorNoContext",
-                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/LinkErrorNoContext/minimum",
+                                                                                                                                                                            "/runtime_tags/DeliveryDiscarded",
+                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/DeliveryDiscarded/minimum",
                                                                                                                                                                         keyword: "minimum",
                                                                                                                                                                         params: {
                                                                                                                                                                             comparison: ">=",
@@ -74996,9 +75125,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                             var valid2 = true;
                                                                                                                                         }
                                                                                                                                         if (valid2) {
-                                                                                                                                            if (data4.OptionNone !==
+                                                                                                                                            if (data4.LinkErrorNoContext !==
                                                                                                                                                 undefined) {
-                                                                                                                                                let data29 = data4.OptionNone;
+                                                                                                                                                let data29 = data4.LinkErrorNoContext;
                                                                                                                                                 const _errs59 = errors;
                                                                                                                                                 if (!(typeof data29 ==
                                                                                                                                                     "number" &&
@@ -75010,8 +75139,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                         [
                                                                                                                                                             {
                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                    "/runtime_tags/OptionNone",
-                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/OptionNone/type",
+                                                                                                                                                                    "/runtime_tags/LinkErrorNoContext",
+                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/LinkErrorNoContext/type",
                                                                                                                                                                 keyword: "type",
                                                                                                                                                                 params: {
                                                                                                                                                                     type: "integer",
@@ -75033,8 +75162,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                 [
                                                                                                                                                                     {
                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                            "/runtime_tags/OptionNone",
-                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/OptionNone/maximum",
+                                                                                                                                                                            "/runtime_tags/LinkErrorNoContext",
+                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/LinkErrorNoContext/maximum",
                                                                                                                                                                         keyword: "maximum",
                                                                                                                                                                         params: {
                                                                                                                                                                             comparison: "<=",
@@ -75053,8 +75182,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                     [
                                                                                                                                                                         {
                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                "/runtime_tags/OptionNone",
-                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/OptionNone/minimum",
+                                                                                                                                                                                "/runtime_tags/LinkErrorNoContext",
+                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/LinkErrorNoContext/minimum",
                                                                                                                                                                             keyword: "minimum",
                                                                                                                                                                             params: {
                                                                                                                                                                                 comparison: ">=",
@@ -75075,9 +75204,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                 var valid2 = true;
                                                                                                                                             }
                                                                                                                                             if (valid2) {
-                                                                                                                                                if (data4.OptionSome !==
+                                                                                                                                                if (data4.OptionNone !==
                                                                                                                                                     undefined) {
-                                                                                                                                                    let data30 = data4.OptionSome;
+                                                                                                                                                    let data30 = data4.OptionNone;
                                                                                                                                                     const _errs61 = errors;
                                                                                                                                                     if (!(typeof data30 ==
                                                                                                                                                         "number" &&
@@ -75089,8 +75218,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                             [
                                                                                                                                                                 {
                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                        "/runtime_tags/OptionSome",
-                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/OptionSome/type",
+                                                                                                                                                                        "/runtime_tags/OptionNone",
+                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/OptionNone/type",
                                                                                                                                                                     keyword: "type",
                                                                                                                                                                     params: {
                                                                                                                                                                         type: "integer",
@@ -75112,8 +75241,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                     [
                                                                                                                                                                         {
                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                "/runtime_tags/OptionSome",
-                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/OptionSome/maximum",
+                                                                                                                                                                                "/runtime_tags/OptionNone",
+                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/OptionNone/maximum",
                                                                                                                                                                             keyword: "maximum",
                                                                                                                                                                             params: {
                                                                                                                                                                                 comparison: "<=",
@@ -75132,8 +75261,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                         [
                                                                                                                                                                             {
                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                    "/runtime_tags/OptionSome",
-                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/OptionSome/minimum",
+                                                                                                                                                                                    "/runtime_tags/OptionNone",
+                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/OptionNone/minimum",
                                                                                                                                                                                 keyword: "minimum",
                                                                                                                                                                                 params: {
                                                                                                                                                                                     comparison: ">=",
@@ -75154,9 +75283,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                     var valid2 = true;
                                                                                                                                                 }
                                                                                                                                                 if (valid2) {
-                                                                                                                                                    if (data4.ResultErr !==
+                                                                                                                                                    if (data4.OptionSome !==
                                                                                                                                                         undefined) {
-                                                                                                                                                        let data31 = data4.ResultErr;
+                                                                                                                                                        let data31 = data4.OptionSome;
                                                                                                                                                         const _errs63 = errors;
                                                                                                                                                         if (!(typeof data31 ==
                                                                                                                                                             "number" &&
@@ -75168,8 +75297,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                 [
                                                                                                                                                                     {
                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                            "/runtime_tags/ResultErr",
-                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/ResultErr/type",
+                                                                                                                                                                            "/runtime_tags/OptionSome",
+                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/OptionSome/type",
                                                                                                                                                                         keyword: "type",
                                                                                                                                                                         params: {
                                                                                                                                                                             type: "integer",
@@ -75191,8 +75320,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                         [
                                                                                                                                                                             {
                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                    "/runtime_tags/ResultErr",
-                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/ResultErr/maximum",
+                                                                                                                                                                                    "/runtime_tags/OptionSome",
+                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/OptionSome/maximum",
                                                                                                                                                                                 keyword: "maximum",
                                                                                                                                                                                 params: {
                                                                                                                                                                                     comparison: "<=",
@@ -75211,8 +75340,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                             [
                                                                                                                                                                                 {
                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                        "/runtime_tags/ResultErr",
-                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/ResultErr/minimum",
+                                                                                                                                                                                        "/runtime_tags/OptionSome",
+                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/OptionSome/minimum",
                                                                                                                                                                                     keyword: "minimum",
                                                                                                                                                                                     params: {
                                                                                                                                                                                         comparison: ">=",
@@ -75233,9 +75362,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                         var valid2 = true;
                                                                                                                                                     }
                                                                                                                                                     if (valid2) {
-                                                                                                                                                        if (data4.ResultOk !==
+                                                                                                                                                        if (data4.ResultErr !==
                                                                                                                                                             undefined) {
-                                                                                                                                                            let data32 = data4.ResultOk;
+                                                                                                                                                            let data32 = data4.ResultErr;
                                                                                                                                                             const _errs65 = errors;
                                                                                                                                                             if (!(typeof data32 ==
                                                                                                                                                                 "number" &&
@@ -75247,8 +75376,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                     [
                                                                                                                                                                         {
                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                "/runtime_tags/ResultOk",
-                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/ResultOk/type",
+                                                                                                                                                                                "/runtime_tags/ResultErr",
+                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/ResultErr/type",
                                                                                                                                                                             keyword: "type",
                                                                                                                                                                             params: {
                                                                                                                                                                                 type: "integer",
@@ -75270,8 +75399,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                             [
                                                                                                                                                                                 {
                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                        "/runtime_tags/ResultOk",
-                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/ResultOk/maximum",
+                                                                                                                                                                                        "/runtime_tags/ResultErr",
+                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/ResultErr/maximum",
                                                                                                                                                                                     keyword: "maximum",
                                                                                                                                                                                     params: {
                                                                                                                                                                                         comparison: "<=",
@@ -75290,8 +75419,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                 [
                                                                                                                                                                                     {
                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                            "/runtime_tags/ResultOk",
-                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/ResultOk/minimum",
+                                                                                                                                                                                            "/runtime_tags/ResultErr",
+                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/ResultErr/minimum",
                                                                                                                                                                                         keyword: "minimum",
                                                                                                                                                                                         params: {
                                                                                                                                                                                             comparison: ">=",
@@ -75312,9 +75441,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                             var valid2 = true;
                                                                                                                                                         }
                                                                                                                                                         if (valid2) {
-                                                                                                                                                            if (data4.SendErrorBackpressure !==
+                                                                                                                                                            if (data4.ResultOk !==
                                                                                                                                                                 undefined) {
-                                                                                                                                                                let data33 = data4.SendErrorBackpressure;
+                                                                                                                                                                let data33 = data4.ResultOk;
                                                                                                                                                                 const _errs67 = errors;
                                                                                                                                                                 if (!(typeof data33 ==
                                                                                                                                                                     "number" &&
@@ -75326,8 +75455,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                         [
                                                                                                                                                                             {
                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                    "/runtime_tags/SendErrorBackpressure",
-                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorBackpressure/type",
+                                                                                                                                                                                    "/runtime_tags/ResultOk",
+                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/ResultOk/type",
                                                                                                                                                                                 keyword: "type",
                                                                                                                                                                                 params: {
                                                                                                                                                                                     type: "integer",
@@ -75349,8 +75478,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                 [
                                                                                                                                                                                     {
                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                            "/runtime_tags/SendErrorBackpressure",
-                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorBackpressure/maximum",
+                                                                                                                                                                                            "/runtime_tags/ResultOk",
+                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/ResultOk/maximum",
                                                                                                                                                                                         keyword: "maximum",
                                                                                                                                                                                         params: {
                                                                                                                                                                                             comparison: "<=",
@@ -75369,8 +75498,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                     [
                                                                                                                                                                                         {
                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                "/runtime_tags/SendErrorBackpressure",
-                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorBackpressure/minimum",
+                                                                                                                                                                                                "/runtime_tags/ResultOk",
+                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/ResultOk/minimum",
                                                                                                                                                                                             keyword: "minimum",
                                                                                                                                                                                             params: {
                                                                                                                                                                                                 comparison: ">=",
@@ -75391,9 +75520,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                 var valid2 = true;
                                                                                                                                                             }
                                                                                                                                                             if (valid2) {
-                                                                                                                                                                if (data4.SendErrorCancelled !==
+                                                                                                                                                                if (data4.SendErrorBackpressure !==
                                                                                                                                                                     undefined) {
-                                                                                                                                                                    let data34 = data4.SendErrorCancelled;
+                                                                                                                                                                    let data34 = data4.SendErrorBackpressure;
                                                                                                                                                                     const _errs69 = errors;
                                                                                                                                                                     if (!(typeof data34 ==
                                                                                                                                                                         "number" &&
@@ -75405,8 +75534,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                             [
                                                                                                                                                                                 {
                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                        "/runtime_tags/SendErrorCancelled",
-                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorCancelled/type",
+                                                                                                                                                                                        "/runtime_tags/SendErrorBackpressure",
+                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorBackpressure/type",
                                                                                                                                                                                     keyword: "type",
                                                                                                                                                                                     params: {
                                                                                                                                                                                         type: "integer",
@@ -75428,8 +75557,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                     [
                                                                                                                                                                                         {
                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                "/runtime_tags/SendErrorCancelled",
-                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorCancelled/maximum",
+                                                                                                                                                                                                "/runtime_tags/SendErrorBackpressure",
+                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorBackpressure/maximum",
                                                                                                                                                                                             keyword: "maximum",
                                                                                                                                                                                             params: {
                                                                                                                                                                                                 comparison: "<=",
@@ -75448,8 +75577,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                         [
                                                                                                                                                                                             {
                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                    "/runtime_tags/SendErrorCancelled",
-                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorCancelled/minimum",
+                                                                                                                                                                                                    "/runtime_tags/SendErrorBackpressure",
+                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorBackpressure/minimum",
                                                                                                                                                                                                 keyword: "minimum",
                                                                                                                                                                                                 params: {
                                                                                                                                                                                                     comparison: ">=",
@@ -75470,9 +75599,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                     var valid2 = true;
                                                                                                                                                                 }
                                                                                                                                                                 if (valid2) {
-                                                                                                                                                                    if (data4.SendErrorClosed !==
+                                                                                                                                                                    if (data4.SendErrorCancelled !==
                                                                                                                                                                         undefined) {
-                                                                                                                                                                        let data35 = data4.SendErrorClosed;
+                                                                                                                                                                        let data35 = data4.SendErrorCancelled;
                                                                                                                                                                         const _errs71 = errors;
                                                                                                                                                                         if (!(typeof data35 ==
                                                                                                                                                                             "number" &&
@@ -75484,8 +75613,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                 [
                                                                                                                                                                                     {
                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                            "/runtime_tags/SendErrorClosed",
-                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorClosed/type",
+                                                                                                                                                                                            "/runtime_tags/SendErrorCancelled",
+                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorCancelled/type",
                                                                                                                                                                                         keyword: "type",
                                                                                                                                                                                         params: {
                                                                                                                                                                                             type: "integer",
@@ -75507,8 +75636,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                         [
                                                                                                                                                                                             {
                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                    "/runtime_tags/SendErrorClosed",
-                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorClosed/maximum",
+                                                                                                                                                                                                    "/runtime_tags/SendErrorCancelled",
+                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorCancelled/maximum",
                                                                                                                                                                                                 keyword: "maximum",
                                                                                                                                                                                                 params: {
                                                                                                                                                                                                     comparison: "<=",
@@ -75527,8 +75656,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                             [
                                                                                                                                                                                                 {
                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                        "/runtime_tags/SendErrorClosed",
-                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorClosed/minimum",
+                                                                                                                                                                                                        "/runtime_tags/SendErrorCancelled",
+                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorCancelled/minimum",
                                                                                                                                                                                                     keyword: "minimum",
                                                                                                                                                                                                     params: {
                                                                                                                                                                                                         comparison: ">=",
@@ -75549,9 +75678,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                         var valid2 = true;
                                                                                                                                                                     }
                                                                                                                                                                     if (valid2) {
-                                                                                                                                                                        if (data4.SendErrorDead !==
+                                                                                                                                                                        if (data4.SendErrorClosed !==
                                                                                                                                                                             undefined) {
-                                                                                                                                                                            let data36 = data4.SendErrorDead;
+                                                                                                                                                                            let data36 = data4.SendErrorClosed;
                                                                                                                                                                             const _errs73 = errors;
                                                                                                                                                                             if (!(typeof data36 ==
                                                                                                                                                                                 "number" &&
@@ -75563,8 +75692,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                     [
                                                                                                                                                                                         {
                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                "/runtime_tags/SendErrorDead",
-                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorDead/type",
+                                                                                                                                                                                                "/runtime_tags/SendErrorClosed",
+                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorClosed/type",
                                                                                                                                                                                             keyword: "type",
                                                                                                                                                                                             params: {
                                                                                                                                                                                                 type: "integer",
@@ -75586,8 +75715,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                             [
                                                                                                                                                                                                 {
                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                        "/runtime_tags/SendErrorDead",
-                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorDead/maximum",
+                                                                                                                                                                                                        "/runtime_tags/SendErrorClosed",
+                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorClosed/maximum",
                                                                                                                                                                                                     keyword: "maximum",
                                                                                                                                                                                                     params: {
                                                                                                                                                                                                         comparison: "<=",
@@ -75606,8 +75735,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                 [
                                                                                                                                                                                                     {
                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                            "/runtime_tags/SendErrorDead",
-                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorDead/minimum",
+                                                                                                                                                                                                            "/runtime_tags/SendErrorClosed",
+                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorClosed/minimum",
                                                                                                                                                                                                         keyword: "minimum",
                                                                                                                                                                                                         params: {
                                                                                                                                                                                                             comparison: ">=",
@@ -75628,9 +75757,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                             var valid2 = true;
                                                                                                                                                                         }
                                                                                                                                                                         if (valid2) {
-                                                                                                                                                                            if (data4.SendErrorFull !==
+                                                                                                                                                                            if (data4.SendErrorDead !==
                                                                                                                                                                                 undefined) {
-                                                                                                                                                                                let data37 = data4.SendErrorFull;
+                                                                                                                                                                                let data37 = data4.SendErrorDead;
                                                                                                                                                                                 const _errs75 = errors;
                                                                                                                                                                                 if (!(typeof data37 ==
                                                                                                                                                                                     "number" &&
@@ -75642,8 +75771,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                         [
                                                                                                                                                                                             {
                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                    "/runtime_tags/SendErrorFull",
-                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorFull/type",
+                                                                                                                                                                                                    "/runtime_tags/SendErrorDead",
+                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorDead/type",
                                                                                                                                                                                                 keyword: "type",
                                                                                                                                                                                                 params: {
                                                                                                                                                                                                     type: "integer",
@@ -75665,8 +75794,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                 [
                                                                                                                                                                                                     {
                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                            "/runtime_tags/SendErrorFull",
-                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorFull/maximum",
+                                                                                                                                                                                                            "/runtime_tags/SendErrorDead",
+                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorDead/maximum",
                                                                                                                                                                                                         keyword: "maximum",
                                                                                                                                                                                                         params: {
                                                                                                                                                                                                             comparison: "<=",
@@ -75685,8 +75814,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                     [
                                                                                                                                                                                                         {
                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                "/runtime_tags/SendErrorFull",
-                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorFull/minimum",
+                                                                                                                                                                                                                "/runtime_tags/SendErrorDead",
+                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorDead/minimum",
                                                                                                                                                                                                             keyword: "minimum",
                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                 comparison: ">=",
@@ -75707,9 +75836,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                 var valid2 = true;
                                                                                                                                                                             }
                                                                                                                                                                             if (valid2) {
-                                                                                                                                                                                if (data4.SendErrorInvalidMessage !==
+                                                                                                                                                                                if (data4.SendErrorFull !==
                                                                                                                                                                                     undefined) {
-                                                                                                                                                                                    let data38 = data4.SendErrorInvalidMessage;
+                                                                                                                                                                                    let data38 = data4.SendErrorFull;
                                                                                                                                                                                     const _errs77 = errors;
                                                                                                                                                                                     if (!(typeof data38 ==
                                                                                                                                                                                         "number" &&
@@ -75721,8 +75850,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                             [
                                                                                                                                                                                                 {
                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                        "/runtime_tags/SendErrorInvalidMessage",
-                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorInvalidMessage/type",
+                                                                                                                                                                                                        "/runtime_tags/SendErrorFull",
+                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorFull/type",
                                                                                                                                                                                                     keyword: "type",
                                                                                                                                                                                                     params: {
                                                                                                                                                                                                         type: "integer",
@@ -75744,8 +75873,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                     [
                                                                                                                                                                                                         {
                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                "/runtime_tags/SendErrorInvalidMessage",
-                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorInvalidMessage/maximum",
+                                                                                                                                                                                                                "/runtime_tags/SendErrorFull",
+                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorFull/maximum",
                                                                                                                                                                                                             keyword: "maximum",
                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                 comparison: "<=",
@@ -75764,8 +75893,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                         [
                                                                                                                                                                                                             {
                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                    "/runtime_tags/SendErrorInvalidMessage",
-                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorInvalidMessage/minimum",
+                                                                                                                                                                                                                    "/runtime_tags/SendErrorFull",
+                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorFull/minimum",
                                                                                                                                                                                                                 keyword: "minimum",
                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                     comparison: ">=",
@@ -75786,9 +75915,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                     var valid2 = true;
                                                                                                                                                                                 }
                                                                                                                                                                                 if (valid2) {
-                                                                                                                                                                                    if (data4.SendErrorLocalShutdown !==
+                                                                                                                                                                                    if (data4.SendErrorInvalidMessage !==
                                                                                                                                                                                         undefined) {
-                                                                                                                                                                                        let data39 = data4.SendErrorLocalShutdown;
+                                                                                                                                                                                        let data39 = data4.SendErrorInvalidMessage;
                                                                                                                                                                                         const _errs79 = errors;
                                                                                                                                                                                         if (!(typeof data39 ==
                                                                                                                                                                                             "number" &&
@@ -75800,8 +75929,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                 [
                                                                                                                                                                                                     {
                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                            "/runtime_tags/SendErrorLocalShutdown",
-                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorLocalShutdown/type",
+                                                                                                                                                                                                            "/runtime_tags/SendErrorInvalidMessage",
+                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorInvalidMessage/type",
                                                                                                                                                                                                         keyword: "type",
                                                                                                                                                                                                         params: {
                                                                                                                                                                                                             type: "integer",
@@ -75823,8 +75952,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                         [
                                                                                                                                                                                                             {
                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                    "/runtime_tags/SendErrorLocalShutdown",
-                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorLocalShutdown/maximum",
+                                                                                                                                                                                                                    "/runtime_tags/SendErrorInvalidMessage",
+                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorInvalidMessage/maximum",
                                                                                                                                                                                                                 keyword: "maximum",
                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                     comparison: "<=",
@@ -75843,8 +75972,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                             [
                                                                                                                                                                                                                 {
                                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                                        "/runtime_tags/SendErrorLocalShutdown",
-                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorLocalShutdown/minimum",
+                                                                                                                                                                                                                        "/runtime_tags/SendErrorInvalidMessage",
+                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorInvalidMessage/minimum",
                                                                                                                                                                                                                     keyword: "minimum",
                                                                                                                                                                                                                     params: {
                                                                                                                                                                                                                         comparison: ">=",
@@ -75865,9 +75994,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                         var valid2 = true;
                                                                                                                                                                                     }
                                                                                                                                                                                     if (valid2) {
-                                                                                                                                                                                        if (data4.SendErrorMessageTooLarge !==
+                                                                                                                                                                                        if (data4.SendErrorLocalShutdown !==
                                                                                                                                                                                             undefined) {
-                                                                                                                                                                                            let data40 = data4.SendErrorMessageTooLarge;
+                                                                                                                                                                                            let data40 = data4.SendErrorLocalShutdown;
                                                                                                                                                                                             const _errs81 = errors;
                                                                                                                                                                                             if (!(typeof data40 ==
                                                                                                                                                                                                 "number" &&
@@ -75879,8 +76008,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                     [
                                                                                                                                                                                                         {
                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                "/runtime_tags/SendErrorMessageTooLarge",
-                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorMessageTooLarge/type",
+                                                                                                                                                                                                                "/runtime_tags/SendErrorLocalShutdown",
+                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorLocalShutdown/type",
                                                                                                                                                                                                             keyword: "type",
                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                 type: "integer",
@@ -75902,8 +76031,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                             [
                                                                                                                                                                                                                 {
                                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                                        "/runtime_tags/SendErrorMessageTooLarge",
-                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorMessageTooLarge/maximum",
+                                                                                                                                                                                                                        "/runtime_tags/SendErrorLocalShutdown",
+                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorLocalShutdown/maximum",
                                                                                                                                                                                                                     keyword: "maximum",
                                                                                                                                                                                                                     params: {
                                                                                                                                                                                                                         comparison: "<=",
@@ -75922,8 +76051,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                 [
                                                                                                                                                                                                                     {
                                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                                            "/runtime_tags/SendErrorMessageTooLarge",
-                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorMessageTooLarge/minimum",
+                                                                                                                                                                                                                            "/runtime_tags/SendErrorLocalShutdown",
+                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorLocalShutdown/minimum",
                                                                                                                                                                                                                         keyword: "minimum",
                                                                                                                                                                                                                         params: {
                                                                                                                                                                                                                             comparison: ">=",
@@ -75944,9 +76073,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                             var valid2 = true;
                                                                                                                                                                                         }
                                                                                                                                                                                         if (valid2) {
-                                                                                                                                                                                            if (data4.SendErrorPartition !==
+                                                                                                                                                                                            if (data4.SendErrorMessageTooLarge !==
                                                                                                                                                                                                 undefined) {
-                                                                                                                                                                                                let data41 = data4.SendErrorPartition;
+                                                                                                                                                                                                let data41 = data4.SendErrorMessageTooLarge;
                                                                                                                                                                                                 const _errs83 = errors;
                                                                                                                                                                                                 if (!(typeof data41 ==
                                                                                                                                                                                                     "number" &&
@@ -75958,8 +76087,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                         [
                                                                                                                                                                                                             {
                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                    "/runtime_tags/SendErrorPartition",
-                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorPartition/type",
+                                                                                                                                                                                                                    "/runtime_tags/SendErrorMessageTooLarge",
+                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorMessageTooLarge/type",
                                                                                                                                                                                                                 keyword: "type",
                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                     type: "integer",
@@ -75981,8 +76110,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                 [
                                                                                                                                                                                                                     {
                                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                                            "/runtime_tags/SendErrorPartition",
-                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorPartition/maximum",
+                                                                                                                                                                                                                            "/runtime_tags/SendErrorMessageTooLarge",
+                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorMessageTooLarge/maximum",
                                                                                                                                                                                                                         keyword: "maximum",
                                                                                                                                                                                                                         params: {
                                                                                                                                                                                                                             comparison: "<=",
@@ -76001,8 +76130,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                     [
                                                                                                                                                                                                                         {
                                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                                "/runtime_tags/SendErrorPartition",
-                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorPartition/minimum",
+                                                                                                                                                                                                                                "/runtime_tags/SendErrorMessageTooLarge",
+                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorMessageTooLarge/minimum",
                                                                                                                                                                                                                             keyword: "minimum",
                                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                                 comparison: ">=",
@@ -76023,9 +76152,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                 var valid2 = true;
                                                                                                                                                                                             }
                                                                                                                                                                                             if (valid2) {
-                                                                                                                                                                                                if (data4.SendErrorStaleRef !==
+                                                                                                                                                                                                if (data4.SendErrorPartition !==
                                                                                                                                                                                                     undefined) {
-                                                                                                                                                                                                    let data42 = data4.SendErrorStaleRef;
+                                                                                                                                                                                                    let data42 = data4.SendErrorPartition;
                                                                                                                                                                                                     const _errs85 = errors;
                                                                                                                                                                                                     if (!(typeof data42 ==
                                                                                                                                                                                                         "number" &&
@@ -76037,8 +76166,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                             [
                                                                                                                                                                                                                 {
                                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                                        "/runtime_tags/SendErrorStaleRef",
-                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorStaleRef/type",
+                                                                                                                                                                                                                        "/runtime_tags/SendErrorPartition",
+                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorPartition/type",
                                                                                                                                                                                                                     keyword: "type",
                                                                                                                                                                                                                     params: {
                                                                                                                                                                                                                         type: "integer",
@@ -76060,8 +76189,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                     [
                                                                                                                                                                                                                         {
                                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                                "/runtime_tags/SendErrorStaleRef",
-                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorStaleRef/maximum",
+                                                                                                                                                                                                                                "/runtime_tags/SendErrorPartition",
+                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorPartition/maximum",
                                                                                                                                                                                                                             keyword: "maximum",
                                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                                 comparison: "<=",
@@ -76080,8 +76209,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                         [
                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                                    "/runtime_tags/SendErrorStaleRef",
-                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorStaleRef/minimum",
+                                                                                                                                                                                                                                    "/runtime_tags/SendErrorPartition",
+                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorPartition/minimum",
                                                                                                                                                                                                                                 keyword: "minimum",
                                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                                     comparison: ">=",
@@ -76102,9 +76231,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                     var valid2 = true;
                                                                                                                                                                                                 }
                                                                                                                                                                                                 if (valid2) {
-                                                                                                                                                                                                    if (data4.SendErrorTimedOut !==
+                                                                                                                                                                                                    if (data4.SendErrorStaleRef !==
                                                                                                                                                                                                         undefined) {
-                                                                                                                                                                                                        let data43 = data4.SendErrorTimedOut;
+                                                                                                                                                                                                        let data43 = data4.SendErrorStaleRef;
                                                                                                                                                                                                         const _errs87 = errors;
                                                                                                                                                                                                         if (!(typeof data43 ==
                                                                                                                                                                                                             "number" &&
@@ -76116,8 +76245,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                 [
                                                                                                                                                                                                                     {
                                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                                            "/runtime_tags/SendErrorTimedOut",
-                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorTimedOut/type",
+                                                                                                                                                                                                                            "/runtime_tags/SendErrorStaleRef",
+                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorStaleRef/type",
                                                                                                                                                                                                                         keyword: "type",
                                                                                                                                                                                                                         params: {
                                                                                                                                                                                                                             type: "integer",
@@ -76139,8 +76268,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                         [
                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                                    "/runtime_tags/SendErrorTimedOut",
-                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorTimedOut/maximum",
+                                                                                                                                                                                                                                    "/runtime_tags/SendErrorStaleRef",
+                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorStaleRef/maximum",
                                                                                                                                                                                                                                 keyword: "maximum",
                                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                                     comparison: "<=",
@@ -76159,8 +76288,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                             [
                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                                                        "/runtime_tags/SendErrorTimedOut",
-                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorTimedOut/minimum",
+                                                                                                                                                                                                                                        "/runtime_tags/SendErrorStaleRef",
+                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorStaleRef/minimum",
                                                                                                                                                                                                                                     keyword: "minimum",
                                                                                                                                                                                                                                     params: {
                                                                                                                                                                                                                                         comparison: ">=",
@@ -76181,9 +76310,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                         var valid2 = true;
                                                                                                                                                                                                     }
                                                                                                                                                                                                     if (valid2) {
-                                                                                                                                                                                                        if (data4.SendErrorUnauthorized !==
+                                                                                                                                                                                                        if (data4.SendErrorTimedOut !==
                                                                                                                                                                                                             undefined) {
-                                                                                                                                                                                                            let data44 = data4.SendErrorUnauthorized;
+                                                                                                                                                                                                            let data44 = data4.SendErrorTimedOut;
                                                                                                                                                                                                             const _errs89 = errors;
                                                                                                                                                                                                             if (!(typeof data44 ==
                                                                                                                                                                                                                 "number" &&
@@ -76195,8 +76324,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                     [
                                                                                                                                                                                                                         {
                                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                                "/runtime_tags/SendErrorUnauthorized",
-                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorUnauthorized/type",
+                                                                                                                                                                                                                                "/runtime_tags/SendErrorTimedOut",
+                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorTimedOut/type",
                                                                                                                                                                                                                             keyword: "type",
                                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                                 type: "integer",
@@ -76218,8 +76347,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                             [
                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                                                        "/runtime_tags/SendErrorUnauthorized",
-                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorUnauthorized/maximum",
+                                                                                                                                                                                                                                        "/runtime_tags/SendErrorTimedOut",
+                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorTimedOut/maximum",
                                                                                                                                                                                                                                     keyword: "maximum",
                                                                                                                                                                                                                                     params: {
                                                                                                                                                                                                                                         comparison: "<=",
@@ -76238,8 +76367,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                                 [
                                                                                                                                                                                                                                     {
                                                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                                                            "/runtime_tags/SendErrorUnauthorized",
-                                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorUnauthorized/minimum",
+                                                                                                                                                                                                                                            "/runtime_tags/SendErrorTimedOut",
+                                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorTimedOut/minimum",
                                                                                                                                                                                                                                         keyword: "minimum",
                                                                                                                                                                                                                                         params: {
                                                                                                                                                                                                                                             comparison: ">=",
@@ -76260,9 +76389,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                             var valid2 = true;
                                                                                                                                                                                                         }
                                                                                                                                                                                                         if (valid2) {
-                                                                                                                                                                                                            if (data4.SendErrorVersionMismatch !==
+                                                                                                                                                                                                            if (data4.SendErrorUnauthorized !==
                                                                                                                                                                                                                 undefined) {
-                                                                                                                                                                                                                let data45 = data4.SendErrorVersionMismatch;
+                                                                                                                                                                                                                let data45 = data4.SendErrorUnauthorized;
                                                                                                                                                                                                                 const _errs91 = errors;
                                                                                                                                                                                                                 if (!(typeof data45 ==
                                                                                                                                                                                                                     "number" &&
@@ -76274,8 +76403,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                         [
                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                                    "/runtime_tags/SendErrorVersionMismatch",
-                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorVersionMismatch/type",
+                                                                                                                                                                                                                                    "/runtime_tags/SendErrorUnauthorized",
+                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorUnauthorized/type",
                                                                                                                                                                                                                                 keyword: "type",
                                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                                     type: "integer",
@@ -76297,8 +76426,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                                 [
                                                                                                                                                                                                                                     {
                                                                                                                                                                                                                                         instancePath: instancePath +
-                                                                                                                                                                                                                                            "/runtime_tags/SendErrorVersionMismatch",
-                                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorVersionMismatch/maximum",
+                                                                                                                                                                                                                                            "/runtime_tags/SendErrorUnauthorized",
+                                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorUnauthorized/maximum",
                                                                                                                                                                                                                                         keyword: "maximum",
                                                                                                                                                                                                                                         params: {
                                                                                                                                                                                                                                             comparison: "<=",
@@ -76317,8 +76446,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                                     [
                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                                                "/runtime_tags/SendErrorVersionMismatch",
-                                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorVersionMismatch/minimum",
+                                                                                                                                                                                                                                                "/runtime_tags/SendErrorUnauthorized",
+                                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorUnauthorized/minimum",
                                                                                                                                                                                                                                             keyword: "minimum",
                                                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                                                 comparison: ">=",
@@ -76339,9 +76468,9 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                 var valid2 = true;
                                                                                                                                                                                                             }
                                                                                                                                                                                                             if (valid2) {
-                                                                                                                                                                                                                if (data4.SendErrorWriteTimedOut !==
+                                                                                                                                                                                                                if (data4.SendErrorVersionMismatch !==
                                                                                                                                                                                                                     undefined) {
-                                                                                                                                                                                                                    let data46 = data4.SendErrorWriteTimedOut;
+                                                                                                                                                                                                                    let data46 = data4.SendErrorVersionMismatch;
                                                                                                                                                                                                                     const _errs93 = errors;
                                                                                                                                                                                                                     if (!(typeof data46 ==
                                                                                                                                                                                                                         "number" &&
@@ -76353,8 +76482,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                             [
                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                     instancePath: instancePath +
-                                                                                                                                                                                                                                        "/runtime_tags/SendErrorWriteTimedOut",
-                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorWriteTimedOut/type",
+                                                                                                                                                                                                                                        "/runtime_tags/SendErrorVersionMismatch",
+                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorVersionMismatch/type",
                                                                                                                                                                                                                                     keyword: "type",
                                                                                                                                                                                                                                     params: {
                                                                                                                                                                                                                                         type: "integer",
@@ -76376,8 +76505,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                                     [
                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                             instancePath: instancePath +
-                                                                                                                                                                                                                                                "/runtime_tags/SendErrorWriteTimedOut",
-                                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorWriteTimedOut/maximum",
+                                                                                                                                                                                                                                                "/runtime_tags/SendErrorVersionMismatch",
+                                                                                                                                                                                                                                            schemaPath: "#/properties/runtime_tags/properties/SendErrorVersionMismatch/maximum",
                                                                                                                                                                                                                                             keyword: "maximum",
                                                                                                                                                                                                                                             params: {
                                                                                                                                                                                                                                                 comparison: "<=",
@@ -76396,8 +76525,8 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                                         [
                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                 instancePath: instancePath +
-                                                                                                                                                                                                                                                    "/runtime_tags/SendErrorWriteTimedOut",
-                                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorWriteTimedOut/minimum",
+                                                                                                                                                                                                                                                    "/runtime_tags/SendErrorVersionMismatch",
+                                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorVersionMismatch/minimum",
                                                                                                                                                                                                                                                 keyword: "minimum",
                                                                                                                                                                                                                                                 params: {
                                                                                                                                                                                                                                                     comparison: ">=",
@@ -76417,6 +76546,86 @@ function validate349(data, { instancePath = "", parentData, parentDataProperty,
                                                                                                                                                                                                                 else {
                                                                                                                                                                                                                     var valid2 = true;
                                                                                                                                                                                                                 }
+                                                                                                                                                                                                                if (valid2) {
+                                                                                                                                                                                                                    if (data4.SendErrorWriteTimedOut !==
+                                                                                                                                                                                                                        undefined) {
+                                                                                                                                                                                                                        let data47 = data4.SendErrorWriteTimedOut;
+                                                                                                                                                                                                                        const _errs95 = errors;
+                                                                                                                                                                                                                        if (!(typeof data47 ==
+                                                                                                                                                                                                                            "number" &&
+                                                                                                                                                                                                                            !(data47 %
+                                                                                                                                                                                                                                1) &&
+                                                                                                                                                                                                                            !isNaN(data47) &&
+                                                                                                                                                                                                                            isFinite(data47))) {
+                                                                                                                                                                                                                            validate349.errors =
+                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                    {
+                                                                                                                                                                                                                                        instancePath: instancePath +
+                                                                                                                                                                                                                                            "/runtime_tags/SendErrorWriteTimedOut",
+                                                                                                                                                                                                                                        schemaPath: "#/properties/runtime_tags/properties/SendErrorWriteTimedOut/type",
+                                                                                                                                                                                                                                        keyword: "type",
+                                                                                                                                                                                                                                        params: {
+                                                                                                                                                                                                                                            type: "integer",
+                                                                                                                                                                                                                                        },
+                                                                                                                                                                                                                                        message: "must be integer",
+                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                ];
+                                                                                                                                                                                                                            return false;
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                        if (errors ===
+                                                                                                                                                                                                                            _errs95) {
+                                                                                                                                                                                                                            if (typeof data47 ==
+                                                                                                                                                                                                                                "number" &&
+                                                                                                                                                                                                                                isFinite(data47)) {
+                                                                                                                                                                                                                                if (data47 >
+                                                                                                                                                                                                                                    4294967295 ||
+                                                                                                                                                                                                                                    isNaN(data47)) {
+                                                                                                                                                                                                                                    validate349.errors =
+                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                            {
+                                                                                                                                                                                                                                                instancePath: instancePath +
+                                                                                                                                                                                                                                                    "/runtime_tags/SendErrorWriteTimedOut",
+                                                                                                                                                                                                                                                schemaPath: "#/properties/runtime_tags/properties/SendErrorWriteTimedOut/maximum",
+                                                                                                                                                                                                                                                keyword: "maximum",
+                                                                                                                                                                                                                                                params: {
+                                                                                                                                                                                                                                                    comparison: "<=",
+                                                                                                                                                                                                                                                    limit: 4294967295,
+                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                message: "must be <= 4294967295",
+                                                                                                                                                                                                                                            },
+                                                                                                                                                                                                                                        ];
+                                                                                                                                                                                                                                    return false;
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                else {
+                                                                                                                                                                                                                                    if (data47 <
+                                                                                                                                                                                                                                        0 ||
+                                                                                                                                                                                                                                        isNaN(data47)) {
+                                                                                                                                                                                                                                        validate349.errors =
+                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                {
+                                                                                                                                                                                                                                                    instancePath: instancePath +
+                                                                                                                                                                                                                                                        "/runtime_tags/SendErrorWriteTimedOut",
+                                                                                                                                                                                                                                                    schemaPath: "#/properties/runtime_tags/properties/SendErrorWriteTimedOut/minimum",
+                                                                                                                                                                                                                                                    keyword: "minimum",
+                                                                                                                                                                                                                                                    params: {
+                                                                                                                                                                                                                                                        comparison: ">=",
+                                                                                                                                                                                                                                                        limit: 0,
+                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                    message: "must be >= 0",
+                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                            ];
+                                                                                                                                                                                                                                        return false;
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                        var valid2 = _errs95 ===
+                                                                                                                                                                                                                            errors;
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                    else {
+                                                                                                                                                                                                                        var valid2 = true;
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                }
                                                                                                                                                                                                             }
                                                                                                                                                                                                         }
                                                                                                                                                                                                     }