@noeos/verification-engine 0.0.0

package/dist/types/validation/diagnostic-collector.d.ts

@@ -0,0 +1,24 @@
+import type { Diagnostic, DiagnosticCode, DiagnosticDetail, DiagnosticPhase, DiagnosticSeverity } from "../domain/diagnostic.js";
+import type { Limits } from "../domain/limits.js";
+export interface DiagnosticOptions {
+    readonly path?: string;
+    readonly recordId?: string;
+    readonly position?: number;
+    readonly details?: Readonly<Record<string, DiagnosticDetail>>;
+    readonly causeCode?: string;
+    /** Only RuleSet may override the catalog default for RULE_FAILED. */
+    readonly severity?: DiagnosticSeverity;
+    /** Stable namespaced key supplied by a trusted rule. */
+    readonly messageKey?: string;
+}
+export declare function createDiagnostic(code: DiagnosticCode, phase: DiagnosticPhase, options?: DiagnosticOptions): Diagnostic;
+export declare class DiagnosticCollector {
+    private readonly limits;
+    private readonly entries;
+    private truncated;
+    constructor(limits: Limits);
+    add(diagnostic: Diagnostic): void;
+    addCode(code: DiagnosticCode, phase: DiagnosticPhase, options?: DiagnosticOptions): void;
+    hasErrors(): boolean;
+    finish(): readonly Diagnostic[];
+}

package/dist/types/validation/digest-validation.d.ts

@@ -0,0 +1,6 @@
+import type { AlgorithmId } from "../domain/algorithm-id.js";
+import { Digest } from "../domain/digest.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function digestLength(algorithm: AlgorithmId): number;
+export declare function validateDigest(value: unknown, algorithm: unknown): OperationResult<Digest>;
+export declare function equalDigest(left: Digest, right: Digest): boolean;

package/dist/types/validation/identifier-validation.d.ts

@@ -0,0 +1,6 @@
+import type { ContextId, ProfileId, RecordId, SequenceId } from "../domain/identifiers.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function validateRecordId(value: unknown): OperationResult<RecordId>;
+export declare function validateSequenceId(value: unknown): OperationResult<SequenceId>;
+export declare function validateContextId(value: unknown): OperationResult<ContextId>;
+export declare function validateProfileId(value: unknown): OperationResult<ProfileId>;

package/dist/types/validation/json-text-parser.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from "../domain/json-value.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function parseJsonText(input: unknown, limits: Limits): OperationResult<JsonValue>;

package/dist/types/validation/json-value-validation.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from "../domain/json-value.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function validateJsonValue(value: unknown, limits: Limits): OperationResult<JsonValue>;

package/dist/types/validation/limit-validation.d.ts

@@ -0,0 +1,4 @@
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function validateLimits(value: unknown): OperationResult<Limits>;
+export declare function validateLimitValue(value: number, maximum: number): OperationResult<number>;

package/dist/types/validation/object-inspection.d.ts

@@ -0,0 +1,11 @@
+export type DataProperty = readonly [name: string, value: unknown];
+export type ExactPropertyValues = readonly unknown[];
+interface DataPropertyDescriptor extends PropertyDescriptor {
+    readonly value: unknown;
+}
+export declare function inspectPlainObject(value: unknown): readonly DataProperty[] | undefined;
+/** Internal fixed-shape inspection that preserves the no-getter/no-proxy boundary. */
+export declare function inspectExactProperties(value: unknown, names: readonly string[]): ExactPropertyValues | undefined;
+export declare function isDataPropertyDescriptor(descriptor: PropertyDescriptor): descriptor is DataPropertyDescriptor;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export {};

package/dist/types/validation/position-validation.d.ts

@@ -0,0 +1,3 @@
+import { Position } from "../domain/position.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function validatePosition(value: unknown): OperationResult<Position>;

package/dist/types/validation/result-helpers.d.ts

@@ -0,0 +1,3 @@
+import type { DiagnosticCode, DiagnosticPhase } from "../domain/diagnostic.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function failureWithCode<T>(code: DiagnosticCode, phase: DiagnosticPhase): OperationResult<T>;

package/dist/types/validation/utf8-validation.d.ts

@@ -0,0 +1,5 @@
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function hasWellFormedUnicode(value: string): boolean;
+export declare function utf8ByteLength(value: string): number | undefined;
+export declare function encodeUtf8(value: unknown, maxBytes: number): OperationResult<Uint8Array>;
+export declare function decodeUtf8(value: Uint8Array): OperationResult<string>;

package/dist/types/validation/version-validation.d.ts

@@ -0,0 +1,9 @@
+import type { ProfileId } from "../domain/identifiers.js";
+import type { ProfileVersion } from "../domain/version.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function validateProfileVersion(value: unknown): OperationResult<ProfileVersion>;
+export declare function validateProtocolVersion(value: unknown): OperationResult<1>;
+export declare function validateProfileReference(id: unknown, version: unknown): OperationResult<{
+    readonly id: ProfileId;
+    readonly version: ProfileVersion;
+}>;

package/dist/types/vectors.d.ts

@@ -0,0 +1,2 @@
+export { VECTOR_SET } from "./contracts/vector-assets.js";
+export type { VectorCategory } from "./contracts/vector-assets.js";

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@noeos/verification-engine",
+  "version": "0.0.0",
+  "private": false,
+  "description": "Deterministic, offline-first verification engine for Noeos protocols.",
+  "license": "Apache-2.0",
+  "author": "Noeos contributors",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.14.0 <23 || >=24.0.0 <25"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/types/schemas.d.ts",
+      "import": "./dist/esm/schemas.js",
+      "require": "./dist/cjs/schemas.js"
+    },
+    "./profiles": {
+      "types": "./dist/types/profiles.d.ts",
+      "import": "./dist/esm/profiles.js",
+      "require": "./dist/cjs/profiles.js"
+    },
+    "./vectors": {
+      "types": "./dist/types/vectors.d.ts",
+      "import": "./dist/esm/vectors.js",
+      "require": "./dist/cjs/vectors.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "schemas/**/*.json",
+    "vectors/**/*.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noeos/verification-engine.git",
+    "directory": "packages/engine"
+  },
+  "bugs": {
+    "url": "https://github.com/noeos/verification-engine/issues"
+  },
+  "homepage": "https://github.com/noeos/verification-engine#readme",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/schemas/chain-summary.v1.schema.json

