openclaw-brokerkit 0.1.0 → 0.3.0

package/dist/src/generated/operator-validators.js

@@ -0,0 +1,2920 @@
+/* eslint-disable */
+// @ts-nocheck -- generated Ajv standalone code
+// Generated from protocol/openapi/operator-v1.yaml. Do not edit.
+import formatsModule from "ajv-formats/dist/formats.js";
+import equal from "ajv/dist/runtime/equal.js";
+import ucs2length from "ajv/dist/runtime/ucs2length.js";
+const formats = formatsModule.fullFormats;
+"use strict";
+export const validateDescriptor = validate20;
+const schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/Descriptor", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Descriptor" };
+const schema33 = { "type": "object", "additionalProperties": false, "required": ["api_version"], "properties": { "api_version": { "type": "string", "const": "brokerkit.io/operator/v1" } } };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/Descriptor" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate20.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} const _errs0 = errors; if (errors === _errs0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((data.api_version === undefined) && (missing0 = "api_version")) {
+            validate20.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Descriptor/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs2 = errors;
+            for (const key0 in data) {
+                if (!(key0 === "api_version")) {
+                    validate20.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Descriptor/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs2 === errors) {
+                if (data.api_version !== undefined) {
+                    let data0 = data.api_version;
+                    if (typeof data0 !== "string") {
+                        validate20.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Descriptor/properties/api_version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if ("brokerkit.io/operator/v1" !== data0) {
+                        validate20.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Descriptor/properties/api_version/const", keyword: "const", params: { allowedValue: "brokerkit.io/operator/v1" }, message: "must be equal to constant" }];
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate20.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Descriptor/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate20.errors = vErrors; return errors === 0; }
+validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateHealth = validate22;
+const schema34 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/Health", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health" };
+const schema35 = { "type": "object", "additionalProperties": false, "required": ["status"], "properties": { "status": { "type": "string", "minLength": 1, "maxLength": 128 } } };
+const func1 = ucs2length;
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/Health" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate22.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} const _errs0 = errors; if (errors === _errs0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((data.status === undefined) && (missing0 = "status")) {
+            validate22.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs2 = errors;
+            for (const key0 in data) {
+                if (!(key0 === "status")) {
+                    validate22.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs2 === errors) {
+                if (data.status !== undefined) {
+                    let data0 = data.status;
+                    const _errs3 = errors;
+                    if (errors === _errs3) {
+                        if (typeof data0 === "string") {
+                            if (func1(data0) > 128) {
+                                validate22.errors = [{ instancePath: instancePath + "/status", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health/properties/status/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                return false;
+                            }
+                            else {
+                                if (func1(data0) < 1) {
+                                    validate22.errors = [{ instancePath: instancePath + "/status", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health/properties/status/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            validate22.errors = [{ instancePath: instancePath + "/status", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health/properties/status/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate22.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/Health/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate22.errors = vErrors; return errors === 0; }
+validate22.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateBrokerRequest = validate23;
+const schema36 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/BrokerRequest", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/BrokerRequest" };
+const schema37 = { "type": "object", "additionalProperties": false, "required": ["id", "revision", "requester", "operation", "status", "requested_at", "requested_duration_seconds", "requested_max_uses", "granted_max_uses", "used_count", "presentation", "allowed_actions"], "properties": { "id": { "type": "string", "minLength": 1, "maxLength": 128 }, "revision": { "type": "integer", "minimum": 1 }, "requester": { "type": "string", "minLength": 1, "maxLength": 80 }, "operation": { "type": "string", "minLength": 1, "maxLength": 500 }, "status": { "$ref": "#/$defs/Status" }, "requested_at": { "type": "string", "format": "date-time" }, "pending_expires_at": { "type": "string", "format": "date-time" }, "active_expires_at": { "type": "string", "format": "date-time" }, "requested_duration_seconds": { "type": "integer", "minimum": 1 }, "requested_max_uses": { "type": ["integer", "null"], "minimum": 1 }, "granted_max_uses": { "type": ["integer", "null"], "minimum": 1 }, "used_count": { "type": "integer", "minimum": 0 }, "request_reason": { "type": "string", "maxLength": 2000 }, "decided_at": { "type": "string", "format": "date-time" }, "decided_by": { "type": "string", "maxLength": 200 }, "decided_on_behalf_of": { "type": "string", "maxLength": 200 }, "presentation": { "$ref": "#/$defs/Presentation" }, "presentation_unavailable": { "type": "boolean" }, "allowed_actions": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/Action" } }, "approval_bounds": { "$ref": "#/$defs/ApprovalBounds" } } };
+const schema38 = { "type": "string", "enum": ["pending", "active", "denied", "canceled", "expired", "consumed", "revoked"] };
+const schema44 = { "type": "string", "enum": ["approve", "deny", "revoke"] };
+const schema45 = { "type": "object", "additionalProperties": false, "required": ["max_duration_seconds", "max_uses"], "properties": { "max_duration_seconds": { "type": "integer", "minimum": 1 }, "max_uses": { "type": ["integer", "null"], "minimum": 1 } } };
+const func3 = Object.prototype.hasOwnProperty;
+const func0 = equal;
+const formats0 = formats["date-time"];
+const schema39 = { "type": "object", "additionalProperties": false, "required": ["risk", "title", "target"], "properties": { "risk": { "$ref": "#/$defs/PresentationRisk" }, "title": { "type": "string", "minLength": 1, "maxLength": 200 }, "summary": { "type": "string", "maxLength": 2000 }, "target": { "type": "string", "minLength": 1, "maxLength": 500 }, "facts": { "type": "array", "maxItems": 20, "items": { "$ref": "#/$defs/Fact" } }, "warnings": { "type": "array", "maxItems": 10, "items": { "$ref": "#/$defs/Warning" } }, "plan_hash": { "type": "string", "maxLength": 128 } } };
+const schema40 = { "type": "string", "enum": ["unknown", "low", "medium", "high", "critical"] };
+const schema41 = { "type": "object", "additionalProperties": false, "required": ["label", "value"], "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80 }, "value": { "type": "string", "minLength": 1, "maxLength": 500 } } };
+const schema42 = { "type": "object", "additionalProperties": false, "required": ["severity", "text"], "properties": { "severity": { "$ref": "#/$defs/PresentationRisk" }, "text": { "type": "string", "minLength": 1, "maxLength": 500 } } };
+function validate26(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate26.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((data.severity === undefined) && (missing0 = "severity")) || ((data.text === undefined) && (missing0 = "text"))) {
+            validate26.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!((key0 === "severity") || (key0 === "text"))) {
+                    validate26.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.severity !== undefined) {
+                    let data0 = data.severity;
+                    const _errs2 = errors;
+                    if (typeof data0 !== "string") {
+                        validate26.errors = [{ instancePath: instancePath + "/severity", schemaPath: "#/$defs/PresentationRisk/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if (!(((((data0 === "unknown") || (data0 === "low")) || (data0 === "medium")) || (data0 === "high")) || (data0 === "critical"))) {
+                        validate26.errors = [{ instancePath: instancePath + "/severity", schemaPath: "#/$defs/PresentationRisk/enum", keyword: "enum", params: { allowedValues: schema40.enum }, message: "must be equal to one of the allowed values" }];
+                        return false;
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.text !== undefined) {
+                        let data1 = data.text;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 500) {
+                                    validate26.errors = [{ instancePath: instancePath + "/text", schemaPath: "#/properties/text/maxLength", keyword: "maxLength", params: { limit: 500 }, message: "must NOT have more than 500 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate26.errors = [{ instancePath: instancePath + "/text", schemaPath: "#/properties/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate26.errors = [{ instancePath: instancePath + "/text", schemaPath: "#/properties/text/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs5 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate26.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate26.errors = vErrors; return errors === 0; }
+validate26.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate25.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((((data.risk === undefined) && (missing0 = "risk")) || ((data.title === undefined) && (missing0 = "title"))) || ((data.target === undefined) && (missing0 = "target"))) {
+            validate25.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!(((((((key0 === "risk") || (key0 === "title")) || (key0 === "summary")) || (key0 === "target")) || (key0 === "facts")) || (key0 === "warnings")) || (key0 === "plan_hash"))) {
+                    validate25.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.risk !== undefined) {
+                    let data0 = data.risk;
+                    const _errs2 = errors;
+                    if (typeof data0 !== "string") {
+                        validate25.errors = [{ instancePath: instancePath + "/risk", schemaPath: "#/$defs/PresentationRisk/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if (!(((((data0 === "unknown") || (data0 === "low")) || (data0 === "medium")) || (data0 === "high")) || (data0 === "critical"))) {
+                        validate25.errors = [{ instancePath: instancePath + "/risk", schemaPath: "#/$defs/PresentationRisk/enum", keyword: "enum", params: { allowedValues: schema40.enum }, message: "must be equal to one of the allowed values" }];
+                        return false;
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.title !== undefined) {
+                        let data1 = data.title;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 200) {
+                                    validate25.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate25.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate25.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs5 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.summary !== undefined) {
+                            let data2 = data.summary;
+                            const _errs7 = errors;
+                            if (errors === _errs7) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 2000) {
+                                        validate25.errors = [{ instancePath: instancePath + "/summary", schemaPath: "#/properties/summary/maxLength", keyword: "maxLength", params: { limit: 2000 }, message: "must NOT have more than 2000 characters" }];
+                                        return false;
+                                    }
+                                }
+                                else {
+                                    validate25.errors = [{ instancePath: instancePath + "/summary", schemaPath: "#/properties/summary/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs7 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.target !== undefined) {
+                                let data3 = data.target;
+                                const _errs9 = errors;
+                                if (errors === _errs9) {
+                                    if (typeof data3 === "string") {
+                                        if (func1(data3) > 500) {
+                                            validate25.errors = [{ instancePath: instancePath + "/target", schemaPath: "#/properties/target/maxLength", keyword: "maxLength", params: { limit: 500 }, message: "must NOT have more than 500 characters" }];
+                                            return false;
+                                        }
+                                        else {
+                                            if (func1(data3) < 1) {
+                                                validate25.errors = [{ instancePath: instancePath + "/target", schemaPath: "#/properties/target/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                return false;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate25.errors = [{ instancePath: instancePath + "/target", schemaPath: "#/properties/target/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs9 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.facts !== undefined) {
+                                    let data4 = data.facts;
+                                    const _errs11 = errors;
+                                    if (errors === _errs11) {
+                                        if (Array.isArray(data4)) {
+                                            if (data4.length > 20) {
+                                                validate25.errors = [{ instancePath: instancePath + "/facts", schemaPath: "#/properties/facts/maxItems", keyword: "maxItems", params: { limit: 20 }, message: "must NOT have more than 20 items" }];
+                                                return false;
+                                            }
+                                            else {
+                                                var valid2 = true;
+                                                const len0 = data4.length;
+                                                for (let i0 = 0; i0 < len0; i0++) {
+                                                    let data5 = data4[i0];
+                                                    const _errs13 = errors;
+                                                    const _errs14 = errors;
+                                                    if (errors === _errs14) {
+                                                        if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                                            let missing1;
+                                                            if (((data5.label === undefined) && (missing1 = "label")) || ((data5.value === undefined) && (missing1 = "value"))) {
+                                                                validate25.errors = [{ instancePath: instancePath + "/facts/" + i0, schemaPath: "#/$defs/Fact/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                const _errs16 = errors;
+                                                                for (const key1 in data5) {
+                                                                    if (!((key1 === "label") || (key1 === "value"))) {
+                                                                        validate25.errors = [{ instancePath: instancePath + "/facts/" + i0, schemaPath: "#/$defs/Fact/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                        return false;
+                                                                        break;
+                                                                    }
+                                                                }
+                                                                if (_errs16 === errors) {
+                                                                    if (data5.label !== undefined) {
+                                                                        let data6 = data5.label;
+                                                                        const _errs17 = errors;
+                                                                        if (errors === _errs17) {
+                                                                            if (typeof data6 === "string") {
+                                                                                if (func1(data6) > 80) {
+                                                                                    validate25.errors = [{ instancePath: instancePath + "/facts/" + i0 + "/label", schemaPath: "#/$defs/Fact/properties/label/maxLength", keyword: "maxLength", params: { limit: 80 }, message: "must NOT have more than 80 characters" }];
+                                                                                    return false;
+                                                                                }
+                                                                                else {
+                                                                                    if (func1(data6) < 1) {
+                                                                                        validate25.errors = [{ instancePath: instancePath + "/facts/" + i0 + "/label", schemaPath: "#/$defs/Fact/properties/label/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            else {
+                                                                                validate25.errors = [{ instancePath: instancePath + "/facts/" + i0 + "/label", schemaPath: "#/$defs/Fact/properties/label/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        var valid4 = _errs17 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid4 = true;
+                                                                    }
+                                                                    if (valid4) {
+                                                                        if (data5.value !== undefined) {
+                                                                            let data7 = data5.value;
+                                                                            const _errs19 = errors;
+                                                                            if (errors === _errs19) {
+                                                                                if (typeof data7 === "string") {
+                                                                                    if (func1(data7) > 500) {
+                                                                                        validate25.errors = [{ instancePath: instancePath + "/facts/" + i0 + "/value", schemaPath: "#/$defs/Fact/properties/value/maxLength", keyword: "maxLength", params: { limit: 500 }, message: "must NOT have more than 500 characters" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    else {
+                                                                                        if (func1(data7) < 1) {
+                                                                                            validate25.errors = [{ instancePath: instancePath + "/facts/" + i0 + "/value", schemaPath: "#/$defs/Fact/properties/value/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate25.errors = [{ instancePath: instancePath + "/facts/" + i0 + "/value", schemaPath: "#/$defs/Fact/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid4 = _errs19 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid4 = true;
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate25.errors = [{ instancePath: instancePath + "/facts/" + i0, schemaPath: "#/$defs/Fact/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid2 = _errs13 === errors;
+                                                    if (!valid2) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate25.errors = [{ instancePath: instancePath + "/facts", schemaPath: "#/properties/facts/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs11 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.warnings !== undefined) {
+                                        let data8 = data.warnings;
+                                        const _errs21 = errors;
+                                        if (errors === _errs21) {
+                                            if (Array.isArray(data8)) {
+                                                if (data8.length > 10) {
+                                                    validate25.errors = [{ instancePath: instancePath + "/warnings", schemaPath: "#/properties/warnings/maxItems", keyword: "maxItems", params: { limit: 10 }, message: "must NOT have more than 10 items" }];
+                                                    return false;
+                                                }
+                                                else {
+                                                    var valid5 = true;
+                                                    const len1 = data8.length;
+                                                    for (let i1 = 0; i1 < len1; i1++) {
+                                                        const _errs23 = errors;
+                                                        if (!(validate26(data8[i1], { instancePath: instancePath + "/warnings/" + i1, parentData: data8, parentDataProperty: i1, rootData, dynamicAnchors }))) {
+                                                            vErrors = vErrors === null ? validate26.errors : vErrors.concat(validate26.errors);
+                                                            errors = vErrors.length;
+                                                        }
+                                                        var valid5 = _errs23 === errors;
+                                                        if (!valid5) {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate25.errors = [{ instancePath: instancePath + "/warnings", schemaPath: "#/properties/warnings/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs21 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.plan_hash !== undefined) {
+                                            let data10 = data.plan_hash;
+                                            const _errs24 = errors;
+                                            if (errors === _errs24) {
+                                                if (typeof data10 === "string") {
+                                                    if (func1(data10) > 128) {
+                                                        validate25.errors = [{ instancePath: instancePath + "/plan_hash", schemaPath: "#/properties/plan_hash/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                else {
+                                                    validate25.errors = [{ instancePath: instancePath + "/plan_hash", schemaPath: "#/properties/plan_hash/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid0 = _errs24 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate25.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate25.errors = vErrors; return errors === 0; }
+validate25.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate24.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((((((((((((data.id === undefined) && (missing0 = "id")) || ((data.revision === undefined) && (missing0 = "revision"))) || ((data.requester === undefined) && (missing0 = "requester"))) || ((data.operation === undefined) && (missing0 = "operation"))) || ((data.status === undefined) && (missing0 = "status"))) || ((data.requested_at === undefined) && (missing0 = "requested_at"))) || ((data.requested_duration_seconds === undefined) && (missing0 = "requested_duration_seconds"))) || ((data.requested_max_uses === undefined) && (missing0 = "requested_max_uses"))) || ((data.granted_max_uses === undefined) && (missing0 = "granted_max_uses"))) || ((data.used_count === undefined) && (missing0 = "used_count"))) || ((data.presentation === undefined) && (missing0 = "presentation"))) || ((data.allowed_actions === undefined) && (missing0 = "allowed_actions"))) {
+            validate24.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!(func3.call(schema37.properties, key0))) {
+                    validate24.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.id !== undefined) {
+                    let data0 = data.id;
+                    const _errs2 = errors;
+                    if (errors === _errs2) {
+                        if (typeof data0 === "string") {
+                            if (func1(data0) > 128) {
+                                validate24.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                return false;
+                            }
+                            else {
+                                if (func1(data0) < 1) {
+                                    validate24.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            validate24.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.revision !== undefined) {
+                        let data1 = data.revision;
+                        const _errs4 = errors;
+                        if (!(((typeof data1 == "number") && (!(data1 % 1) && !isNaN(data1))) && (isFinite(data1)))) {
+                            validate24.errors = [{ instancePath: instancePath + "/revision", schemaPath: "#/properties/revision/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                            return false;
+                        }
+                        if (errors === _errs4) {
+                            if ((typeof data1 == "number") && (isFinite(data1))) {
+                                if (data1 < 1 || isNaN(data1)) {
+                                    validate24.errors = [{ instancePath: instancePath + "/revision", schemaPath: "#/properties/revision/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.requester !== undefined) {
+                            let data2 = data.requester;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 80) {
+                                        validate24.errors = [{ instancePath: instancePath + "/requester", schemaPath: "#/properties/requester/maxLength", keyword: "maxLength", params: { limit: 80 }, message: "must NOT have more than 80 characters" }];
+                                        return false;
+                                    }
+                                    else {
+                                        if (func1(data2) < 1) {
+                                            validate24.errors = [{ instancePath: instancePath + "/requester", schemaPath: "#/properties/requester/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                            return false;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate24.errors = [{ instancePath: instancePath + "/requester", schemaPath: "#/properties/requester/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.operation !== undefined) {
+                                let data3 = data.operation;
+                                const _errs8 = errors;
+                                if (errors === _errs8) {
+                                    if (typeof data3 === "string") {
+                                        if (func1(data3) > 500) {
+                                            validate24.errors = [{ instancePath: instancePath + "/operation", schemaPath: "#/properties/operation/maxLength", keyword: "maxLength", params: { limit: 500 }, message: "must NOT have more than 500 characters" }];
+                                            return false;
+                                        }
+                                        else {
+                                            if (func1(data3) < 1) {
+                                                validate24.errors = [{ instancePath: instancePath + "/operation", schemaPath: "#/properties/operation/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                return false;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate24.errors = [{ instancePath: instancePath + "/operation", schemaPath: "#/properties/operation/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.status !== undefined) {
+                                    let data4 = data.status;
+                                    const _errs10 = errors;
+                                    if (typeof data4 !== "string") {
+                                        validate24.errors = [{ instancePath: instancePath + "/status", schemaPath: "#/$defs/Status/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                    if (!(((((((data4 === "pending") || (data4 === "active")) || (data4 === "denied")) || (data4 === "canceled")) || (data4 === "expired")) || (data4 === "consumed")) || (data4 === "revoked"))) {
+                                        validate24.errors = [{ instancePath: instancePath + "/status", schemaPath: "#/$defs/Status/enum", keyword: "enum", params: { allowedValues: schema38.enum }, message: "must be equal to one of the allowed values" }];
+                                        return false;
+                                    }
+                                    var valid0 = _errs10 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.requested_at !== undefined) {
+                                        let data5 = data.requested_at;
+                                        const _errs13 = errors;
+                                        if (errors === _errs13) {
+                                            if (errors === _errs13) {
+                                                if (typeof data5 === "string") {
+                                                    if (!(formats0.validate(data5))) {
+                                                        validate24.errors = [{ instancePath: instancePath + "/requested_at", schemaPath: "#/properties/requested_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                else {
+                                                    validate24.errors = [{ instancePath: instancePath + "/requested_at", schemaPath: "#/properties/requested_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                            }
+                                        }
+                                        var valid0 = _errs13 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.pending_expires_at !== undefined) {
+                                            let data6 = data.pending_expires_at;
+                                            const _errs15 = errors;
+                                            if (errors === _errs15) {
+                                                if (errors === _errs15) {
+                                                    if (typeof data6 === "string") {
+                                                        if (!(formats0.validate(data6))) {
+                                                            validate24.errors = [{ instancePath: instancePath + "/pending_expires_at", schemaPath: "#/properties/pending_expires_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate24.errors = [{ instancePath: instancePath + "/pending_expires_at", schemaPath: "#/properties/pending_expires_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                }
+                                            }
+                                            var valid0 = _errs15 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                        if (valid0) {
+                                            if (data.active_expires_at !== undefined) {
+                                                let data7 = data.active_expires_at;
+                                                const _errs17 = errors;
+                                                if (errors === _errs17) {
+                                                    if (errors === _errs17) {
+                                                        if (typeof data7 === "string") {
+                                                            if (!(formats0.validate(data7))) {
+                                                                validate24.errors = [{ instancePath: instancePath + "/active_expires_at", schemaPath: "#/properties/active_expires_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate24.errors = [{ instancePath: instancePath + "/active_expires_at", schemaPath: "#/properties/active_expires_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                }
+                                                var valid0 = _errs17 === errors;
+                                            }
+                                            else {
+                                                var valid0 = true;
+                                            }
+                                            if (valid0) {
+                                                if (data.requested_duration_seconds !== undefined) {
+                                                    let data8 = data.requested_duration_seconds;
+                                                    const _errs19 = errors;
+                                                    if (!(((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8))) && (isFinite(data8)))) {
+                                                        validate24.errors = [{ instancePath: instancePath + "/requested_duration_seconds", schemaPath: "#/properties/requested_duration_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                        return false;
+                                                    }
+                                                    if (errors === _errs19) {
+                                                        if ((typeof data8 == "number") && (isFinite(data8))) {
+                                                            if (data8 < 1 || isNaN(data8)) {
+                                                                validate24.errors = [{ instancePath: instancePath + "/requested_duration_seconds", schemaPath: "#/properties/requested_duration_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                    }
+                                                    var valid0 = _errs19 === errors;
+                                                }
+                                                else {
+                                                    var valid0 = true;
+                                                }
+                                                if (valid0) {
+                                                    if (data.requested_max_uses !== undefined) {
+                                                        let data9 = data.requested_max_uses;
+                                                        const _errs21 = errors;
+                                                        if ((!(((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9))) && (isFinite(data9)))) && (data9 !== null)) {
+                                                            validate24.errors = [{ instancePath: instancePath + "/requested_max_uses", schemaPath: "#/properties/requested_max_uses/type", keyword: "type", params: { type: schema37.properties.requested_max_uses.type }, message: "must be integer,null" }];
+                                                            return false;
+                                                        }
+                                                        if (errors === _errs21) {
+                                                            if ((typeof data9 == "number") && (isFinite(data9))) {
+                                                                if (data9 < 1 || isNaN(data9)) {
+                                                                    validate24.errors = [{ instancePath: instancePath + "/requested_max_uses", schemaPath: "#/properties/requested_max_uses/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                    return false;
+                                                                }
+                                                            }
+                                                        }
+                                                        var valid0 = _errs21 === errors;
+                                                    }
+                                                    else {
+                                                        var valid0 = true;
+                                                    }
+                                                    if (valid0) {
+                                                        if (data.granted_max_uses !== undefined) {
+                                                            let data10 = data.granted_max_uses;
+                                                            const _errs23 = errors;
+                                                            if ((!(((typeof data10 == "number") && (!(data10 % 1) && !isNaN(data10))) && (isFinite(data10)))) && (data10 !== null)) {
+                                                                validate24.errors = [{ instancePath: instancePath + "/granted_max_uses", schemaPath: "#/properties/granted_max_uses/type", keyword: "type", params: { type: schema37.properties.granted_max_uses.type }, message: "must be integer,null" }];
+                                                                return false;
+                                                            }
+                                                            if (errors === _errs23) {
+                                                                if ((typeof data10 == "number") && (isFinite(data10))) {
+                                                                    if (data10 < 1 || isNaN(data10)) {
+                                                                        validate24.errors = [{ instancePath: instancePath + "/granted_max_uses", schemaPath: "#/properties/granted_max_uses/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                        return false;
+                                                                    }
+                                                                }
+                                                            }
+                                                            var valid0 = _errs23 === errors;
+                                                        }
+                                                        else {
+                                                            var valid0 = true;
+                                                        }
+                                                        if (valid0) {
+                                                            if (data.used_count !== undefined) {
+                                                                let data11 = data.used_count;
+                                                                const _errs25 = errors;
+                                                                if (!(((typeof data11 == "number") && (!(data11 % 1) && !isNaN(data11))) && (isFinite(data11)))) {
+                                                                    validate24.errors = [{ instancePath: instancePath + "/used_count", schemaPath: "#/properties/used_count/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                                    return false;
+                                                                }
+                                                                if (errors === _errs25) {
+                                                                    if ((typeof data11 == "number") && (isFinite(data11))) {
+                                                                        if (data11 < 0 || isNaN(data11)) {
+                                                                            validate24.errors = [{ instancePath: instancePath + "/used_count", schemaPath: "#/properties/used_count/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                }
+                                                                var valid0 = _errs25 === errors;
+                                                            }
+                                                            else {
+                                                                var valid0 = true;
+                                                            }
+                                                            if (valid0) {
+                                                                if (data.request_reason !== undefined) {
+                                                                    let data12 = data.request_reason;
+                                                                    const _errs27 = errors;
+                                                                    if (errors === _errs27) {
+                                                                        if (typeof data12 === "string") {
+                                                                            if (func1(data12) > 2000) {
+                                                                                validate24.errors = [{ instancePath: instancePath + "/request_reason", schemaPath: "#/properties/request_reason/maxLength", keyword: "maxLength", params: { limit: 2000 }, message: "must NOT have more than 2000 characters" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            validate24.errors = [{ instancePath: instancePath + "/request_reason", schemaPath: "#/properties/request_reason/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                    var valid0 = _errs27 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid0 = true;
+                                                                }
+                                                                if (valid0) {
+                                                                    if (data.decided_at !== undefined) {
+                                                                        let data13 = data.decided_at;
+                                                                        const _errs29 = errors;
+                                                                        if (errors === _errs29) {
+                                                                            if (errors === _errs29) {
+                                                                                if (typeof data13 === "string") {
+                                                                                    if (!(formats0.validate(data13))) {
+                                                                                        validate24.errors = [{ instancePath: instancePath + "/decided_at", schemaPath: "#/properties/decided_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate24.errors = [{ instancePath: instancePath + "/decided_at", schemaPath: "#/properties/decided_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        var valid0 = _errs29 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid0 = true;
+                                                                    }
+                                                                    if (valid0) {
+                                                                        if (data.decided_by !== undefined) {
+                                                                            let data14 = data.decided_by;
+                                                                            const _errs31 = errors;
+                                                                            if (errors === _errs31) {
+                                                                                if (typeof data14 === "string") {
+                                                                                    if (func1(data14) > 200) {
+                                                                                        validate24.errors = [{ instancePath: instancePath + "/decided_by", schemaPath: "#/properties/decided_by/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate24.errors = [{ instancePath: instancePath + "/decided_by", schemaPath: "#/properties/decided_by/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid0 = _errs31 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid0 = true;
+                                                                        }
+                                                                        if (valid0) {
+                                                                            if (data.decided_on_behalf_of !== undefined) {
+                                                                                let data15 = data.decided_on_behalf_of;
+                                                                                const _errs33 = errors;
+                                                                                if (errors === _errs33) {
+                                                                                    if (typeof data15 === "string") {
+                                                                                        if (func1(data15) > 200) {
+                                                                                            validate24.errors = [{ instancePath: instancePath + "/decided_on_behalf_of", schemaPath: "#/properties/decided_on_behalf_of/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                    else {
+                                                                                        validate24.errors = [{ instancePath: instancePath + "/decided_on_behalf_of", schemaPath: "#/properties/decided_on_behalf_of/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                var valid0 = _errs33 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid0 = true;
+                                                                            }
+                                                                            if (valid0) {
+                                                                                if (data.presentation !== undefined) {
+                                                                                    const _errs35 = errors;
+                                                                                    if (!(validate25(data.presentation, { instancePath: instancePath + "/presentation", parentData: data, parentDataProperty: "presentation", rootData, dynamicAnchors }))) {
+                                                                                        vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
+                                                                                        errors = vErrors.length;
+                                                                                    }
+                                                                                    var valid0 = _errs35 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid0 = true;
+                                                                                }
+                                                                                if (valid0) {
+                                                                                    if (data.presentation_unavailable !== undefined) {
+                                                                                        const _errs36 = errors;
+                                                                                        if (typeof data.presentation_unavailable !== "boolean") {
+                                                                                            validate24.errors = [{ instancePath: instancePath + "/presentation_unavailable", schemaPath: "#/properties/presentation_unavailable/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid0 = _errs36 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid0 = true;
+                                                                                    }
+                                                                                    if (valid0) {
+                                                                                        if (data.allowed_actions !== undefined) {
+                                                                                            let data18 = data.allowed_actions;
+                                                                                            const _errs38 = errors;
+                                                                                            if (errors === _errs38) {
+                                                                                                if (Array.isArray(data18)) {
+                                                                                                    var valid2 = true;
+                                                                                                    const len0 = data18.length;
+                                                                                                    for (let i0 = 0; i0 < len0; i0++) {
+                                                                                                        let data19 = data18[i0];
+                                                                                                        const _errs40 = errors;
+                                                                                                        if (typeof data19 !== "string") {
+                                                                                                            validate24.errors = [{ instancePath: instancePath + "/allowed_actions/" + i0, schemaPath: "#/$defs/Action/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        if (!(((data19 === "approve") || (data19 === "deny")) || (data19 === "revoke"))) {
+                                                                                                            validate24.errors = [{ instancePath: instancePath + "/allowed_actions/" + i0, schemaPath: "#/$defs/Action/enum", keyword: "enum", params: { allowedValues: schema44.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid2 = _errs40 === errors;
+                                                                                                        if (!valid2) {
+                                                                                                            break;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    if (valid2) {
+                                                                                                        let i1 = data18.length;
+                                                                                                        let j0;
+                                                                                                        if (i1 > 1) {
+                                                                                                            outer0: for (; i1--;) {
+                                                                                                                for (j0 = i1; j0--;) {
+                                                                                                                    if (func0(data18[i1], data18[j0])) {
+                                                                                                                        validate24.errors = [{ instancePath: instancePath + "/allowed_actions", schemaPath: "#/properties/allowed_actions/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" }];
+                                                                                                                        return false;
+                                                                                                                        break outer0;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    validate24.errors = [{ instancePath: instancePath + "/allowed_actions", schemaPath: "#/properties/allowed_actions/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                            }
+                                                                                            var valid0 = _errs38 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid0 = true;
+                                                                                        }
+                                                                                        if (valid0) {
+                                                                                            if (data.approval_bounds !== undefined) {
+                                                                                                let data20 = data.approval_bounds;
+                                                                                                const _errs43 = errors;
+                                                                                                const _errs44 = errors;
+                                                                                                if (errors === _errs44) {
+                                                                                                    if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
+                                                                                                        let missing1;
+                                                                                                        if (((data20.max_duration_seconds === undefined) && (missing1 = "max_duration_seconds")) || ((data20.max_uses === undefined) && (missing1 = "max_uses"))) {
+                                                                                                            validate24.errors = [{ instancePath: instancePath + "/approval_bounds", schemaPath: "#/$defs/ApprovalBounds/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            const _errs46 = errors;
+                                                                                                            for (const key1 in data20) {
+                                                                                                                if (!((key1 === "max_duration_seconds") || (key1 === "max_uses"))) {
+                                                                                                                    validate24.errors = [{ instancePath: instancePath + "/approval_bounds", schemaPath: "#/$defs/ApprovalBounds/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                                                                    return false;
+                                                                                                                    break;
+                                                                                                                }
+                                                                                                            }
+                                                                                                            if (_errs46 === errors) {
+                                                                                                                if (data20.max_duration_seconds !== undefined) {
+                                                                                                                    let data21 = data20.max_duration_seconds;
+                                                                                                                    const _errs47 = errors;
+                                                                                                                    if (!(((typeof data21 == "number") && (!(data21 % 1) && !isNaN(data21))) && (isFinite(data21)))) {
+                                                                                                                        validate24.errors = [{ instancePath: instancePath + "/approval_bounds/max_duration_seconds", schemaPath: "#/$defs/ApprovalBounds/properties/max_duration_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    if (errors === _errs47) {
+                                                                                                                        if ((typeof data21 == "number") && (isFinite(data21))) {
+                                                                                                                            if (data21 < 1 || isNaN(data21)) {
+                                                                                                                                validate24.errors = [{ instancePath: instancePath + "/approval_bounds/max_duration_seconds", schemaPath: "#/$defs/ApprovalBounds/properties/max_duration_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    var valid6 = _errs47 === errors;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    var valid6 = true;
+                                                                                                                }
+                                                                                                                if (valid6) {
+                                                                                                                    if (data20.max_uses !== undefined) {
+                                                                                                                        let data22 = data20.max_uses;
+                                                                                                                        const _errs49 = errors;
+                                                                                                                        if ((!(((typeof data22 == "number") && (!(data22 % 1) && !isNaN(data22))) && (isFinite(data22)))) && (data22 !== null)) {
+                                                                                                                            validate24.errors = [{ instancePath: instancePath + "/approval_bounds/max_uses", schemaPath: "#/$defs/ApprovalBounds/properties/max_uses/type", keyword: "type", params: { type: schema45.properties.max_uses.type }, message: "must be integer,null" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        if (errors === _errs49) {
+                                                                                                                            if ((typeof data22 == "number") && (isFinite(data22))) {
+                                                                                                                                if (data22 < 1 || isNaN(data22)) {
+                                                                                                                                    validate24.errors = [{ instancePath: instancePath + "/approval_bounds/max_uses", schemaPath: "#/$defs/ApprovalBounds/properties/max_uses/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                        var valid6 = _errs49 === errors;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        var valid6 = true;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        validate24.errors = [{ instancePath: instancePath + "/approval_bounds", schemaPath: "#/$defs/ApprovalBounds/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid0 = _errs43 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid0 = true;
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate24.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate24.errors = vErrors; return errors === 0; }
+validate24.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/BrokerRequest" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate23.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate24(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate24.errors : vErrors.concat(validate24.errors);
+    errors = vErrors.length;
+} validate23.errors = vErrors; return errors === 0; }
+validate23.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateRequestPage = validate30;
+const schema46 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/RequestPage", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/RequestPage" };
+const schema47 = { "type": "object", "additionalProperties": false, "required": ["requests"], "properties": { "requests": { "type": "array", "maxItems": 100, "items": { "$ref": "#/$defs/BrokerRequest" } }, "next_cursor": { "type": "string", "maxLength": 1024 }, "event_cursor": { "type": "string", "maxLength": 1024 } } };
+function validate32(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate32.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((((((((((((data.id === undefined) && (missing0 = "id")) || ((data.revision === undefined) && (missing0 = "revision"))) || ((data.requester === undefined) && (missing0 = "requester"))) || ((data.operation === undefined) && (missing0 = "operation"))) || ((data.status === undefined) && (missing0 = "status"))) || ((data.requested_at === undefined) && (missing0 = "requested_at"))) || ((data.requested_duration_seconds === undefined) && (missing0 = "requested_duration_seconds"))) || ((data.requested_max_uses === undefined) && (missing0 = "requested_max_uses"))) || ((data.granted_max_uses === undefined) && (missing0 = "granted_max_uses"))) || ((data.used_count === undefined) && (missing0 = "used_count"))) || ((data.presentation === undefined) && (missing0 = "presentation"))) || ((data.allowed_actions === undefined) && (missing0 = "allowed_actions"))) {
+            validate32.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!(func3.call(schema37.properties, key0))) {
+                    validate32.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.id !== undefined) {
+                    let data0 = data.id;
+                    const _errs2 = errors;
+                    if (errors === _errs2) {
+                        if (typeof data0 === "string") {
+                            if (func1(data0) > 128) {
+                                validate32.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                return false;
+                            }
+                            else {
+                                if (func1(data0) < 1) {
+                                    validate32.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            validate32.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.revision !== undefined) {
+                        let data1 = data.revision;
+                        const _errs4 = errors;
+                        if (!(((typeof data1 == "number") && (!(data1 % 1) && !isNaN(data1))) && (isFinite(data1)))) {
+                            validate32.errors = [{ instancePath: instancePath + "/revision", schemaPath: "#/properties/revision/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                            return false;
+                        }
+                        if (errors === _errs4) {
+                            if ((typeof data1 == "number") && (isFinite(data1))) {
+                                if (data1 < 1 || isNaN(data1)) {
+                                    validate32.errors = [{ instancePath: instancePath + "/revision", schemaPath: "#/properties/revision/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.requester !== undefined) {
+                            let data2 = data.requester;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 80) {
+                                        validate32.errors = [{ instancePath: instancePath + "/requester", schemaPath: "#/properties/requester/maxLength", keyword: "maxLength", params: { limit: 80 }, message: "must NOT have more than 80 characters" }];
+                                        return false;
+                                    }
+                                    else {
+                                        if (func1(data2) < 1) {
+                                            validate32.errors = [{ instancePath: instancePath + "/requester", schemaPath: "#/properties/requester/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                            return false;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate32.errors = [{ instancePath: instancePath + "/requester", schemaPath: "#/properties/requester/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.operation !== undefined) {
+                                let data3 = data.operation;
+                                const _errs8 = errors;
+                                if (errors === _errs8) {
+                                    if (typeof data3 === "string") {
+                                        if (func1(data3) > 500) {
+                                            validate32.errors = [{ instancePath: instancePath + "/operation", schemaPath: "#/properties/operation/maxLength", keyword: "maxLength", params: { limit: 500 }, message: "must NOT have more than 500 characters" }];
+                                            return false;
+                                        }
+                                        else {
+                                            if (func1(data3) < 1) {
+                                                validate32.errors = [{ instancePath: instancePath + "/operation", schemaPath: "#/properties/operation/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                return false;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate32.errors = [{ instancePath: instancePath + "/operation", schemaPath: "#/properties/operation/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.status !== undefined) {
+                                    let data4 = data.status;
+                                    const _errs10 = errors;
+                                    if (typeof data4 !== "string") {
+                                        validate32.errors = [{ instancePath: instancePath + "/status", schemaPath: "#/$defs/Status/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                    if (!(((((((data4 === "pending") || (data4 === "active")) || (data4 === "denied")) || (data4 === "canceled")) || (data4 === "expired")) || (data4 === "consumed")) || (data4 === "revoked"))) {
+                                        validate32.errors = [{ instancePath: instancePath + "/status", schemaPath: "#/$defs/Status/enum", keyword: "enum", params: { allowedValues: schema38.enum }, message: "must be equal to one of the allowed values" }];
+                                        return false;
+                                    }
+                                    var valid0 = _errs10 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.requested_at !== undefined) {
+                                        let data5 = data.requested_at;
+                                        const _errs13 = errors;
+                                        if (errors === _errs13) {
+                                            if (errors === _errs13) {
+                                                if (typeof data5 === "string") {
+                                                    if (!(formats0.validate(data5))) {
+                                                        validate32.errors = [{ instancePath: instancePath + "/requested_at", schemaPath: "#/properties/requested_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                else {
+                                                    validate32.errors = [{ instancePath: instancePath + "/requested_at", schemaPath: "#/properties/requested_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                            }
+                                        }
+                                        var valid0 = _errs13 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.pending_expires_at !== undefined) {
+                                            let data6 = data.pending_expires_at;
+                                            const _errs15 = errors;
+                                            if (errors === _errs15) {
+                                                if (errors === _errs15) {
+                                                    if (typeof data6 === "string") {
+                                                        if (!(formats0.validate(data6))) {
+                                                            validate32.errors = [{ instancePath: instancePath + "/pending_expires_at", schemaPath: "#/properties/pending_expires_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate32.errors = [{ instancePath: instancePath + "/pending_expires_at", schemaPath: "#/properties/pending_expires_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                }
+                                            }
+                                            var valid0 = _errs15 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                        if (valid0) {
+                                            if (data.active_expires_at !== undefined) {
+                                                let data7 = data.active_expires_at;
+                                                const _errs17 = errors;
+                                                if (errors === _errs17) {
+                                                    if (errors === _errs17) {
+                                                        if (typeof data7 === "string") {
+                                                            if (!(formats0.validate(data7))) {
+                                                                validate32.errors = [{ instancePath: instancePath + "/active_expires_at", schemaPath: "#/properties/active_expires_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate32.errors = [{ instancePath: instancePath + "/active_expires_at", schemaPath: "#/properties/active_expires_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                }
+                                                var valid0 = _errs17 === errors;
+                                            }
+                                            else {
+                                                var valid0 = true;
+                                            }
+                                            if (valid0) {
+                                                if (data.requested_duration_seconds !== undefined) {
+                                                    let data8 = data.requested_duration_seconds;
+                                                    const _errs19 = errors;
+                                                    if (!(((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8))) && (isFinite(data8)))) {
+                                                        validate32.errors = [{ instancePath: instancePath + "/requested_duration_seconds", schemaPath: "#/properties/requested_duration_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                        return false;
+                                                    }
+                                                    if (errors === _errs19) {
+                                                        if ((typeof data8 == "number") && (isFinite(data8))) {
+                                                            if (data8 < 1 || isNaN(data8)) {
+                                                                validate32.errors = [{ instancePath: instancePath + "/requested_duration_seconds", schemaPath: "#/properties/requested_duration_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                    }
+                                                    var valid0 = _errs19 === errors;
+                                                }
+                                                else {
+                                                    var valid0 = true;
+                                                }
+                                                if (valid0) {
+                                                    if (data.requested_max_uses !== undefined) {
+                                                        let data9 = data.requested_max_uses;
+                                                        const _errs21 = errors;
+                                                        if ((!(((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9))) && (isFinite(data9)))) && (data9 !== null)) {
+                                                            validate32.errors = [{ instancePath: instancePath + "/requested_max_uses", schemaPath: "#/properties/requested_max_uses/type", keyword: "type", params: { type: schema37.properties.requested_max_uses.type }, message: "must be integer,null" }];
+                                                            return false;
+                                                        }
+                                                        if (errors === _errs21) {
+                                                            if ((typeof data9 == "number") && (isFinite(data9))) {
+                                                                if (data9 < 1 || isNaN(data9)) {
+                                                                    validate32.errors = [{ instancePath: instancePath + "/requested_max_uses", schemaPath: "#/properties/requested_max_uses/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                    return false;
+                                                                }
+                                                            }
+                                                        }
+                                                        var valid0 = _errs21 === errors;
+                                                    }
+                                                    else {
+                                                        var valid0 = true;
+                                                    }
+                                                    if (valid0) {
+                                                        if (data.granted_max_uses !== undefined) {
+                                                            let data10 = data.granted_max_uses;
+                                                            const _errs23 = errors;
+                                                            if ((!(((typeof data10 == "number") && (!(data10 % 1) && !isNaN(data10))) && (isFinite(data10)))) && (data10 !== null)) {
+                                                                validate32.errors = [{ instancePath: instancePath + "/granted_max_uses", schemaPath: "#/properties/granted_max_uses/type", keyword: "type", params: { type: schema37.properties.granted_max_uses.type }, message: "must be integer,null" }];
+                                                                return false;
+                                                            }
+                                                            if (errors === _errs23) {
+                                                                if ((typeof data10 == "number") && (isFinite(data10))) {
+                                                                    if (data10 < 1 || isNaN(data10)) {
+                                                                        validate32.errors = [{ instancePath: instancePath + "/granted_max_uses", schemaPath: "#/properties/granted_max_uses/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                        return false;
+                                                                    }
+                                                                }
+                                                            }
+                                                            var valid0 = _errs23 === errors;
+                                                        }
+                                                        else {
+                                                            var valid0 = true;
+                                                        }
+                                                        if (valid0) {
+                                                            if (data.used_count !== undefined) {
+                                                                let data11 = data.used_count;
+                                                                const _errs25 = errors;
+                                                                if (!(((typeof data11 == "number") && (!(data11 % 1) && !isNaN(data11))) && (isFinite(data11)))) {
+                                                                    validate32.errors = [{ instancePath: instancePath + "/used_count", schemaPath: "#/properties/used_count/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                                    return false;
+                                                                }
+                                                                if (errors === _errs25) {
+                                                                    if ((typeof data11 == "number") && (isFinite(data11))) {
+                                                                        if (data11 < 0 || isNaN(data11)) {
+                                                                            validate32.errors = [{ instancePath: instancePath + "/used_count", schemaPath: "#/properties/used_count/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                }
+                                                                var valid0 = _errs25 === errors;
+                                                            }
+                                                            else {
+                                                                var valid0 = true;
+                                                            }
+                                                            if (valid0) {
+                                                                if (data.request_reason !== undefined) {
+                                                                    let data12 = data.request_reason;
+                                                                    const _errs27 = errors;
+                                                                    if (errors === _errs27) {
+                                                                        if (typeof data12 === "string") {
+                                                                            if (func1(data12) > 2000) {
+                                                                                validate32.errors = [{ instancePath: instancePath + "/request_reason", schemaPath: "#/properties/request_reason/maxLength", keyword: "maxLength", params: { limit: 2000 }, message: "must NOT have more than 2000 characters" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            validate32.errors = [{ instancePath: instancePath + "/request_reason", schemaPath: "#/properties/request_reason/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                    var valid0 = _errs27 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid0 = true;
+                                                                }
+                                                                if (valid0) {
+                                                                    if (data.decided_at !== undefined) {
+                                                                        let data13 = data.decided_at;
+                                                                        const _errs29 = errors;
+                                                                        if (errors === _errs29) {
+                                                                            if (errors === _errs29) {
+                                                                                if (typeof data13 === "string") {
+                                                                                    if (!(formats0.validate(data13))) {
+                                                                                        validate32.errors = [{ instancePath: instancePath + "/decided_at", schemaPath: "#/properties/decided_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate32.errors = [{ instancePath: instancePath + "/decided_at", schemaPath: "#/properties/decided_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        var valid0 = _errs29 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid0 = true;
+                                                                    }
+                                                                    if (valid0) {
+                                                                        if (data.decided_by !== undefined) {
+                                                                            let data14 = data.decided_by;
+                                                                            const _errs31 = errors;
+                                                                            if (errors === _errs31) {
+                                                                                if (typeof data14 === "string") {
+                                                                                    if (func1(data14) > 200) {
+                                                                                        validate32.errors = [{ instancePath: instancePath + "/decided_by", schemaPath: "#/properties/decided_by/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate32.errors = [{ instancePath: instancePath + "/decided_by", schemaPath: "#/properties/decided_by/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid0 = _errs31 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid0 = true;
+                                                                        }
+                                                                        if (valid0) {
+                                                                            if (data.decided_on_behalf_of !== undefined) {
+                                                                                let data15 = data.decided_on_behalf_of;
+                                                                                const _errs33 = errors;
+                                                                                if (errors === _errs33) {
+                                                                                    if (typeof data15 === "string") {
+                                                                                        if (func1(data15) > 200) {
+                                                                                            validate32.errors = [{ instancePath: instancePath + "/decided_on_behalf_of", schemaPath: "#/properties/decided_on_behalf_of/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                    else {
+                                                                                        validate32.errors = [{ instancePath: instancePath + "/decided_on_behalf_of", schemaPath: "#/properties/decided_on_behalf_of/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                var valid0 = _errs33 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid0 = true;
+                                                                            }
+                                                                            if (valid0) {
+                                                                                if (data.presentation !== undefined) {
+                                                                                    const _errs35 = errors;
+                                                                                    if (!(validate25(data.presentation, { instancePath: instancePath + "/presentation", parentData: data, parentDataProperty: "presentation", rootData, dynamicAnchors }))) {
+                                                                                        vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
+                                                                                        errors = vErrors.length;
+                                                                                    }
+                                                                                    var valid0 = _errs35 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid0 = true;
+                                                                                }
+                                                                                if (valid0) {
+                                                                                    if (data.presentation_unavailable !== undefined) {
+                                                                                        const _errs36 = errors;
+                                                                                        if (typeof data.presentation_unavailable !== "boolean") {
+                                                                                            validate32.errors = [{ instancePath: instancePath + "/presentation_unavailable", schemaPath: "#/properties/presentation_unavailable/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid0 = _errs36 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid0 = true;
+                                                                                    }
+                                                                                    if (valid0) {
+                                                                                        if (data.allowed_actions !== undefined) {
+                                                                                            let data18 = data.allowed_actions;
+                                                                                            const _errs38 = errors;
+                                                                                            if (errors === _errs38) {
+                                                                                                if (Array.isArray(data18)) {
+                                                                                                    var valid2 = true;
+                                                                                                    const len0 = data18.length;
+                                                                                                    for (let i0 = 0; i0 < len0; i0++) {
+                                                                                                        let data19 = data18[i0];
+                                                                                                        const _errs40 = errors;
+                                                                                                        if (typeof data19 !== "string") {
+                                                                                                            validate32.errors = [{ instancePath: instancePath + "/allowed_actions/" + i0, schemaPath: "#/$defs/Action/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        if (!(((data19 === "approve") || (data19 === "deny")) || (data19 === "revoke"))) {
+                                                                                                            validate32.errors = [{ instancePath: instancePath + "/allowed_actions/" + i0, schemaPath: "#/$defs/Action/enum", keyword: "enum", params: { allowedValues: schema44.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid2 = _errs40 === errors;
+                                                                                                        if (!valid2) {
+                                                                                                            break;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    if (valid2) {
+                                                                                                        let i1 = data18.length;
+                                                                                                        let j0;
+                                                                                                        if (i1 > 1) {
+                                                                                                            outer0: for (; i1--;) {
+                                                                                                                for (j0 = i1; j0--;) {
+                                                                                                                    if (func0(data18[i1], data18[j0])) {
+                                                                                                                        validate32.errors = [{ instancePath: instancePath + "/allowed_actions", schemaPath: "#/properties/allowed_actions/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" }];
+                                                                                                                        return false;
+                                                                                                                        break outer0;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    validate32.errors = [{ instancePath: instancePath + "/allowed_actions", schemaPath: "#/properties/allowed_actions/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                            }
+                                                                                            var valid0 = _errs38 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid0 = true;
+                                                                                        }
+                                                                                        if (valid0) {
+                                                                                            if (data.approval_bounds !== undefined) {
+                                                                                                let data20 = data.approval_bounds;
+                                                                                                const _errs43 = errors;
+                                                                                                const _errs44 = errors;
+                                                                                                if (errors === _errs44) {
+                                                                                                    if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
+                                                                                                        let missing1;
+                                                                                                        if (((data20.max_duration_seconds === undefined) && (missing1 = "max_duration_seconds")) || ((data20.max_uses === undefined) && (missing1 = "max_uses"))) {
+                                                                                                            validate32.errors = [{ instancePath: instancePath + "/approval_bounds", schemaPath: "#/$defs/ApprovalBounds/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            const _errs46 = errors;
+                                                                                                            for (const key1 in data20) {
+                                                                                                                if (!((key1 === "max_duration_seconds") || (key1 === "max_uses"))) {
+                                                                                                                    validate32.errors = [{ instancePath: instancePath + "/approval_bounds", schemaPath: "#/$defs/ApprovalBounds/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                                                                    return false;
+                                                                                                                    break;
+                                                                                                                }
+                                                                                                            }
+                                                                                                            if (_errs46 === errors) {
+                                                                                                                if (data20.max_duration_seconds !== undefined) {
+                                                                                                                    let data21 = data20.max_duration_seconds;
+                                                                                                                    const _errs47 = errors;
+                                                                                                                    if (!(((typeof data21 == "number") && (!(data21 % 1) && !isNaN(data21))) && (isFinite(data21)))) {
+                                                                                                                        validate32.errors = [{ instancePath: instancePath + "/approval_bounds/max_duration_seconds", schemaPath: "#/$defs/ApprovalBounds/properties/max_duration_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    if (errors === _errs47) {
+                                                                                                                        if ((typeof data21 == "number") && (isFinite(data21))) {
+                                                                                                                            if (data21 < 1 || isNaN(data21)) {
+                                                                                                                                validate32.errors = [{ instancePath: instancePath + "/approval_bounds/max_duration_seconds", schemaPath: "#/$defs/ApprovalBounds/properties/max_duration_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    var valid6 = _errs47 === errors;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    var valid6 = true;
+                                                                                                                }
+                                                                                                                if (valid6) {
+                                                                                                                    if (data20.max_uses !== undefined) {
+                                                                                                                        let data22 = data20.max_uses;
+                                                                                                                        const _errs49 = errors;
+                                                                                                                        if ((!(((typeof data22 == "number") && (!(data22 % 1) && !isNaN(data22))) && (isFinite(data22)))) && (data22 !== null)) {
+                                                                                                                            validate32.errors = [{ instancePath: instancePath + "/approval_bounds/max_uses", schemaPath: "#/$defs/ApprovalBounds/properties/max_uses/type", keyword: "type", params: { type: schema45.properties.max_uses.type }, message: "must be integer,null" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        if (errors === _errs49) {
+                                                                                                                            if ((typeof data22 == "number") && (isFinite(data22))) {
+                                                                                                                                if (data22 < 1 || isNaN(data22)) {
+                                                                                                                                    validate32.errors = [{ instancePath: instancePath + "/approval_bounds/max_uses", schemaPath: "#/$defs/ApprovalBounds/properties/max_uses/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                        var valid6 = _errs49 === errors;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        var valid6 = true;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        validate32.errors = [{ instancePath: instancePath + "/approval_bounds", schemaPath: "#/$defs/ApprovalBounds/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid0 = _errs43 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid0 = true;
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate32.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate32.errors = vErrors; return errors === 0; }
+validate32.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate31(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate31.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((data.requests === undefined) && (missing0 = "requests")) {
+            validate31.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!(((key0 === "requests") || (key0 === "next_cursor")) || (key0 === "event_cursor"))) {
+                    validate31.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.requests !== undefined) {
+                    let data0 = data.requests;
+                    const _errs2 = errors;
+                    if (errors === _errs2) {
+                        if (Array.isArray(data0)) {
+                            if (data0.length > 100) {
+                                validate31.errors = [{ instancePath: instancePath + "/requests", schemaPath: "#/properties/requests/maxItems", keyword: "maxItems", params: { limit: 100 }, message: "must NOT have more than 100 items" }];
+                                return false;
+                            }
+                            else {
+                                var valid1 = true;
+                                const len0 = data0.length;
+                                for (let i0 = 0; i0 < len0; i0++) {
+                                    const _errs4 = errors;
+                                    if (!(validate32(data0[i0], { instancePath: instancePath + "/requests/" + i0, parentData: data0, parentDataProperty: i0, rootData, dynamicAnchors }))) {
+                                        vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                        errors = vErrors.length;
+                                    }
+                                    var valid1 = _errs4 === errors;
+                                    if (!valid1) {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            validate31.errors = [{ instancePath: instancePath + "/requests", schemaPath: "#/properties/requests/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.next_cursor !== undefined) {
+                        let data2 = data.next_cursor;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data2 === "string") {
+                                if (func1(data2) > 1024) {
+                                    validate31.errors = [{ instancePath: instancePath + "/next_cursor", schemaPath: "#/properties/next_cursor/maxLength", keyword: "maxLength", params: { limit: 1024 }, message: "must NOT have more than 1024 characters" }];
+                                    return false;
+                                }
+                            }
+                            else {
+                                validate31.errors = [{ instancePath: instancePath + "/next_cursor", schemaPath: "#/properties/next_cursor/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs5 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.event_cursor !== undefined) {
+                            let data3 = data.event_cursor;
+                            const _errs7 = errors;
+                            if (errors === _errs7) {
+                                if (typeof data3 === "string") {
+                                    if (func1(data3) > 1024) {
+                                        validate31.errors = [{ instancePath: instancePath + "/event_cursor", schemaPath: "#/properties/event_cursor/maxLength", keyword: "maxLength", params: { limit: 1024 }, message: "must NOT have more than 1024 characters" }];
+                                        return false;
+                                    }
+                                }
+                                else {
+                                    validate31.errors = [{ instancePath: instancePath + "/event_cursor", schemaPath: "#/properties/event_cursor/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs7 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate31.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate31.errors = vErrors; return errors === 0; }
+validate31.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate30(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/RequestPage" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate30.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate31(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate31.errors : vErrors.concat(validate31.errors);
+    errors = vErrors.length;
+} validate30.errors = vErrors; return errors === 0; }
+validate30.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateBrokerEvent = validate36;
+const schema52 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/BrokerEvent", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/BrokerEvent" };
+const schema53 = { "type": "object", "additionalProperties": false, "required": ["cursor", "kind", "request_id", "revision", "status", "occurred_at", "used_count"], "properties": { "cursor": { "type": "string", "minLength": 1, "maxLength": 1024 }, "kind": { "type": "string", "enum": ["request.created", "request.approved", "request.denied", "request.canceled", "request.expired", "grant.revoked", "grant.reserved", "grant.consumed", "grant.released", "execution.succeeded", "execution.failed", "execution.ambiguous"] }, "request_id": { "type": "string", "minLength": 1, "maxLength": 128 }, "revision": { "type": "integer", "minimum": 1 }, "status": { "$ref": "#/$defs/Status" }, "occurred_at": { "type": "string", "format": "date-time" }, "used_count": { "type": "integer", "minimum": 0 } } };
+function validate37(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate37.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((((((((data.cursor === undefined) && (missing0 = "cursor")) || ((data.kind === undefined) && (missing0 = "kind"))) || ((data.request_id === undefined) && (missing0 = "request_id"))) || ((data.revision === undefined) && (missing0 = "revision"))) || ((data.status === undefined) && (missing0 = "status"))) || ((data.occurred_at === undefined) && (missing0 = "occurred_at"))) || ((data.used_count === undefined) && (missing0 = "used_count"))) {
+            validate37.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!(((((((key0 === "cursor") || (key0 === "kind")) || (key0 === "request_id")) || (key0 === "revision")) || (key0 === "status")) || (key0 === "occurred_at")) || (key0 === "used_count"))) {
+                    validate37.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.cursor !== undefined) {
+                    let data0 = data.cursor;
+                    const _errs2 = errors;
+                    if (errors === _errs2) {
+                        if (typeof data0 === "string") {
+                            if (func1(data0) > 1024) {
+                                validate37.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "#/properties/cursor/maxLength", keyword: "maxLength", params: { limit: 1024 }, message: "must NOT have more than 1024 characters" }];
+                                return false;
+                            }
+                            else {
+                                if (func1(data0) < 1) {
+                                    validate37.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "#/properties/cursor/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            validate37.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "#/properties/cursor/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.kind !== undefined) {
+                        let data1 = data.kind;
+                        const _errs4 = errors;
+                        if (typeof data1 !== "string") {
+                            validate37.errors = [{ instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                        if (!((((((((((((data1 === "request.created") || (data1 === "request.approved")) || (data1 === "request.denied")) || (data1 === "request.canceled")) || (data1 === "request.expired")) || (data1 === "grant.revoked")) || (data1 === "grant.reserved")) || (data1 === "grant.consumed")) || (data1 === "grant.released")) || (data1 === "execution.succeeded")) || (data1 === "execution.failed")) || (data1 === "execution.ambiguous"))) {
+                            validate37.errors = [{ instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema53.properties.kind.enum }, message: "must be equal to one of the allowed values" }];
+                            return false;
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.request_id !== undefined) {
+                            let data2 = data.request_id;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 128) {
+                                        validate37.errors = [{ instancePath: instancePath + "/request_id", schemaPath: "#/properties/request_id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                        return false;
+                                    }
+                                    else {
+                                        if (func1(data2) < 1) {
+                                            validate37.errors = [{ instancePath: instancePath + "/request_id", schemaPath: "#/properties/request_id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                            return false;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate37.errors = [{ instancePath: instancePath + "/request_id", schemaPath: "#/properties/request_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.revision !== undefined) {
+                                let data3 = data.revision;
+                                const _errs8 = errors;
+                                if (!(((typeof data3 == "number") && (!(data3 % 1) && !isNaN(data3))) && (isFinite(data3)))) {
+                                    validate37.errors = [{ instancePath: instancePath + "/revision", schemaPath: "#/properties/revision/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                    return false;
+                                }
+                                if (errors === _errs8) {
+                                    if ((typeof data3 == "number") && (isFinite(data3))) {
+                                        if (data3 < 1 || isNaN(data3)) {
+                                            validate37.errors = [{ instancePath: instancePath + "/revision", schemaPath: "#/properties/revision/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                            return false;
+                                        }
+                                    }
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.status !== undefined) {
+                                    let data4 = data.status;
+                                    const _errs10 = errors;
+                                    if (typeof data4 !== "string") {
+                                        validate37.errors = [{ instancePath: instancePath + "/status", schemaPath: "#/$defs/Status/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                    if (!(((((((data4 === "pending") || (data4 === "active")) || (data4 === "denied")) || (data4 === "canceled")) || (data4 === "expired")) || (data4 === "consumed")) || (data4 === "revoked"))) {
+                                        validate37.errors = [{ instancePath: instancePath + "/status", schemaPath: "#/$defs/Status/enum", keyword: "enum", params: { allowedValues: schema38.enum }, message: "must be equal to one of the allowed values" }];
+                                        return false;
+                                    }
+                                    var valid0 = _errs10 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.occurred_at !== undefined) {
+                                        let data5 = data.occurred_at;
+                                        const _errs13 = errors;
+                                        if (errors === _errs13) {
+                                            if (errors === _errs13) {
+                                                if (typeof data5 === "string") {
+                                                    if (!(formats0.validate(data5))) {
+                                                        validate37.errors = [{ instancePath: instancePath + "/occurred_at", schemaPath: "#/properties/occurred_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                else {
+                                                    validate37.errors = [{ instancePath: instancePath + "/occurred_at", schemaPath: "#/properties/occurred_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                            }
+                                        }
+                                        var valid0 = _errs13 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.used_count !== undefined) {
+                                            let data6 = data.used_count;
+                                            const _errs15 = errors;
+                                            if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
+                                                validate37.errors = [{ instancePath: instancePath + "/used_count", schemaPath: "#/properties/used_count/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                                return false;
+                                            }
+                                            if (errors === _errs15) {
+                                                if ((typeof data6 == "number") && (isFinite(data6))) {
+                                                    if (data6 < 0 || isNaN(data6)) {
+                                                        validate37.errors = [{ instancePath: instancePath + "/used_count", schemaPath: "#/properties/used_count/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                                                        return false;
+                                                    }
+                                                }
+                                            }
+                                            var valid0 = _errs15 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate37.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate37.errors = vErrors; return errors === 0; }
+validate37.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate36(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/BrokerEvent" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate36.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate37(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate37.errors : vErrors.concat(validate37.errors);
+    errors = vErrors.length;
+} validate36.errors = vErrors; return errors === 0; }
+validate36.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateErrorEnvelope = validate39;
+const schema55 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/ErrorEnvelope", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/ErrorEnvelope" };
+const schema56 = { "type": "object", "additionalProperties": false, "required": ["error"], "properties": { "error": { "$ref": "#/$defs/Error" } } };
+const schema57 = { "type": "object", "additionalProperties": false, "required": ["code", "message", "correlation_id"], "properties": { "code": { "type": "string", "enum": ["invalid_request", "unauthorized", "forbidden", "not_found", "method_not_allowed", "revision_conflict", "idempotency_conflict", "constraint_exceeded", "invalid_transition", "invalid_decision_token", "cursor_expired", "temporarily_unavailable", "internal_error"] }, "message": { "type": "string", "minLength": 1, "maxLength": 500 }, "correlation_id": { "type": "string", "minLength": 1, "maxLength": 128 }, "current": { "$ref": "#/$defs/BrokerRequest" } } };
+function validate41(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate41.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((((data.code === undefined) && (missing0 = "code")) || ((data.message === undefined) && (missing0 = "message"))) || ((data.correlation_id === undefined) && (missing0 = "correlation_id"))) {
+            validate41.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!((((key0 === "code") || (key0 === "message")) || (key0 === "correlation_id")) || (key0 === "current"))) {
+                    validate41.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.code !== undefined) {
+                    let data0 = data.code;
+                    const _errs2 = errors;
+                    if (typeof data0 !== "string") {
+                        validate41.errors = [{ instancePath: instancePath + "/code", schemaPath: "#/properties/code/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if (!(((((((((((((data0 === "invalid_request") || (data0 === "unauthorized")) || (data0 === "forbidden")) || (data0 === "not_found")) || (data0 === "method_not_allowed")) || (data0 === "revision_conflict")) || (data0 === "idempotency_conflict")) || (data0 === "constraint_exceeded")) || (data0 === "invalid_transition")) || (data0 === "invalid_decision_token")) || (data0 === "cursor_expired")) || (data0 === "temporarily_unavailable")) || (data0 === "internal_error"))) {
+                        validate41.errors = [{ instancePath: instancePath + "/code", schemaPath: "#/properties/code/enum", keyword: "enum", params: { allowedValues: schema57.properties.code.enum }, message: "must be equal to one of the allowed values" }];
+                        return false;
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.message !== undefined) {
+                        let data1 = data.message;
+                        const _errs4 = errors;
+                        if (errors === _errs4) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 500) {
+                                    validate41.errors = [{ instancePath: instancePath + "/message", schemaPath: "#/properties/message/maxLength", keyword: "maxLength", params: { limit: 500 }, message: "must NOT have more than 500 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate41.errors = [{ instancePath: instancePath + "/message", schemaPath: "#/properties/message/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate41.errors = [{ instancePath: instancePath + "/message", schemaPath: "#/properties/message/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.correlation_id !== undefined) {
+                            let data2 = data.correlation_id;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 128) {
+                                        validate41.errors = [{ instancePath: instancePath + "/correlation_id", schemaPath: "#/properties/correlation_id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                        return false;
+                                    }
+                                    else {
+                                        if (func1(data2) < 1) {
+                                            validate41.errors = [{ instancePath: instancePath + "/correlation_id", schemaPath: "#/properties/correlation_id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                            return false;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate41.errors = [{ instancePath: instancePath + "/correlation_id", schemaPath: "#/properties/correlation_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.current !== undefined) {
+                                const _errs8 = errors;
+                                if (!(validate32(data.current, { instancePath: instancePath + "/current", parentData: data, parentDataProperty: "current", rootData, dynamicAnchors }))) {
+                                    vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                    errors = vErrors.length;
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate41.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate41.errors = vErrors; return errors === 0; }
+validate41.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate40(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate40.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((data.error === undefined) && (missing0 = "error")) {
+            validate40.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!(key0 === "error")) {
+                    validate40.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.error !== undefined) {
+                    if (!(validate41(data.error, { instancePath: instancePath + "/error", parentData: data, parentDataProperty: "error", rootData, dynamicAnchors }))) {
+                        vErrors = vErrors === null ? validate41.errors : vErrors.concat(validate41.errors);
+                        errors = vErrors.length;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate40.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate40.errors = vErrors; return errors === 0; }
+validate40.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate39(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/ErrorEnvelope" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate39.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate40(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate40.errors : vErrors.concat(validate40.errors);
+    errors = vErrors.length;
+} validate39.errors = vErrors; return errors === 0; }
+validate39.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateUISnapshot = validate45;
+const schema58 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/UISnapshot", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshot" };
+const schema59 = { "type": "object", "additionalProperties": false, "required": ["api_version", "cursor", "synchronized_at", "sources", "requests"], "properties": { "api_version": { "type": "string", "const": "brokerkit.io/operator-ui/v1" }, "cursor": { "type": "string", "minLength": 1, "maxLength": 128 }, "synchronized_at": { "type": "string", "format": "date-time" }, "sources": { "type": "array", "maxItems": 100, "items": { "$ref": "#/$defs/UISourceHealth" } }, "requests": { "type": "array", "maxItems": 1000, "items": { "$ref": "#/$defs/UIRequest" } }, "delivery_failures": { "type": "integer", "minimum": 0 } } };
+const schema60 = { "type": "object", "additionalProperties": false, "required": ["id", "label", "healthy"], "properties": { "id": { "type": "string", "minLength": 1, "maxLength": 128 }, "label": { "type": "string", "minLength": 1, "maxLength": 200 }, "healthy": { "type": "boolean" }, "last_sync_at": { "type": "string", "format": "date-time" }, "error": { "type": "string", "maxLength": 200 } } };
+const schema61 = { "type": "object", "additionalProperties": false, "required": ["source_id", "source_label", "handle", "request"], "properties": { "source_id": { "type": "string", "minLength": 1, "maxLength": 128 }, "source_label": { "type": "string", "minLength": 1, "maxLength": 200 }, "handle": { "type": "string", "minLength": 22, "maxLength": 256, "pattern": "^[A-Za-z0-9_-]+$" }, "request": { "$ref": "#/$defs/BrokerRequest" } } };
+const pattern4 = new RegExp("^[A-Za-z0-9_-]+$", "u");
+function validate47(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate47.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((((data.source_id === undefined) && (missing0 = "source_id")) || ((data.source_label === undefined) && (missing0 = "source_label"))) || ((data.handle === undefined) && (missing0 = "handle"))) || ((data.request === undefined) && (missing0 = "request"))) {
+            validate47.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!((((key0 === "source_id") || (key0 === "source_label")) || (key0 === "handle")) || (key0 === "request"))) {
+                    validate47.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.source_id !== undefined) {
+                    let data0 = data.source_id;
+                    const _errs2 = errors;
+                    if (errors === _errs2) {
+                        if (typeof data0 === "string") {
+                            if (func1(data0) > 128) {
+                                validate47.errors = [{ instancePath: instancePath + "/source_id", schemaPath: "#/properties/source_id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                return false;
+                            }
+                            else {
+                                if (func1(data0) < 1) {
+                                    validate47.errors = [{ instancePath: instancePath + "/source_id", schemaPath: "#/properties/source_id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            validate47.errors = [{ instancePath: instancePath + "/source_id", schemaPath: "#/properties/source_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.source_label !== undefined) {
+                        let data1 = data.source_label;
+                        const _errs4 = errors;
+                        if (errors === _errs4) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 200) {
+                                    validate47.errors = [{ instancePath: instancePath + "/source_label", schemaPath: "#/properties/source_label/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate47.errors = [{ instancePath: instancePath + "/source_label", schemaPath: "#/properties/source_label/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate47.errors = [{ instancePath: instancePath + "/source_label", schemaPath: "#/properties/source_label/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.handle !== undefined) {
+                            let data2 = data.handle;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 256) {
+                                        validate47.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                                        return false;
+                                    }
+                                    else {
+                                        if (func1(data2) < 22) {
+                                            validate47.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/minLength", keyword: "minLength", params: { limit: 22 }, message: "must NOT have fewer than 22 characters" }];
+                                            return false;
+                                        }
+                                        else {
+                                            if (!pattern4.test(data2)) {
+                                                validate47.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                return false;
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate47.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.request !== undefined) {
+                                const _errs8 = errors;
+                                if (!(validate32(data.request, { instancePath: instancePath + "/request", parentData: data, parentDataProperty: "request", rootData, dynamicAnchors }))) {
+                                    vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                    errors = vErrors.length;
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate47.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate47.errors = vErrors; return errors === 0; }
+validate47.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate46(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate46.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((((((data.api_version === undefined) && (missing0 = "api_version")) || ((data.cursor === undefined) && (missing0 = "cursor"))) || ((data.synchronized_at === undefined) && (missing0 = "synchronized_at"))) || ((data.sources === undefined) && (missing0 = "sources"))) || ((data.requests === undefined) && (missing0 = "requests"))) {
+            validate46.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!((((((key0 === "api_version") || (key0 === "cursor")) || (key0 === "synchronized_at")) || (key0 === "sources")) || (key0 === "requests")) || (key0 === "delivery_failures"))) {
+                    validate46.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.api_version !== undefined) {
+                    let data0 = data.api_version;
+                    const _errs2 = errors;
+                    if (typeof data0 !== "string") {
+                        validate46.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "#/properties/api_version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if ("brokerkit.io/operator-ui/v1" !== data0) {
+                        validate46.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "#/properties/api_version/const", keyword: "const", params: { allowedValue: "brokerkit.io/operator-ui/v1" }, message: "must be equal to constant" }];
+                        return false;
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.cursor !== undefined) {
+                        let data1 = data.cursor;
+                        const _errs4 = errors;
+                        if (errors === _errs4) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 128) {
+                                    validate46.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "#/properties/cursor/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate46.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "#/properties/cursor/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate46.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "#/properties/cursor/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.synchronized_at !== undefined) {
+                            let data2 = data.synchronized_at;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (errors === _errs6) {
+                                    if (typeof data2 === "string") {
+                                        if (!(formats0.validate(data2))) {
+                                            validate46.errors = [{ instancePath: instancePath + "/synchronized_at", schemaPath: "#/properties/synchronized_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                            return false;
+                                        }
+                                    }
+                                    else {
+                                        validate46.errors = [{ instancePath: instancePath + "/synchronized_at", schemaPath: "#/properties/synchronized_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.sources !== undefined) {
+                                let data3 = data.sources;
+                                const _errs8 = errors;
+                                if (errors === _errs8) {
+                                    if (Array.isArray(data3)) {
+                                        if (data3.length > 100) {
+                                            validate46.errors = [{ instancePath: instancePath + "/sources", schemaPath: "#/properties/sources/maxItems", keyword: "maxItems", params: { limit: 100 }, message: "must NOT have more than 100 items" }];
+                                            return false;
+                                        }
+                                        else {
+                                            var valid1 = true;
+                                            const len0 = data3.length;
+                                            for (let i0 = 0; i0 < len0; i0++) {
+                                                let data4 = data3[i0];
+                                                const _errs10 = errors;
+                                                const _errs11 = errors;
+                                                if (errors === _errs11) {
+                                                    if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                                                        let missing1;
+                                                        if ((((data4.id === undefined) && (missing1 = "id")) || ((data4.label === undefined) && (missing1 = "label"))) || ((data4.healthy === undefined) && (missing1 = "healthy"))) {
+                                                            validate46.errors = [{ instancePath: instancePath + "/sources/" + i0, schemaPath: "#/$defs/UISourceHealth/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            const _errs13 = errors;
+                                                            for (const key1 in data4) {
+                                                                if (!(((((key1 === "id") || (key1 === "label")) || (key1 === "healthy")) || (key1 === "last_sync_at")) || (key1 === "error"))) {
+                                                                    validate46.errors = [{ instancePath: instancePath + "/sources/" + i0, schemaPath: "#/$defs/UISourceHealth/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                    return false;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            if (_errs13 === errors) {
+                                                                if (data4.id !== undefined) {
+                                                                    let data5 = data4.id;
+                                                                    const _errs14 = errors;
+                                                                    if (errors === _errs14) {
+                                                                        if (typeof data5 === "string") {
+                                                                            if (func1(data5) > 128) {
+                                                                                validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/id", schemaPath: "#/$defs/UISourceHealth/properties/id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                                                                return false;
+                                                                            }
+                                                                            else {
+                                                                                if (func1(data5) < 1) {
+                                                                                    validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/id", schemaPath: "#/$defs/UISourceHealth/properties/id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/id", schemaPath: "#/$defs/UISourceHealth/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                    var valid3 = _errs14 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid3 = true;
+                                                                }
+                                                                if (valid3) {
+                                                                    if (data4.label !== undefined) {
+                                                                        let data6 = data4.label;
+                                                                        const _errs16 = errors;
+                                                                        if (errors === _errs16) {
+                                                                            if (typeof data6 === "string") {
+                                                                                if (func1(data6) > 200) {
+                                                                                    validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/label", schemaPath: "#/$defs/UISourceHealth/properties/label/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                                                                    return false;
+                                                                                }
+                                                                                else {
+                                                                                    if (func1(data6) < 1) {
+                                                                                        validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/label", schemaPath: "#/$defs/UISourceHealth/properties/label/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            else {
+                                                                                validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/label", schemaPath: "#/$defs/UISourceHealth/properties/label/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        var valid3 = _errs16 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid3 = true;
+                                                                    }
+                                                                    if (valid3) {
+                                                                        if (data4.healthy !== undefined) {
+                                                                            const _errs18 = errors;
+                                                                            if (typeof data4.healthy !== "boolean") {
+                                                                                validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/healthy", schemaPath: "#/$defs/UISourceHealth/properties/healthy/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid3 = _errs18 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid3 = true;
+                                                                        }
+                                                                        if (valid3) {
+                                                                            if (data4.last_sync_at !== undefined) {
+                                                                                let data8 = data4.last_sync_at;
+                                                                                const _errs20 = errors;
+                                                                                if (errors === _errs20) {
+                                                                                    if (errors === _errs20) {
+                                                                                        if (typeof data8 === "string") {
+                                                                                            if (!(formats0.validate(data8))) {
+                                                                                                validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/last_sync_at", schemaPath: "#/$defs/UISourceHealth/properties/last_sync_at/format", keyword: "format", params: { format: "date-time" }, message: "must match format \"" + "date-time" + "\"" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                        }
+                                                                                        else {
+                                                                                            validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/last_sync_at", schemaPath: "#/$defs/UISourceHealth/properties/last_sync_at/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                var valid3 = _errs20 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid3 = true;
+                                                                            }
+                                                                            if (valid3) {
+                                                                                if (data4.error !== undefined) {
+                                                                                    let data9 = data4.error;
+                                                                                    const _errs22 = errors;
+                                                                                    if (errors === _errs22) {
+                                                                                        if (typeof data9 === "string") {
+                                                                                            if (func1(data9) > 200) {
+                                                                                                validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/error", schemaPath: "#/$defs/UISourceHealth/properties/error/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                        }
+                                                                                        else {
+                                                                                            validate46.errors = [{ instancePath: instancePath + "/sources/" + i0 + "/error", schemaPath: "#/$defs/UISourceHealth/properties/error/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                    var valid3 = _errs22 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid3 = true;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate46.errors = [{ instancePath: instancePath + "/sources/" + i0, schemaPath: "#/$defs/UISourceHealth/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid1 = _errs10 === errors;
+                                                if (!valid1) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate46.errors = [{ instancePath: instancePath + "/sources", schemaPath: "#/properties/sources/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.requests !== undefined) {
+                                    let data10 = data.requests;
+                                    const _errs24 = errors;
+                                    if (errors === _errs24) {
+                                        if (Array.isArray(data10)) {
+                                            if (data10.length > 1000) {
+                                                validate46.errors = [{ instancePath: instancePath + "/requests", schemaPath: "#/properties/requests/maxItems", keyword: "maxItems", params: { limit: 1000 }, message: "must NOT have more than 1000 items" }];
+                                                return false;
+                                            }
+                                            else {
+                                                var valid4 = true;
+                                                const len1 = data10.length;
+                                                for (let i1 = 0; i1 < len1; i1++) {
+                                                    const _errs26 = errors;
+                                                    if (!(validate47(data10[i1], { instancePath: instancePath + "/requests/" + i1, parentData: data10, parentDataProperty: i1, rootData, dynamicAnchors }))) {
+                                                        vErrors = vErrors === null ? validate47.errors : vErrors.concat(validate47.errors);
+                                                        errors = vErrors.length;
+                                                    }
+                                                    var valid4 = _errs26 === errors;
+                                                    if (!valid4) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate46.errors = [{ instancePath: instancePath + "/requests", schemaPath: "#/properties/requests/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs24 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.delivery_failures !== undefined) {
+                                        let data12 = data.delivery_failures;
+                                        const _errs27 = errors;
+                                        if (!(((typeof data12 == "number") && (!(data12 % 1) && !isNaN(data12))) && (isFinite(data12)))) {
+                                            validate46.errors = [{ instancePath: instancePath + "/delivery_failures", schemaPath: "#/properties/delivery_failures/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                            return false;
+                                        }
+                                        if (errors === _errs27) {
+                                            if ((typeof data12 == "number") && (isFinite(data12))) {
+                                                if (data12 < 0 || isNaN(data12)) {
+                                                    validate46.errors = [{ instancePath: instancePath + "/delivery_failures", schemaPath: "#/properties/delivery_failures/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                                                    return false;
+                                                }
+                                            }
+                                        }
+                                        var valid0 = _errs27 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate46.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate46.errors = vErrors; return errors === 0; }
+validate46.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate45(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/UISnapshot" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate45.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate46(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
+    errors = vErrors.length;
+} validate45.errors = vErrors; return errors === 0; }
+validate45.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateUISnapshotEvent = validate51;
+const schema62 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/UISnapshotEvent", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent" };
+const schema63 = { "type": "object", "additionalProperties": false, "required": ["api_version", "cursor", "changed"], "properties": { "api_version": { "type": "string", "const": "brokerkit.io/operator-ui/v1" }, "cursor": { "type": "string", "minLength": 1, "maxLength": 128 }, "changed": { "type": "boolean" } } };
+function validate51(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/UISnapshotEvent" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate51.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} const _errs0 = errors; if (errors === _errs0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((((data.api_version === undefined) && (missing0 = "api_version")) || ((data.cursor === undefined) && (missing0 = "cursor"))) || ((data.changed === undefined) && (missing0 = "changed"))) {
+            validate51.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs2 = errors;
+            for (const key0 in data) {
+                if (!(((key0 === "api_version") || (key0 === "cursor")) || (key0 === "changed"))) {
+                    validate51.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs2 === errors) {
+                if (data.api_version !== undefined) {
+                    let data0 = data.api_version;
+                    const _errs3 = errors;
+                    if (typeof data0 !== "string") {
+                        validate51.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/properties/api_version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if ("brokerkit.io/operator-ui/v1" !== data0) {
+                        validate51.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/properties/api_version/const", keyword: "const", params: { allowedValue: "brokerkit.io/operator-ui/v1" }, message: "must be equal to constant" }];
+                        return false;
+                    }
+                    var valid1 = _errs3 === errors;
+                }
+                else {
+                    var valid1 = true;
+                }
+                if (valid1) {
+                    if (data.cursor !== undefined) {
+                        let data1 = data.cursor;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 128) {
+                                    validate51.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/properties/cursor/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate51.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/properties/cursor/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate51.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/properties/cursor/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid1 = _errs5 === errors;
+                    }
+                    else {
+                        var valid1 = true;
+                    }
+                    if (valid1) {
+                        if (data.changed !== undefined) {
+                            const _errs7 = errors;
+                            if (typeof data.changed !== "boolean") {
+                                validate51.errors = [{ instancePath: instancePath + "/changed", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/properties/changed/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                return false;
+                            }
+                            var valid1 = _errs7 === errors;
+                        }
+                        else {
+                            var valid1 = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate51.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISnapshotEvent/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate51.errors = vErrors; return errors === 0; }
+validate51.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateUISummary = validate52;
+const schema64 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/UISummary", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary" };
+const schema65 = { "type": "object", "additionalProperties": false, "required": ["api_version", "cursor", "pending", "healthy"], "properties": { "api_version": { "type": "string", "const": "brokerkit.io/operator-ui/v1" }, "cursor": { "type": "string", "minLength": 1, "maxLength": 128 }, "pending": { "type": "integer", "minimum": 0 }, "healthy": { "type": "boolean" } } };
+function validate52(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/UISummary" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate52.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} const _errs0 = errors; if (errors === _errs0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((((data.api_version === undefined) && (missing0 = "api_version")) || ((data.cursor === undefined) && (missing0 = "cursor"))) || ((data.pending === undefined) && (missing0 = "pending"))) || ((data.healthy === undefined) && (missing0 = "healthy"))) {
+            validate52.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs2 = errors;
+            for (const key0 in data) {
+                if (!((((key0 === "api_version") || (key0 === "cursor")) || (key0 === "pending")) || (key0 === "healthy"))) {
+                    validate52.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs2 === errors) {
+                if (data.api_version !== undefined) {
+                    let data0 = data.api_version;
+                    const _errs3 = errors;
+                    if (typeof data0 !== "string") {
+                        validate52.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/api_version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                    if ("brokerkit.io/operator-ui/v1" !== data0) {
+                        validate52.errors = [{ instancePath: instancePath + "/api_version", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/api_version/const", keyword: "const", params: { allowedValue: "brokerkit.io/operator-ui/v1" }, message: "must be equal to constant" }];
+                        return false;
+                    }
+                    var valid1 = _errs3 === errors;
+                }
+                else {
+                    var valid1 = true;
+                }
+                if (valid1) {
+                    if (data.cursor !== undefined) {
+                        let data1 = data.cursor;
+                        const _errs5 = errors;
+                        if (errors === _errs5) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 128) {
+                                    validate52.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/cursor/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate52.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/cursor/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate52.errors = [{ instancePath: instancePath + "/cursor", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/cursor/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid1 = _errs5 === errors;
+                    }
+                    else {
+                        var valid1 = true;
+                    }
+                    if (valid1) {
+                        if (data.pending !== undefined) {
+                            let data2 = data.pending;
+                            const _errs7 = errors;
+                            if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
+                                validate52.errors = [{ instancePath: instancePath + "/pending", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/pending/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                return false;
+                            }
+                            if (errors === _errs7) {
+                                if ((typeof data2 == "number") && (isFinite(data2))) {
+                                    if (data2 < 0 || isNaN(data2)) {
+                                        validate52.errors = [{ instancePath: instancePath + "/pending", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/pending/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            var valid1 = _errs7 === errors;
+                        }
+                        else {
+                            var valid1 = true;
+                        }
+                        if (valid1) {
+                            if (data.healthy !== undefined) {
+                                const _errs9 = errors;
+                                if (typeof data.healthy !== "boolean") {
+                                    validate52.errors = [{ instancePath: instancePath + "/healthy", schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/properties/healthy/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                    return false;
+                                }
+                                var valid1 = _errs9 === errors;
+                            }
+                            else {
+                                var valid1 = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate52.errors = [{ instancePath, schemaPath: "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UISummary/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate52.errors = vErrors; return errors === 0; }
+validate52.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export const validateUIRequest = validate53;
+const schema66 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://brokerkit.dev/schema/operator/v1/runtime/UIRequest", "$ref": "https://brokerkit.dev/schema/operator/v1/runtime/components#/$defs/UIRequest" };
+function validate54(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate54.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((((data.source_id === undefined) && (missing0 = "source_id")) || ((data.source_label === undefined) && (missing0 = "source_label"))) || ((data.handle === undefined) && (missing0 = "handle"))) || ((data.request === undefined) && (missing0 = "request"))) {
+            validate54.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            const _errs1 = errors;
+            for (const key0 in data) {
+                if (!((((key0 === "source_id") || (key0 === "source_label")) || (key0 === "handle")) || (key0 === "request"))) {
+                    validate54.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                    return false;
+                    break;
+                }
+            }
+            if (_errs1 === errors) {
+                if (data.source_id !== undefined) {
+                    let data0 = data.source_id;
+                    const _errs2 = errors;
+                    if (errors === _errs2) {
+                        if (typeof data0 === "string") {
+                            if (func1(data0) > 128) {
+                                validate54.errors = [{ instancePath: instancePath + "/source_id", schemaPath: "#/properties/source_id/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters" }];
+                                return false;
+                            }
+                            else {
+                                if (func1(data0) < 1) {
+                                    validate54.errors = [{ instancePath: instancePath + "/source_id", schemaPath: "#/properties/source_id/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            validate54.errors = [{ instancePath: instancePath + "/source_id", schemaPath: "#/properties/source_id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs2 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.source_label !== undefined) {
+                        let data1 = data.source_label;
+                        const _errs4 = errors;
+                        if (errors === _errs4) {
+                            if (typeof data1 === "string") {
+                                if (func1(data1) > 200) {
+                                    validate54.errors = [{ instancePath: instancePath + "/source_label", schemaPath: "#/properties/source_label/maxLength", keyword: "maxLength", params: { limit: 200 }, message: "must NOT have more than 200 characters" }];
+                                    return false;
+                                }
+                                else {
+                                    if (func1(data1) < 1) {
+                                        validate54.errors = [{ instancePath: instancePath + "/source_label", schemaPath: "#/properties/source_label/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                            else {
+                                validate54.errors = [{ instancePath: instancePath + "/source_label", schemaPath: "#/properties/source_label/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid0 = _errs4 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.handle !== undefined) {
+                            let data2 = data.handle;
+                            const _errs6 = errors;
+                            if (errors === _errs6) {
+                                if (typeof data2 === "string") {
+                                    if (func1(data2) > 256) {
+                                        validate54.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                                        return false;
+                                    }
+                                    else {
+                                        if (func1(data2) < 22) {
+                                            validate54.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/minLength", keyword: "minLength", params: { limit: 22 }, message: "must NOT have fewer than 22 characters" }];
+                                            return false;
+                                        }
+                                        else {
+                                            if (!pattern4.test(data2)) {
+                                                validate54.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]+$" }, message: "must match pattern \"" + "^[A-Za-z0-9_-]+$" + "\"" }];
+                                                return false;
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate54.errors = [{ instancePath: instancePath + "/handle", schemaPath: "#/properties/handle/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs6 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.request !== undefined) {
+                                const _errs8 = errors;
+                                if (!(validate32(data.request, { instancePath: instancePath + "/request", parentData: data, parentDataProperty: "request", rootData, dynamicAnchors }))) {
+                                    vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                    errors = vErrors.length;
+                                }
+                                var valid0 = _errs8 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate54.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate54.errors = vErrors; return errors === 0; }
+validate54.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+function validate53(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://brokerkit.dev/schema/operator/v1/runtime/UIRequest" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate53.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (!(validate54(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+    vErrors = vErrors === null ? validate54.errors : vErrors.concat(validate54.errors);
+    errors = vErrors.length;
+} validate53.errors = vErrors; return errors === 0; }
+validate53.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };