@arcforges/api-client 1.0.0-ci.19.1 → 1.0.0-ci.201.1

package/dist/shapes/gen/ExtensionWorkflow.js

@@ -0,0 +1,2251 @@
+export function isExtensionWorkflow(value) { return check0(value); }
+/** The schema's declared UTF-8 document bound in bytes. */
+export const extensionWorkflowJsonMaxBytes = 4194304;
+/** Parses one strict ExtensionWorkflow document; refusal kinds match the C# codec. */
+export function tryParseExtensionWorkflowJson(input) {
+    const parsed = strictJson(input, 4194304);
+    if (!parsed.ok)
+        return parsed;
+    return isExtensionWorkflow(parsed.value) ? { ok: true, value: parsed.value } : { ok: false, failure: "invalid" };
+}
+/** Parses one strict ExtensionWorkflow document or throws an error carrying the refusal kind. */
+export function parseExtensionWorkflowJson(input) {
+    const result = tryParseExtensionWorkflowJson(input);
+    if (!result.ok)
+        throw Object.assign(new Error(`ExtensionWorkflow JSON refused: ${result.failure}.`), { failure: result.failure });
+    return result.value;
+}
+/** Writes compact UTF-8 in schema property order and refuses output the schema rejects. */
+export function serializeExtensionWorkflowJson(value) {
+    if (!isExtensionWorkflow(value))
+        throw Object.assign(new Error('Invalid recursive shape'), { failure: 'invalid' });
+    const bytes = new TextEncoder().encode(JSON.stringify(orderExtensionWorkflow(value)));
+    const result = tryParseExtensionWorkflowJson(bytes);
+    if (!result.ok)
+        throw Object.assign(new Error(`ExtensionWorkflow JSON refused: ${result.failure}.`), { failure: result.failure });
+    return bytes;
+}
+function orderExtensionWorkflow(value) {
+    const out = {};
+    out["schemaVersion"] = value["schemaVersion"];
+    out["inputs"] = value["inputs"].map(item => orderWorkflowInput(item));
+    out["nodes"] = value["nodes"].map(item => orderWorkflowNode(item));
+    out["outputs"] = value["outputs"].map(item => orderWorkflowOutput(item));
+    out["limits"] = orderWorkflowLimits(value["limits"]);
+    return out;
+}
+function orderWorkflowAll(value) {
+    const out = {};
+    out["operator"] = value["operator"];
+    out["predicates"] = value["predicates"].map(item => orderWorkflowPredicate(item));
+    return out;
+}
+function orderWorkflowAny(value) {
+    const out = {};
+    out["operator"] = value["operator"];
+    out["predicates"] = value["predicates"].map(item => orderWorkflowPredicate(item));
+    return out;
+}
+function orderWorkflowArgument(value) {
+    const out = {};
+    out["name"] = value["name"];
+    out["value"] = orderWorkflowOperand(value["value"]);
+    return out;
+}
+function orderWorkflowBoolValue(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = value["value"];
+    return out;
+}
+function orderWorkflowCapabilityNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["operationId"] = value["operationId"];
+    out["typedArguments"] = value["typedArguments"].map(item => orderWorkflowArgument(item));
+    out["dependencies"] = value["dependencies"];
+    return out;
+}
+function orderWorkflowComparison(value) {
+    const out = {};
+    out["operator"] = value["operator"];
+    out["left"] = orderWorkflowOperand(value["left"]);
+    out["right"] = orderWorkflowOperand(value["right"]);
+    return out;
+}
+function orderWorkflowConditionNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["predicate"] = orderWorkflowPredicate(value["predicate"]);
+    out["thenNodes"] = value["thenNodes"];
+    out["elseNodes"] = value["elseNodes"];
+    return out;
+}
+function orderWorkflowConstantNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["typedValue"] = orderWorkflowTypedValue(value["typedValue"]);
+    return out;
+}
+function orderWorkflowDecimalValue(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = value["value"];
+    return out;
+}
+function orderWorkflowEnumValue(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = value["value"];
+    return out;
+}
+function orderWorkflowExists(value) {
+    const out = {};
+    out["operator"] = value["operator"];
+    out["valueRef"] = orderWorkflowValueRef(value["valueRef"]);
+    return out;
+}
+function orderWorkflowForeachNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["inputArray"] = orderWorkflowValueRef(value["inputArray"]);
+    out["maxItems"] = value["maxItems"];
+    out["body"] = value["body"].map(item => orderWorkflowNode(item));
+    return out;
+}
+function orderWorkflowInput(value) {
+    const out = {};
+    out["name"] = value["name"];
+    out["schemaId"] = value["schemaId"];
+    out["required"] = value["required"];
+    return out;
+}
+function orderWorkflowInputNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["name"] = value["name"];
+    return out;
+}
+function orderWorkflowInt64Value(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = value["value"];
+    return out;
+}
+function orderWorkflowLimits(value) {
+    const out = {};
+    out["maxExpandedSteps"] = value["maxExpandedSteps"];
+    out["maxForEachNesting"] = value["maxForEachNesting"];
+    out["maxPredicateDepth"] = value["maxPredicateDepth"];
+    out["maxPredicateNodes"] = value["maxPredicateNodes"];
+    return out;
+}
+function orderWorkflowLiteralOperand(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = orderWorkflowTypedValue(value["value"]);
+    return out;
+}
+function orderWorkflowNode(value) {
+    if (check9(value))
+        return orderWorkflowConstantNode(value);
+    if (check39(value))
+        return orderWorkflowInputNode(value);
+    if (check43(value))
+        return orderWorkflowSelectNode(value);
+    if (check50(value))
+        return orderWorkflowCapabilityNode(value);
+    if (check64(value))
+        return orderWorkflowConditionNode(value);
+    if (check82(value))
+        return orderWorkflowForeachNode(value);
+    if (check87(value))
+        return orderWorkflowOutputNode(value);
+    throw new TypeError('Invalid closed union');
+}
+function orderWorkflowOperand(value) {
+    if (check58(value))
+        return orderWorkflowLiteralOperand(value);
+    if (check60(value))
+        return orderWorkflowReferenceOperand(value);
+    throw new TypeError('Invalid closed union');
+}
+function orderWorkflowOutput(value) {
+    const out = {};
+    out["name"] = value["name"];
+    out["schemaId"] = value["schemaId"];
+    out["valueRef"] = orderWorkflowValueRef(value["valueRef"]);
+    return out;
+}
+function orderWorkflowOutputNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["valueRef"] = orderWorkflowValueRef(value["valueRef"]);
+    return out;
+}
+function orderWorkflowPredicate(value) {
+    if (check68(value))
+        return orderWorkflowComparison(value);
+    if (check70(value))
+        return orderWorkflowExists(value);
+    if (check72(value))
+        return orderWorkflowAll(value);
+    if (check75(value))
+        return orderWorkflowAny(value);
+    throw new TypeError('Invalid closed union');
+}
+function orderWorkflowReferenceOperand(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["valueRef"] = orderWorkflowValueRef(value["valueRef"]);
+    return out;
+}
+function orderWorkflowResourceRef(value) {
+    const out = {};
+    out["realmId"] = value["realmId"];
+    if (value["workspaceId"] !== undefined)
+        out["workspaceId"] = value["workspaceId"];
+    out["ownerAppId"] = value["ownerAppId"];
+    out["resourceKind"] = value["resourceKind"];
+    out["resourceId"] = value["resourceId"];
+    if (value["displayHint"] !== undefined)
+        out["displayHint"] = value["displayHint"];
+    out["availability"] = value["availability"];
+    if (value["holdingDeviceId"] !== undefined)
+        out["holdingDeviceId"] = value["holdingDeviceId"];
+    return out;
+}
+function orderWorkflowResourceRefValue(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = orderWorkflowResourceRef(value["value"]);
+    return out;
+}
+function orderWorkflowSelectNode(value) {
+    const out = {};
+    out["id"] = value["id"];
+    out["kind"] = value["kind"];
+    out["source"] = orderWorkflowValueRef(value["source"]);
+    out["recordField"] = value["recordField"];
+    return out;
+}
+function orderWorkflowTextValue(value) {
+    const out = {};
+    out["kind"] = value["kind"];
+    out["value"] = value["value"];
+    return out;
+}
+function orderWorkflowTypedValue(value) {
+    if (check13(value))
+        return orderWorkflowTextValue(value);
+    if (check16(value))
+        return orderWorkflowBoolValue(value);
+    if (check19(value))
+        return orderWorkflowInt64Value(value);
+    if (check22(value))
+        return orderWorkflowDecimalValue(value);
+    if (check25(value))
+        return orderWorkflowEnumValue(value);
+    if (check28(value))
+        return orderWorkflowResourceRefValue(value);
+    throw new TypeError('Invalid closed union');
+}
+function orderWorkflowValueRef(value) {
+    const out = {};
+    out["nodeId"] = value["nodeId"];
+    out["field"] = value["field"];
+    return out;
+}
+function check0(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "schemaVersion":
+                if (!check1(object[key], depth + 1))
+                    return false;
+                break;
+            case "inputs":
+                if (!check2(object[key], depth + 1))
+                    return false;
+                break;
+            case "nodes":
+                if (!check7(object[key], depth + 1))
+                    return false;
+                break;
+            case "outputs":
+                if (!check90(object[key], depth + 1))
+                    return false;
+                break;
+            case "limits":
+                if (!check94(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "schemaVersion"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "inputs"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "nodes"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "outputs"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "limits"))
+        return false;
+    if (!workflowGraph(value))
+        return false;
+    return true;
+}
+function check1(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "workflow.v1")
+        return false;
+    return true;
+}
+function check2(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 64)
+        return false;
+    if (!value.every(item => check3(item, depth + 1)))
+        return false;
+    return true;
+}
+function check3(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "name":
+                if (!check4(object[key], depth + 1))
+                    return false;
+                break;
+            case "schemaId":
+                if (!check5(object[key], depth + 1))
+                    return false;
+                break;
+            case "required":
+                if (!check6(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "name"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "schemaId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "required"))
+        return false;
+    return true;
+}
+function check4(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check5(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check6(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'boolean')
+        return false;
+    return true;
+}
+function check7(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 256)
+        return false;
+    if (!value.every(item => check8(item, depth + 1)))
+        return false;
+    return true;
+}
+function check8(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if ((check9(value, depth + 1) ? 1 : 0) + (check39(value, depth + 1) ? 1 : 0) + (check43(value, depth + 1) ? 1 : 0) + (check50(value, depth + 1) ? 1 : 0) + (check64(value, depth + 1) ? 1 : 0) + (check82(value, depth + 1) ? 1 : 0) + (check87(value, depth + 1) ? 1 : 0) !== 1)
+        return false;
+    return true;
+}
+function check9(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check10(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check11(object[key], depth + 1))
+                    return false;
+                break;
+            case "typedValue":
+                if (!check12(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "typedValue"))
+        return false;
+    return true;
+}
+function check10(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check11(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "constant")
+        return false;
+    return true;
+}
+function check12(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if ((check13(value, depth + 1) ? 1 : 0) + (check16(value, depth + 1) ? 1 : 0) + (check19(value, depth + 1) ? 1 : 0) + (check22(value, depth + 1) ? 1 : 0) + (check25(value, depth + 1) ? 1 : 0) + (check28(value, depth + 1) ? 1 : 0) !== 1)
+        return false;
+    return true;
+}
+function check13(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check14(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check15(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check14(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "text")
+        return false;
+    return true;
+}
+function check15(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 4096)
+        return false;
+    return true;
+}
+function check16(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check17(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check18(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check17(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "bool")
+        return false;
+    return true;
+}
+function check18(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'boolean')
+        return false;
+    return true;
+}
+function check19(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check20(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check21(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check20(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "int64")
+        return false;
+    return true;
+}
+function check21(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 20)
+        return false;
+    if ((new RegExp("^(0|-[1-9][0-9]*|[1-9][0-9]*)$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (BigInt(value) < -9223372036854775808n || BigInt(value) > 9223372036854775807n)
+        return false;
+    return true;
+}
+function check22(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check23(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check24(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check23(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "decimal")
+        return false;
+    return true;
+}
+function check24(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 39)
+        return false;
+    if ((new RegExp("^(0|-?[1-9][0-9]*|-?(0|[1-9][0-9]*)\\.[0-9]{0,8}[1-9])$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (!canonicalDecimal(value))
+        return false;
+    return true;
+}
+function check25(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check26(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check27(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check26(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "enum")
+        return false;
+    return true;
+}
+function check27(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check28(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check29(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check30(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check29(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "resourceRef")
+        return false;
+    return true;
+}
+function check30(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "realmId":
+                if (!check31(object[key], depth + 1))
+                    return false;
+                break;
+            case "workspaceId":
+                if (!check32(object[key], depth + 1))
+                    return false;
+                break;
+            case "ownerAppId":
+                if (!check33(object[key], depth + 1))
+                    return false;
+                break;
+            case "resourceKind":
+                if (!check34(object[key], depth + 1))
+                    return false;
+                break;
+            case "resourceId":
+                if (!check35(object[key], depth + 1))
+                    return false;
+                break;
+            case "displayHint":
+                if (!check36(object[key], depth + 1))
+                    return false;
+                break;
+            case "availability":
+                if (!check37(object[key], depth + 1))
+                    return false;
+                break;
+            case "holdingDeviceId":
+                if (!check38(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "realmId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "ownerAppId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "resourceKind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "resourceId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "availability"))
+        return false;
+    return true;
+}
+function check31(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 36)
+        return false;
+    if ((new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (value === '00000000-0000-0000-0000-000000000000')
+        return false;
+    return true;
+}
+function check32(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 36)
+        return false;
+    if ((new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (value === '00000000-0000-0000-0000-000000000000')
+        return false;
+    return true;
+}
+function check33(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check34(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check35(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 36)
+        return false;
+    if ((new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (value === '00000000-0000-0000-0000-000000000000')
+        return false;
+    return true;
+}
+function check36(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 256)
+        return false;
+    return true;
+}
+function check37(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "AlwaysKeep" && value !== "AvailableOffline" && value !== "OnDemand" && value !== "CloudOnly" && value !== "MissingExternal")
+        return false;
+    return true;
+}
+function check38(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 36)
+        return false;
+    if ((new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (value === '00000000-0000-0000-0000-000000000000')
+        return false;
+    return true;
+}
+function check39(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check40(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check41(object[key], depth + 1))
+                    return false;
+                break;
+            case "name":
+                if (!check42(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "name"))
+        return false;
+    return true;
+}
+function check40(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check41(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "input")
+        return false;
+    return true;
+}
+function check42(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check43(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check44(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check45(object[key], depth + 1))
+                    return false;
+                break;
+            case "source":
+                if (!check46(object[key], depth + 1))
+                    return false;
+                break;
+            case "recordField":
+                if (!check49(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "source"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "recordField"))
+        return false;
+    return true;
+}
+function check44(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check45(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "select")
+        return false;
+    return true;
+}
+function check46(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "nodeId":
+                if (!check47(object[key], depth + 1))
+                    return false;
+                break;
+            case "field":
+                if (!check48(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "nodeId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "field"))
+        return false;
+    return true;
+}
+function check47(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check48(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check49(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check50(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check51(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check52(object[key], depth + 1))
+                    return false;
+                break;
+            case "operationId":
+                if (!check53(object[key], depth + 1))
+                    return false;
+                break;
+            case "typedArguments":
+                if (!check54(object[key], depth + 1))
+                    return false;
+                break;
+            case "dependencies":
+                if (!check62(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "operationId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "typedArguments"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "dependencies"))
+        return false;
+    return true;
+}
+function check51(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check52(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "capability")
+        return false;
+    return true;
+}
+function check53(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check54(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 64)
+        return false;
+    if (!value.every(item => check55(item, depth + 1)))
+        return false;
+    return true;
+}
+function check55(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "name":
+                if (!check56(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check57(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "name"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check56(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check57(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if ((check58(value, depth + 1) ? 1 : 0) + (check60(value, depth + 1) ? 1 : 0) !== 1)
+        return false;
+    return true;
+}
+function check58(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check59(object[key], depth + 1))
+                    return false;
+                break;
+            case "value":
+                if (!check12(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "value"))
+        return false;
+    return true;
+}
+function check59(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "literal")
+        return false;
+    return true;
+}
+function check60(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "kind":
+                if (!check61(object[key], depth + 1))
+                    return false;
+                break;
+            case "valueRef":
+                if (!check46(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "valueRef"))
+        return false;
+    return true;
+}
+function check61(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "reference")
+        return false;
+    return true;
+}
+function check62(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 256)
+        return false;
+    if (!value.every(item => check63(item, depth + 1)))
+        return false;
+    return true;
+}
+function check63(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check64(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check65(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check66(object[key], depth + 1))
+                    return false;
+                break;
+            case "predicate":
+                if (!check67(object[key], depth + 1))
+                    return false;
+                break;
+            case "thenNodes":
+                if (!check78(object[key], depth + 1))
+                    return false;
+                break;
+            case "elseNodes":
+                if (!check80(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "predicate"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "thenNodes"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "elseNodes"))
+        return false;
+    return true;
+}
+function check65(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check66(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "condition")
+        return false;
+    return true;
+}
+function check67(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if ((check68(value, depth + 1) ? 1 : 0) + (check70(value, depth + 1) ? 1 : 0) + (check72(value, depth + 1) ? 1 : 0) + (check75(value, depth + 1) ? 1 : 0) !== 1)
+        return false;
+    return true;
+}
+function check68(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "operator":
+                if (!check69(object[key], depth + 1))
+                    return false;
+                break;
+            case "left":
+                if (!check57(object[key], depth + 1))
+                    return false;
+                break;
+            case "right":
+                if (!check57(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "operator"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "left"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "right"))
+        return false;
+    return true;
+}
+function check69(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "eq" && value !== "ne" && value !== "lt" && value !== "le" && value !== "gt" && value !== "ge")
+        return false;
+    return true;
+}
+function check70(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "operator":
+                if (!check71(object[key], depth + 1))
+                    return false;
+                break;
+            case "valueRef":
+                if (!check46(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "operator"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "valueRef"))
+        return false;
+    return true;
+}
+function check71(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "exists")
+        return false;
+    return true;
+}
+function check72(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "operator":
+                if (!check73(object[key], depth + 1))
+                    return false;
+                break;
+            case "predicates":
+                if (!check74(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "operator"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "predicates"))
+        return false;
+    return true;
+}
+function check73(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "all")
+        return false;
+    return true;
+}
+function check74(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 1)
+        return false;
+    if (value.length > 128)
+        return false;
+    if (!value.every(item => check67(item, depth + 1)))
+        return false;
+    return true;
+}
+function check75(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "operator":
+                if (!check76(object[key], depth + 1))
+                    return false;
+                break;
+            case "predicates":
+                if (!check77(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "operator"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "predicates"))
+        return false;
+    return true;
+}
+function check76(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "any")
+        return false;
+    return true;
+}
+function check77(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 1)
+        return false;
+    if (value.length > 128)
+        return false;
+    if (!value.every(item => check67(item, depth + 1)))
+        return false;
+    return true;
+}
+function check78(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 256)
+        return false;
+    if (!value.every(item => check79(item, depth + 1)))
+        return false;
+    return true;
+}
+function check79(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check80(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 256)
+        return false;
+    if (!value.every(item => check81(item, depth + 1)))
+        return false;
+    return true;
+}
+function check81(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check82(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check83(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check84(object[key], depth + 1))
+                    return false;
+                break;
+            case "inputArray":
+                if (!check46(object[key], depth + 1))
+                    return false;
+                break;
+            case "maxItems":
+                if (!check85(object[key], depth + 1))
+                    return false;
+                break;
+            case "body":
+                if (!check86(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "inputArray"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "maxItems"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "body"))
+        return false;
+    return true;
+}
+function check83(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check84(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "foreach")
+        return false;
+    return true;
+}
+function check85(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        return false;
+    if (value < 1)
+        return false;
+    if (value > 100)
+        return false;
+    return true;
+}
+function check86(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 256)
+        return false;
+    if (!value.every(item => check8(item, depth + 1)))
+        return false;
+    return true;
+}
+function check87(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "id":
+                if (!check88(object[key], depth + 1))
+                    return false;
+                break;
+            case "kind":
+                if (!check89(object[key], depth + 1))
+                    return false;
+                break;
+            case "valueRef":
+                if (!check46(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "id"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "kind"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "valueRef"))
+        return false;
+    return true;
+}
+function check88(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check89(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "output")
+        return false;
+    return true;
+}
+function check90(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 64)
+        return false;
+    if (!value.every(item => check91(item, depth + 1)))
+        return false;
+    return true;
+}
+function check91(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "name":
+                if (!check92(object[key], depth + 1))
+                    return false;
+                break;
+            case "schemaId":
+                if (!check93(object[key], depth + 1))
+                    return false;
+                break;
+            case "valueRef":
+                if (!check46(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "name"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "schemaId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "valueRef"))
+        return false;
+    return true;
+}
+function check92(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check93(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check94(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "maxExpandedSteps":
+                if (!check95(object[key], depth + 1))
+                    return false;
+                break;
+            case "maxForEachNesting":
+                if (!check96(object[key], depth + 1))
+                    return false;
+                break;
+            case "maxPredicateDepth":
+                if (!check97(object[key], depth + 1))
+                    return false;
+                break;
+            case "maxPredicateNodes":
+                if (!check98(object[key], depth + 1))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "maxExpandedSteps"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "maxForEachNesting"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "maxPredicateDepth"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "maxPredicateNodes"))
+        return false;
+    return true;
+}
+function check95(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        return false;
+    if (value < 1)
+        return false;
+    if (value > 256)
+        return false;
+    return true;
+}
+function check96(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        return false;
+    if (value < 0)
+        return false;
+    if (value > 2)
+        return false;
+    return true;
+}
+function check97(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        return false;
+    if (value < 1)
+        return false;
+    if (value > 8)
+        return false;
+    return true;
+}
+function check98(value, depth = 0) {
+    if (depth >= 128)
+        return false;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        return false;
+    if (value < 1)
+        return false;
+    if (value > 128)
+        return false;
+    return true;
+}
+/** Strict UTF-8 JSON: no BOM, comments, trailing commas or duplicate properties; depth <= 32; integer lexemes only. */
+function strictJson(input, maxBytes) {
+    let text;
+    if (typeof input === "string") {
+        if (!validText(input))
+            return { ok: false, failure: "malformed" };
+        if (new TextEncoder().encode(input).byteLength > maxBytes)
+            return { ok: false, failure: "tooLarge" };
+        text = input;
+    }
+    else {
+        if (input.byteLength > maxBytes)
+            return { ok: false, failure: "tooLarge" };
+        try {
+            text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input);
+        }
+        catch {
+            return { ok: false, failure: "malformed" };
+        }
+    }
+    try {
+        return { ok: true, value: new StrictJsonReader(text).document() };
+    }
+    catch {
+        return { ok: false, failure: "malformed" };
+    }
+}
+class StrictJsonReader {
+    text;
+    index = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    document() {
+        this.space();
+        const value = this.value(0);
+        this.space();
+        if (this.index !== this.text.length)
+            throw new SyntaxError("Trailing JSON content");
+        return value;
+    }
+    value(depth) {
+        switch (this.text[this.index]) {
+            case "{": return this.object(depth + 1);
+            case "[": return this.array(depth + 1);
+            case '"': return this.string();
+            case "t": return this.literal("true", true);
+            case "f": return this.literal("false", false);
+            case "n": return this.literal("null", null);
+            default: return this.number();
+        }
+    }
+    object(depth) {
+        if (depth > 32)
+            throw new SyntaxError("JSON depth exceeded");
+        this.index++;
+        const out = {};
+        const keys = new Set();
+        this.space();
+        if (this.text[this.index] === "}") {
+            this.index++;
+            return out;
+        }
+        for (;;) {
+            this.space();
+            if (this.text[this.index] !== '"')
+                throw new SyntaxError("Expected property name");
+            const key = this.string();
+            if (keys.has(key))
+                throw new SyntaxError("Duplicate JSON property");
+            keys.add(key);
+            this.space();
+            if (this.text[this.index++] !== ":")
+                throw new SyntaxError("Expected colon");
+            this.space();
+            // defineProperty keeps names such as __proto__ as ordinary own properties.
+            Object.defineProperty(out, key, { value: this.value(depth), enumerable: true, writable: true, configurable: true });
+            this.space();
+            const next = this.text[this.index++];
+            if (next === "}")
+                return out;
+            if (next !== ",")
+                throw new SyntaxError("Expected comma");
+        }
+    }
+    array(depth) {
+        if (depth > 32)
+            throw new SyntaxError("JSON depth exceeded");
+        this.index++;
+        const out = [];
+        this.space();
+        if (this.text[this.index] === "]") {
+            this.index++;
+            return out;
+        }
+        for (;;) {
+            this.space();
+            out.push(this.value(depth));
+            this.space();
+            const next = this.text[this.index++];
+            if (next === "]")
+                return out;
+            if (next !== ",")
+                throw new SyntaxError("Expected comma");
+        }
+    }
+    string() {
+        this.index++;
+        let out = "";
+        for (;;) {
+            const c = this.text[this.index++];
+            if (c === undefined)
+                throw new SyntaxError("Unterminated string");
+            if (c === '"')
+                break;
+            if (c < " ")
+                throw new SyntaxError("Unescaped control character");
+            if (c !== "\\") {
+                out += c;
+                continue;
+            }
+            const e = this.text[this.index++];
+            const simple = { '"': '"', "\\": "\\", "/": "/", b: "\b", f: "\f", n: "\n", r: "\r", t: "\t" };
+            if (e !== undefined && e in simple) {
+                out += simple[e];
+                continue;
+            }
+            if (e !== "u" || !/^[0-9a-fA-F]{4}$/.test(this.text.slice(this.index, this.index + 4)))
+                throw new SyntaxError("Invalid escape");
+            out += String.fromCharCode(parseInt(this.text.slice(this.index, this.index + 4), 16));
+            this.index += 4;
+        }
+        if (!validText(out))
+            throw new SyntaxError("Lone surrogate escape");
+        return out;
+    }
+    number() {
+        const match = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/y;
+        match.lastIndex = this.index;
+        const found = match.exec(this.text);
+        if (found === null)
+            throw new SyntaxError("Invalid JSON value");
+        this.index = match.lastIndex;
+        // Selected schemas have no fractional numbers; fraction/exponent lexemes never satisfy an integer.
+        return found[1] !== undefined || found[2] !== undefined ? Number.NaN : Number(found[0]);
+    }
+    literal(word, value) {
+        if (this.text.slice(this.index, this.index + word.length) !== word)
+            throw new SyntaxError("Invalid JSON literal");
+        this.index += word.length;
+        return value;
+    }
+    space() {
+        while (this.text[this.index] === " " || this.text[this.index] === "\t" || this.text[this.index] === "\n" || this.text[this.index] === "\r")
+            this.index++;
+    }
+}
+function validText(value) {
+    for (const scalar of value) {
+        const point = scalar.codePointAt(0);
+        if (point >= 0xd800 && point <= 0xdfff)
+            return false;
+    }
+    return true;
+}
+function inventoryRules(value) {
+    const files = value.files;
+    const seen = new Set();
+    let previous;
+    let total = 0n;
+    for (const file of files) {
+        const path = file.path;
+        const folded = path.toUpperCase();
+        if (path.length === 0 || folded === 'INVENTORY.JSON' || folded === 'SIGNATURE.JSON' || seen.has(folded) || (previous !== undefined && previous >= path))
+            return false;
+        for (const segment of path.split('/')) {
+            if (!/^[A-Za-z0-9_.-]+$/.test(segment) || segment === '.' || segment === '..' || segment.endsWith('.') || /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(segment))
+                return false;
+        }
+        const size = BigInt(file.size);
+        if (size > 134217728n)
+            return false;
+        total += size;
+        if (total > 1073741824n)
+            return false;
+        seen.add(folded);
+        previous = path;
+    }
+    return files.some(file => file.path === 'manifest.json');
+}
+function canonicalDecimal(value) {
+    if (/^-?(0|[1-9][0-9]*)(\.[0-9]{1,9})?$/u.exec(value)?.[0] !== value || value === '-0' || (value.includes('.') && value.endsWith('0')))
+        return false;
+    return value.replace('-', '').replace('.', '').replace(/^0+/u, '').length <= 28;
+}
+function workflowGraph(value) {
+    const root = value;
+    const obj = (x) => x;
+    const list = (x) => x;
+    const names = (xs, key) => xs.map(x => obj(x)[key]);
+    const unique = (xs) => new Set(xs).size === xs.length;
+    const inputs = names(list(root.inputs), 'name');
+    if (!unique(inputs) || !unique(names(list(root.outputs), 'name')))
+        return false;
+    const nodes = new Map();
+    const scopes = new Map();
+    const edges = new Map();
+    const limits = obj(root.limits);
+    let expanded = 0;
+    function collect(items, ancestors, depth, weight) {
+        const local = names(items, 'id');
+        const scope = new Set([...ancestors, ...local]);
+        for (const raw of items) {
+            const n = obj(raw), id = n.id;
+            if (nodes.has(id))
+                return false;
+            nodes.set(id, n);
+            scopes.set(id, scope);
+            edges.set(id, new Set());
+            expanded += weight;
+            if (expanded > limits.maxExpandedSteps)
+                return false;
+            if (n.kind === 'foreach') {
+                if (depth + 1 > limits.maxForEachNesting)
+                    return false;
+                const childAncestors = new Set(scope);
+                childAncestors.delete(id);
+                if (!collect(list(n.body), childAncestors, depth + 1, weight * n.maxItems))
+                    return false;
+            }
+        }
+        return true;
+    }
+    if (!collect(list(root.nodes), new Set(), 0, 1))
+        return false;
+    function reference(raw, consumer, scope) {
+        const r = obj(raw), id = r.nodeId, target = nodes.get(id);
+        if (!target || id === consumer || !scope.has(id))
+            return false;
+        // Constant/output nodes expose one known field. Installed-schema fields are bound by the owner.
+        if ((target.kind === 'constant' || target.kind === 'output') && r.field !== 'value')
+            return false;
+        if (target.kind === 'condition' || target.kind === 'foreach')
+            return false;
+        if (consumer)
+            edges.get(consumer).add(id);
+        return true;
+    }
+    function operand(raw, id) {
+        const o = obj(raw);
+        return o.kind !== 'reference' || reference(o.valueRef, id, scopes.get(id));
+    }
+    function knownKind(raw) {
+        const o = obj(raw);
+        if (o.kind === 'literal')
+            return obj(o.value).kind;
+        const target = nodes.get(obj(o.valueRef).nodeId);
+        return target?.kind === 'constant' ? obj(target.typedValue).kind : undefined;
+    }
+    function predicate(raw, id, depth, count) {
+        const p = obj(raw), op = p.operator;
+        if (depth > limits.maxPredicateDepth || ++count.value > limits.maxPredicateNodes)
+            return false;
+        if (op === 'all' || op === 'any')
+            return list(p.predicates).every(x => predicate(x, id, depth + 1, count));
+        if (op === 'exists')
+            return reference(p.valueRef, id, scopes.get(id));
+        if (!operand(p.left, id) || !operand(p.right, id))
+            return false;
+        const left = knownKind(p.left), right = knownKind(p.right);
+        if (left !== undefined && right !== undefined && left !== right)
+            return false;
+        if (op !== 'eq' && op !== 'ne' && [left, right].some(x => x === 'bool' || x === 'resourceRef'))
+            return false;
+        return true;
+    }
+    function validateBlock(items) {
+        const siblingIds = new Set(names(items, 'id'));
+        for (const raw of items) {
+            const n = obj(raw), id = n.id, scope = scopes.get(id);
+            if (n.kind === 'input' && !inputs.includes(n.name))
+                return false;
+            if (n.kind === 'select' && (!reference(n.source, id, scope) || nodes.get(obj(n.source).nodeId).kind === 'constant'))
+                return false;
+            if (n.kind === 'output' && !reference(n.valueRef, id, scope))
+                return false;
+            if (n.kind === 'capability') {
+                if (!unique(names(list(n.typedArguments), 'name')) || !unique(n.dependencies))
+                    return false;
+                for (const dep of n.dependencies) {
+                    if (dep === id || !scope.has(dep))
+                        return false;
+                    edges.get(id).add(dep);
+                }
+                if (!list(n.typedArguments).every(x => operand(obj(x).value, id)))
+                    return false;
+            }
+            if (n.kind === 'condition') {
+                if (!predicate(n.predicate, id, 1, { value: 0 }))
+                    return false;
+                const branches = [...n.thenNodes, ...n.elseNodes];
+                if (!unique(branches))
+                    return false;
+                for (const child of branches) {
+                    if (child === id || !siblingIds.has(child))
+                        return false;
+                    // Branches execute after their condition. Cycles reject future-output predicates
+                    // and branches already required by the condition, independent of array order.
+                    edges.get(child).add(id);
+                }
+            }
+            if (n.kind === 'foreach') {
+                if (!reference(n.inputArray, id, scope))
+                    return false;
+                const source = nodes.get(obj(n.inputArray).nodeId);
+                if (source.kind === 'constant')
+                    return false; // All declared constant kinds are scalar.
+                if (!validateBlock(list(n.body)))
+                    return false;
+                for (const child of list(n.body))
+                    edges.get(id).add(obj(child).id);
+            }
+        }
+        return true;
+    }
+    if (!validateBlock(list(root.nodes)))
+        return false;
+    const top = new Set(names(list(root.nodes), 'id'));
+    if (!list(root.outputs).every(x => reference(obj(x).valueRef, '', top)))
+        return false;
+    const visiting = new Set(), done = new Set();
+    function acyclic(id) {
+        if (done.has(id))
+            return true;
+        if (visiting.has(id))
+            return false;
+        visiting.add(id);
+        for (const dependency of edges.get(id))
+            if (!acyclic(dependency))
+                return false;
+        visiting.delete(id);
+        done.add(id);
+        return true;
+    }
+    return [...nodes.keys()].every(acyclic);
+}