@@ -0,0 +1,156 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:noeos:verification-engine:chain-summary:1",
+  "title": "Noeos Verification Engine Chain Summary Evidence v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "$schema",
+    "protocolVersion",
+    "contextId",
+    "sequenceId",
+    "profile",
+    "algorithm",
+    "count",
+    "boundaries",
+    "status",
+    "diagnostics"
+  ],
+  "properties": {
+    "$schema": { "const": "urn:noeos:verification-engine:chain-summary:1" },
+    "protocolVersion": { "const": 1 },
+    "contextId": { "$ref": "#/$defs/identifier" },
+    "sequenceId": { "$ref": "#/$defs/identifier" },
+    "profile": { "$ref": "#/$defs/profile" },
+    "algorithm": { "$ref": "#/$defs/algorithm" },
+    "count": { "$ref": "#/$defs/safeInteger" },
+    "firstPosition": { "$ref": "#/$defs/safeInteger" },
+    "lastPosition": { "$ref": "#/$defs/safeInteger" },
+    "firstLinkDigest": { "$ref": "#/$defs/digest" },
+    "finalLinkDigest": { "$ref": "#/$defs/digest" },
+    "boundaries": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["start", "end"],
+      "properties": {
+        "start": { "enum": ["verified", "unverified", "not-applicable"] },
+        "end": { "enum": ["verified", "unverified", "not-applicable"] }
+      }
+    },
+    "status": { "enum": ["valid", "invalid", "indeterminate", "aborted"] },
+    "diagnostics": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["errors", "warnings", "info", "truncated"],
+      "properties": {
+        "errors": { "$ref": "#/$defs/safeInteger" },
+        "warnings": { "$ref": "#/$defs/safeInteger" },
+        "info": { "$ref": "#/$defs/safeInteger" },
+        "truncated": { "type": "boolean" }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": { "type": "object", "properties": { "count": { "const": 0 } } },
+      "then": {
+        "not": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": { "firstPosition": true },
+              "required": ["firstPosition"]
+            },
+            {
+              "type": "object",
+              "properties": { "lastPosition": true },
+              "required": ["lastPosition"]
+            },
+            {
+              "type": "object",
+              "properties": { "firstLinkDigest": true },
+              "required": ["firstLinkDigest"]
+            },
+            {
+              "type": "object",
+              "properties": { "finalLinkDigest": true },
+              "required": ["finalLinkDigest"]
+            }
+          ]
+        }
+      },
+      "else": {
+        "type": "object",
+        "properties": {
+          "firstPosition": true,
+          "lastPosition": true,
+          "firstLinkDigest": true,
+          "finalLinkDigest": true
+        },
+        "required": ["firstPosition", "lastPosition", "firstLinkDigest", "finalLinkDigest"]
+      }
+    },
+    { "$ref": "#/$defs/digestLengths" }
+  ],
+  "$defs": {
+    "identifier": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$",
+      "maxLength": 128
+    },
+    "profile": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "version"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$",
+          "maxLength": 128
+        },
+        "version": {
+          "type": "string",
+          "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$",
+          "maxLength": 256
+        }
+      }
+    },
+    "algorithm": { "enum": ["sha-256", "sha-384", "sha-512"] },
+    "safeInteger": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+    "digest": { "type": "string", "pattern": "^[0-9a-f]+$", "maxLength": 128 },
+    "digestLengths": {
+      "allOf": [
+        {
+          "if": { "type": "object", "properties": { "algorithm": { "const": "sha-256" } } },
+          "then": {
+            "type": "object",
+            "properties": {
+              "firstLinkDigest": { "type": "string", "minLength": 64, "maxLength": 64 },
+              "finalLinkDigest": { "type": "string", "minLength": 64, "maxLength": 64 }
+            }
+          }
+        },
+        {
+          "if": { "type": "object", "properties": { "algorithm": { "const": "sha-384" } } },
+          "then": {
+            "type": "object",
+            "properties": {
+              "firstLinkDigest": { "type": "string", "minLength": 96, "maxLength": 96 },
+              "finalLinkDigest": { "type": "string", "minLength": 96, "maxLength": 96 }
+            }
+          }
+        },
+        {
+          "if": { "type": "object", "properties": { "algorithm": { "const": "sha-512" } } },
+          "then": {
+            "type": "object",
+            "properties": {
+              "firstLinkDigest": { "type": "string", "minLength": 128, "maxLength": 128 },
+              "finalLinkDigest": { "type": "string", "minLength": 128, "maxLength": 128 }
+            }
+          }
+        }
+      ]
+    }
+  }
+}

package/schemas/diagnostic.v1.schema.json

@@ -0,0 +1,107 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:noeos:verification-engine:diagnostic:1",
+  "title": "Noeos Verification Engine Diagnostic v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["$schema", "code", "severity", "phase", "messageKey"],
+  "properties": {
+    "$schema": { "const": "urn:noeos:verification-engine:diagnostic:1" },
+    "code": {
+      "enum": [
+        "INPUT_REQUIRED",
+        "INPUT_TYPE_INVALID",
+        "INPUT_LIMIT_EXCEEDED",
+        "IDENTIFIER_INVALID",
+        "VERSION_INVALID",
+        "JSON_SYNTAX_INVALID",
+        "JSON_DUPLICATE_KEY",
+        "JSON_VALUE_UNSUPPORTED",
+        "JSON_NUMBER_UNSAFE",
+        "UTF8_INVALID",
+        "NDJSON_LINE_EMPTY",
+        "NDJSON_LINE_TOO_LARGE",
+        "PROFILE_UNKNOWN",
+        "PROFILE_VERSION_UNSUPPORTED",
+        "PROFILE_VERSION_CONFLICT",
+        "PROFILE_INPUT_KIND_MISMATCH",
+        "NORMALIZATION_FAILED",
+        "ALGORITHM_UNKNOWN",
+        "ALGORITHM_FORBIDDEN",
+        "ALGORITHM_VERIFY_ONLY",
+        "DIGEST_ENCODING_INVALID",
+        "DIGEST_LENGTH_INVALID",
+        "FRAME_MAGIC_INVALID",
+        "FRAME_VERSION_UNSUPPORTED",
+        "FRAME_KIND_UNKNOWN",
+        "FRAME_FIELD_UNKNOWN",
+        "FRAME_FIELD_MISSING",
+        "FRAME_FIELD_DUPLICATE",
+        "FRAME_FIELD_ORDER_INVALID",
+        "FRAME_FIELD_TYPE_INVALID",
+        "FRAME_LENGTH_INVALID",
+        "FRAME_TRAILING_DATA",
+        "EVIDENCE_SCHEMA_UNKNOWN",
+        "EVIDENCE_INVALID",
+        "CONTENT_DIGEST_MISMATCH",
+        "RECORD_DIGEST_MISMATCH",
+        "RECORD_ID_DUPLICATE",
+        "CONTENT_DUPLICATE",
+        "LINK_DIGEST_DUPLICATE",
+        "POSITION_MISMATCH",
+        "PREVIOUS_LINK_MISMATCH",
+        "LINK_DIGEST_MISMATCH",
+        "CHAIN_CONFIGURATION_MISMATCH",
+        "CHAIN_FORK",
+        "EXPECTED_COUNT_MISMATCH",
+        "FINAL_LINK_MISMATCH",
+        "BOUNDARY_UNVERIFIED",
+        "EMPTY_CHAIN_FORBIDDEN",
+        "RULE_FAILED",
+        "RULE_EXECUTION_FAILED",
+        "RULE_VERSION_CONFLICT",
+        "DIAGNOSTIC_LIMIT_REACHED",
+        "INPUT_STREAM_FAILED",
+        "OUTPUT_SINK_FAILED",
+        "OPERATION_ABORTED",
+        "RESOURCE_BUDGET_EXCEEDED",
+        "CONCURRENT_USE_FORBIDDEN",
+        "BUILDER_FINALIZED",
+        "BUILDER_FAILED",
+        "OBSERVER_FAILED",
+        "IO_READ_FAILED",
+        "IO_WRITE_FAILED",
+        "OUTPUT_EXISTS",
+        "INTERNAL_INVARIANT_BROKEN"
+      ]
+    },
+    "severity": { "enum": ["error", "warning", "info"] },
+    "phase": { "enum": ["input", "normalization", "record", "link", "chain", "output"] },
+    "messageKey": { "type": "string", "pattern": "^[a-z][a-z0-9.-]{0,127}$", "maxLength": 128 },
+    "path": {
+      "type": "string",
+      "maxLength": 512,
+      "pattern": "^(?:|/(?:[A-Za-z0-9._~-]|~[01])+(?:/(?:[A-Za-z0-9._~-]|~[01])+)*|[a-z][a-z0-9.-]{0,127})$"
+    },
+    "recordId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$",
+      "maxLength": 128
+    },
+    "position": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+    "details": {
+      "type": "object",
+      "maxProperties": 32,
+      "propertyNames": { "type": "string", "pattern": "^[a-z][a-z0-9.-]{0,63}$" },
+      "additionalProperties": {
+        "anyOf": [
+          { "type": "string", "maxLength": 256 },
+          { "type": "number" },
+          { "type": "boolean" },
+          { "type": "null" }
+        ]
+      }
+    },
+    "causeCode": { "type": "string", "pattern": "^[A-Z][A-Z0-9_]{1,127}$", "maxLength": 128 }
+  }
+}

package/schemas/link-evidence.v1.schema.json

@@ -0,0 +1,165 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:noeos:verification-engine:link-evidence:1",
+  "title": "Noeos Verification Engine Link Evidence v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "$schema",
+    "protocolVersion",
+    "contextId",
+    "sequenceId",
+    "position",
+    "recordId",
+    "profile",
+    "algorithm",
+    "normalizedByteLength",
+    "contentDigest",
+    "recordDigest",
+    "previous",
+    "linkDigest"
+  ],
+  "properties": {
+    "$schema": { "const": "urn:noeos:verification-engine:link-evidence:1" },
+    "protocolVersion": { "const": 1 },
+    "contextId": { "$ref": "#/$defs/identifier" },
+    "sequenceId": { "$ref": "#/$defs/identifier" },
+    "position": { "$ref": "#/$defs/safeInteger" },
+    "recordId": { "$ref": "#/$defs/identifier" },
+    "profile": { "$ref": "#/$defs/profile" },
+    "algorithm": { "$ref": "#/$defs/algorithm" },
+    "normalizedByteLength": { "$ref": "#/$defs/safeInteger" },
+    "contentDigest": { "$ref": "#/$defs/digest" },
+    "recordDigest": { "$ref": "#/$defs/digest" },
+    "previous": { "$ref": "#/$defs/previous" },
+    "linkDigest": { "$ref": "#/$defs/digest" }
+  },
+  "allOf": [
+    {
+      "if": { "type": "object", "properties": { "position": { "const": 0 } } },
+      "then": { "type": "object", "properties": { "previous": { "const": { "kind": "none" } } } },
+      "else": {
+        "type": "object",
+        "properties": { "previous": { "$ref": "#/$defs/previousDigest" } }
+      }
+    },
+    { "$ref": "#/$defs/digestLengths" }
+  ],
+  "$defs": {
+    "identifier": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$",
+      "maxLength": 128
+    },
+    "profile": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "version"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$",
+          "maxLength": 128
+        },
+        "version": {
+          "type": "string",
+          "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$",
+          "maxLength": 256
+        }
+      }
+    },
+    "algorithm": { "enum": ["sha-256", "sha-384", "sha-512"] },
+    "safeInteger": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+    "digest": { "type": "string", "pattern": "^[0-9a-f]+$", "maxLength": 128 },
+    "previous": {
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["kind"],
+          "properties": { "kind": { "const": "none" } }
+        },
+        { "$ref": "#/$defs/previousDigest" }
+      ]
+    },
+    "previousDigest": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["kind", "value"],
+      "properties": { "kind": { "const": "digest" }, "value": { "$ref": "#/$defs/digest" } }
+    },
+    "digestLengths": {
+      "allOf": [
+        {
+          "if": { "type": "object", "properties": { "algorithm": { "const": "sha-256" } } },
+          "then": {
+            "type": "object",
+            "properties": {
+              "contentDigest": { "type": "string", "minLength": 64, "maxLength": 64 },
+              "recordDigest": { "type": "string", "minLength": 64, "maxLength": 64 },
+              "linkDigest": { "type": "string", "minLength": 64, "maxLength": 64 },
+              "previous": {
+                "oneOf": [
+                  { "const": { "kind": "none" } },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "kind": { "const": "digest" },
+                      "value": { "type": "string", "minLength": 64, "maxLength": 64 }
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          "if": { "type": "object", "properties": { "algorithm": { "const": "sha-384" } } },
+          "then": {
+            "type": "object",
+            "properties": {
+              "contentDigest": { "type": "string", "minLength": 96, "maxLength": 96 },
+              "recordDigest": { "type": "string", "minLength": 96, "maxLength": 96 },
+              "linkDigest": { "type": "string", "minLength": 96, "maxLength": 96 },
+              "previous": {
+                "oneOf": [
+                  { "const": { "kind": "none" } },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "kind": { "const": "digest" },
+                      "value": { "type": "string", "minLength": 96, "maxLength": 96 }
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          "if": { "type": "object", "properties": { "algorithm": { "const": "sha-512" } } },
+          "then": {
+            "type": "object",
+            "properties": {
+              "contentDigest": { "type": "string", "minLength": 128, "maxLength": 128 },
+              "recordDigest": { "type": "string", "minLength": 128, "maxLength": 128 },
+              "linkDigest": { "type": "string", "minLength": 128, "maxLength": 128 },
+              "previous": {
+                "oneOf": [
+                  { "const": { "kind": "none" } },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "kind": { "const": "digest" },
+                      "value": { "type": "string", "minLength": 128, "maxLength": 128 }
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+}