@lionweb/validation 0.6.13-beta.7 → 0.7.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lionweb/validation",
-  "version": "0.6.13-beta.7",
+  "version": "0.7.0-alpha.10",
   "license": "Apache 2.0",
   "description": "LionWeb Serialization validation",
   "author": "jos.warmer@openmodeling.nl",
@@ -14,14 +14,15 @@
     "testing"
   ],
   "scripts": {
-    "clean": "rm -rf dist/ lionweb-validation-*.tgz",
+    "clean": "npx rimraf dist node_modules -g lionweb-validation-*.tgz",
     "build": "tsc && npm run copyM3 && npm run copyBuiltins",
     "copyM3": "node -e \"const fs = require('fs'); fs.copyFileSync('./src/languages/LionCore-M3.json', './dist/languages/LionCore-M3.json');\"",
     "copyBuiltins": "node -e \"const fs = require('fs'); fs.copyFileSync('./src/languages/LionCore-builtins.json', './dist/languages/LionCore-builtins.json');\"",
     "lint": "eslint src",
     "test-here": "cd ../test && find dist/validation -type d | sed '1!G;h;$!d' | xargs npx mocha",
-    "release": "npm publish",
-    "release-beta": "npm publish --tag beta",
+    "release-alpha": "npm publish --registry https://registry.npmjs.org --tag alpha",
+    "release-beta": "npm publish --registry https://registry.npmjs.org --tag beta",
+    "release": "npm publish --registry https://registry.npmjs.org",
     "testValid": "node dist/runners/RunCheckFolder.js ../test/testset/valid",
     "testInvalid": "node dist/runners/RunCheckFolder.js ../test/testset/invalid",
     "testInvalidWithLanguage": "node dist/runners/RunCheckFolderWithLanguage.js ../test/testset/withLanguage/invalid/ ../test/testset/withLanguage/myLang.language.json",
@@ -29,5 +30,10 @@
     "publish-local": "npm publish --registry http://localhost:4873",
     "unpublish-local": "npm unpublish --force --registry http://localhost:4873",
     "republish-local": "yarn unpublish-local && yarn publish-local"
+  },
+  "dependencies": {
+    "@lionweb/json": "0.7.0-alpha.10",
+    "@lionweb/ts-utils": "0.7.0-alpha.10",
+    "@lionweb/json-utils": "0.7.0-alpha.10"
   }
 }

package/src/index.ts

@@ -1,7 +1,4 @@
 export * from "./issues/index.js"
-export * from "./json/index.js"
 export * from "./validators/index.js"
-export * from "./diff/index.js"
 export * from "./runners/index.js"
 export * from "./languages/index.js"
-export * from "./util/graphs.js"

package/src/issues/LanguageIssues.ts

@@ -1,5 +1,5 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
-import { JsonContext } from "../json/JsonContext.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { JsonContext } from "@lionweb/json-utils"
 import { ValidationIssue } from "./ValidationIssue.js"
 
 export class Language_PropertyValue_Issue extends ValidationIssue {
@@ -8,13 +8,13 @@ export class Language_PropertyValue_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public property: string,
-        public value: (string | null),
-        public expectedType: string,
+        public value: string | null,
+        public expectedType: string
     ) {
         super(context)
     }
 
-    msg = (): string => `Property  "${this.property}" with value "${this.value}" is not of type "${this.expectedType}"`
+    msg = (): string => `Property "${this.property}" with value "${this.value}" is not of type "${this.expectedType}"`
 }
 
 // Incorrect Meta Pointers
@@ -24,7 +24,7 @@ export abstract class Language_IncorrectMetaPointerType_Issue extends Validation
     constructor(
         context: JsonContext,
         public metaPointer: LionWebJsonMetaPointer,
-        public incorrectType: string,
+        public incorrectType: string
     ) {
         super(context)
     }
@@ -43,7 +43,7 @@ export abstract class Language_FeatureMetaPointerNotInClassifier_Issue extends V
     constructor(
         context: JsonContext,
         public featureMetaPointer: LionWebJsonMetaPointer,
-        public classifierPointer: LionWebJsonNode,
+        public classifierPointer: LionWebJsonNode
     ) {
         super(context)
     }
@@ -82,7 +82,7 @@ export abstract class Language_UnknownMetaPointer_Issue extends ValidationIssue
 
     constructor(
         context: JsonContext,
-        public metaPointer: LionWebJsonMetaPointer,
+        public metaPointer: LionWebJsonMetaPointer
     ) {
         super(context)
     }
@@ -112,7 +112,7 @@ export class NumberOfLanguagesUsed_Issue extends ValidationIssue {
     readonly issueType = "NumberOfLanguagesUsed"
     constructor(
         context: JsonContext,
-        public nrOfLanguages: number,
+        public nrOfLanguages: number
     ) {
         super(context)
     }
@@ -120,9 +120,7 @@ export class NumberOfLanguagesUsed_Issue extends ValidationIssue {
 }
 export class MissingM3Language_Issue extends ValidationIssue {
     readonly issueType = "MissingM3Language"
-    constructor(
-        context: JsonContext
-    ) {
+    constructor(context: JsonContext) {
         super(context)
     }
     msg = () => `Missing used language LionCore-M3`
@@ -131,7 +129,7 @@ export class NotLionCoreLanguageKey_Issue extends ValidationIssue {
     readonly issueType = "NotLionCoreLanguageKey"
     constructor(
         context: JsonContext,
-        public incorrectKey: string,
+        public incorrectKey: string
     ) {
         super(context)
     }
@@ -141,7 +139,7 @@ export class IncorrectLionCoreVersion_Issue extends ValidationIssue {
     readonly issueType = "IncorrectLionCoreVersion"
     constructor(
         context: JsonContext,
-        public incorrectVersion: string,
+        public incorrectVersion: string
     ) {
         super(context)
     }

package/src/issues/ReferenceIssues.ts

@@ -1,5 +1,5 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
-import { JsonContext } from "../json/JsonContext.js"
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { JsonContext } from "@lionweb/json-utils"
 import { ValidationIssue } from "./ValidationIssue.js"
 
 export class Reference_DuplicateNodeId_Issue extends ValidationIssue {
@@ -7,7 +7,7 @@ export class Reference_DuplicateNodeId_Issue extends ValidationIssue {
 
     constructor(
         context: JsonContext,
-        public nodeId: string,
+        public nodeId: LionWebId
     ) {
         super(context)
     }
@@ -21,7 +21,7 @@ export class Reference_ChildMissingInParent_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public child: LionWebJsonNode,
-        public parent: LionWebJsonNode,
+        public parent: LionWebJsonNode
     ) {
         super(context)
     }
@@ -35,7 +35,7 @@ export class Reference_ParentMissingInChild_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public parent: LionWebJsonNode,
-        public child: LionWebJsonNode,
+        public child: LionWebJsonNode
     ) {
         super(context)
     }
@@ -49,7 +49,7 @@ export class Reference_CirculairParent_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
         public node: LionWebJsonNode | undefined,
-        public parentPath: string[],
+        public parentPath: string[]
     ) {
         super(context)
     }
@@ -62,7 +62,7 @@ export class Reference_LanguageUnknown_Issue extends ValidationIssue {
 
     constructor(
         context: JsonContext,
-        public languageRef: LionWebJsonMetaPointer,
+        public languageRef: LionWebJsonMetaPointer
     ) {
         super(context)
     }
@@ -75,9 +75,9 @@ export class Duplicates_Issue extends ValidationIssue {
 
     constructor(
         context: JsonContext,
-        public nodeid: string,
+        public nodeId: LionWebId
     ) {
         super(context)
     }
-    msg = () => `Duplicate value "${this.nodeid}"`
+    msg = () => `Duplicate value "${this.nodeId}"`
 }

package/src/issues/SyntaxIssues.ts

@@ -1,10 +1,10 @@
-import { JsonContext } from "../json/JsonContext.js"
+import { JsonContext } from "@lionweb/json-utils"
 import { ValidationIssue } from "./ValidationIssue.js"
 
 export abstract class Syntax_PropertyIssue extends ValidationIssue {
     constructor(
         public context: JsonContext,
-        protected property: string,
+        protected property: string
     ) {
         super(context)
     }
@@ -32,7 +32,7 @@ export class Syntax_PropertyTypeIssue extends Syntax_PropertyIssue {
         context: JsonContext,
         property: string,
         protected expectedType: string,
-        protected actualType: string,
+        protected actualType: string
     ) {
         super(context, property)
     }
@@ -46,7 +46,7 @@ export class Syntax_ArrayContainsNull_Issue extends Syntax_PropertyIssue {
     constructor(
         context: JsonContext,
         property: string,
-        public index: number,
+        public index: number
     ) {
         super(context, property)
     }
@@ -57,7 +57,7 @@ export class Syntax_ArrayContainsNull_Issue extends Syntax_PropertyIssue {
 export abstract class Syntax_IncorrectFormat_Issue extends ValidationIssue {
     constructor(
         context: JsonContext,
-        public value: string,
+        public value: string
     ) {
         super(context)
     }

package/src/issues/ValidationIssue.ts

@@ -1,26 +1,29 @@
-import { JsonContext } from "../json/JsonContext.js"
+import { JsonContext } from "@lionweb/json-utils"
 
 export abstract class ValidationIssue {
     abstract readonly issueType: string
-    context: JsonContext
+    context: JsonContext | null
 
-    constructor(context: JsonContext) {
+    constructor(context: JsonContext | null) {
         this.context = context
     }
 
     protected abstract msg(): string
 
     public errorMsg(): string {
-        return `${this.issueType}: ${this.msg()} at ${this.context.toString()} `
+        return `${this.issueType}: ${this.msg()} at ${this.context?.toString()} `
     }
 }
 
 export class GenericIssue extends ValidationIssue {
     readonly issueType = "GenericIssue"
-    
-    constructor(context: JsonContext, public text: string) {
+
+    constructor(
+        context: JsonContext | null,
+        public text: string
+    ) {
         super(context)
     }
-    
+
     protected msg = () => this.text
 }

package/src/issues/index.ts

@@ -1,4 +1,3 @@
-export * from "../json/JsonContext.js"
 export * from "./ValidationIssue.js"
 export * from "./SyntaxIssues.js"
 export * from "./ReferenceIssues.js"

package/src/languages/CompositeLionWebLanguageWrapper.ts

@@ -1,4 +1,4 @@
-import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
 import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
 import { MetaPointerMap } from "./MetaPointerMap.js"
 

package/src/languages/LanguageRegistry.ts

@@ -1,4 +1,4 @@
-import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
 import { CompositeLionWebLanguageWrapper } from "./CompositeLionWebLanguageWrapper.js"
 import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
 

package/src/languages/LanguageUtils.ts

@@ -1,11 +1,11 @@
-import { isEqualMetaPointer, LionWebJsonNode, LionWebJsonChunk } from "../json/LionWebJson.js"
-import { LION_CORE_M3_KEY, MetaPointers } from "../json/M3definitions.js"
+import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
+import { LION_CORE_M3_KEY, MetaPointers } from "@lionweb/json-utils"
 
-import { createRequire } from 'module';
+import { createRequire } from "module"
 
-const require = createRequire(import.meta.url);
-const LionCore_M3 = require('./LionCore-M3.json');
-const LionCore_builtins = require('./LionCore-builtins.json');
+const require = createRequire(import.meta.url)
+const LionCore_M3 = require("./LionCore-M3.json")
+const LionCore_builtins = require("./LionCore-builtins.json")
 
 export const LionCore_M3_Json = LionCore_M3 as LionWebJsonChunk
 export const LionCore_builtins_Json = LionCore_builtins as LionWebJsonChunk

package/src/languages/LionWebLanguageWrapper.ts

@@ -1,10 +1,6 @@
-import {
-    LionWebJsonChunkWrapper,
-    MetaPointers,
-    NodeUtils
-} from "../json/index.js"
-import { LionWebJsonChunk, LionWebJsonNode } from "../json/LionWebJson.js"
-import { visitAndMap } from "../util/graphs.js"
+import { LionWebJsonChunk, LionWebJsonNode, LionWebKey } from "@lionweb/json"
+import { LionWebJsonChunkWrapper, MetaPointers, NodeUtils } from "@lionweb/json-utils"
+import { visitAndMap } from "@lionweb/ts-utils"
 import { isAnnotation, isConcept, isContainment, isInterface, isProperty, isReference } from "./LanguageUtils.js"
 
 interface LionWebLanguageWrapperInterface {
@@ -24,8 +20,8 @@ interface LionWebLanguageWrapperInterface {
 export class LionWebLanguageWrapper extends LionWebJsonChunkWrapper implements LionWebLanguageWrapperInterface {
     name: string
     version: string
-    key: string
-    
+    key: LionWebKey
+
     constructor(chunk: LionWebJsonChunk) {
         super(chunk)
         const languageNode: LionWebJsonNode = this.findNodesOfClassifier(MetaPointers.Language)[0]

package/src/languages/MetaPointerMap.ts

@@ -1,12 +1,13 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode, MetaPointers, NodeUtils } from "../json/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode, LionWebKey } from "@lionweb/json"
+import { MetaPointers, NodeUtils } from "@lionweb/json-utils"
 
 export class MetaPointerMap {
     /**
      * Map from languageKey => languageVersion => key => LionWebJsonNode
      */
     map: Map<string, Map<string, Map<string, LionWebJsonNode>>> = new Map<string, Map<string, Map<string, LionWebJsonNode>>>()
-    
-    add(languageKey: string, languageVersion: string, node: LionWebJsonNode): void {
+
+    add(languageKey: LionWebKey, languageVersion: string, node: LionWebJsonNode): void {
         const keyProperty = NodeUtils.findProperty(node, MetaPointers.IKeyedKey)
         if (keyProperty === undefined) {
             console.log("MetaPointerMap.add: trying to add node without key property.")
@@ -17,9 +18,9 @@ export class MetaPointerMap {
             console.log("MetaPointerMap.add: trying to add node without key property being empty or null.")
             return
         }
-        this.set({language: languageKey, version: languageVersion, key: key}, node)
+        this.set({ language: languageKey, version: languageVersion, key: key }, node)
     }
-    
+
     set(mp: LionWebJsonMetaPointer, node: LionWebJsonNode): void {
         let language = this.map.get(mp.language)
         if (language === undefined) {
@@ -33,7 +34,7 @@ export class MetaPointerMap {
         }
         version.set(mp.key, node)
     }
-    
+
     get(mp: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
         return this.map.get(mp.language)?.get(mp.version)?.get(mp.key)
     }

package/src/runners/FileUtils.ts

@@ -1,7 +1,7 @@
 import fs from "fs"
 import { LanguageRegistry } from "../languages/index.js"
-import { LionWebValidator } from "../validators/LionWebValidator.js"
 import { ValidationResult } from "../validators/generic/ValidationResult.js"
+import { LionWebValidator } from "../validators/LionWebValidator.js"
 import { getFilesRecursive, printIssues } from "./Utils.js"
 
 export function validateFile(file: string, registry: LanguageRegistry): void {

package/src/runners/RunCheckFolderWithLanguage.ts

@@ -28,7 +28,7 @@ if (languageValidator.validationResult.hasErrors()) {
 for (const modelFile of getFilesRecursive(folder, [])) {
     const jsonString1 = fs.readFileSync(modelFile, "utf-8")
     const jsonModel = JSON.parse(jsonString1)
-    const modelValidator = new LionWebValidator(jsonModel, registry )
+    const modelValidator = new LionWebValidator(jsonModel, registry)
 
     modelValidator.validateAll()
     if (modelValidator.validationResult.hasErrors()) {

package/src/runners/RunLioncoreDiff.ts

@@ -1,6 +1,6 @@
+import { LionWebJsonChunk } from "@lionweb/json"
+import { LionWebJsonDiff } from "@lionweb/json-diff"
 import fs from "fs"
-import { LionWebJsonDiff } from "../diff/index.js"
-import { LionWebJsonChunk } from "../json/LionWebJson.js"
 
 const file1 = process.argv[2]
 const file2 = process.argv[3]

package/src/runners/Utils.ts

@@ -48,7 +48,7 @@ export function printIssues(result: ValidationResult, file?: string): void {
 }
 
 export function issuestoString(vresult: ValidationResult, file?: string): string {
-    let result = ""
-    vresult.issues.forEach(issue => (result += (file == undefined ? "" : `File ${file}: `) + issue.errorMsg() + "\n"))
+    let result = "ISSUES: "
+    vresult.issues.forEach(issue => (result += (file === undefined ? "NOFILE" : `File ${file}: `) + issue.errorMsg() + "\n"))
     return result
 }

package/src/validators/LionWebChunkDefinitions.ts

@@ -1,104 +1,102 @@
-import {
-    validateId,
-    validateKey,
-    validateSerializationFormatVersion,
-    validateVersion
-} from "./ValidationFunctions.js"
-import { MAY_BE_NULL, PropertyDef, PropertyDefinition } from "./generic/ValidationTypes.js"
+import { DefinitionSchema,  MAY_BE_NULL, PropertyDef, PrimitiveDef } from "./generic/index.js"
+import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
 
 /**
  * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
  * It can
- *   - be fed to the SyntaxValidator to validate an object sat runtime.
- *   - used to generate all the types for a LionWebChunk.
+ *   - be used by the SyntaxValidator to validate an object sat runtime.
+ *   - used to generate all the TypeScript types for a LionWebChunk.
  */
-export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
-    [
-        "LionWebMetaPointer",
-        [
-            PropertyDef({ property: "key", expectedType: "string", validate: validateKey }),
-            PropertyDef({ property: "version", expectedType: "string", validate: validateVersion }),
-            PropertyDef({ property: "language", expectedType: "string", validate: validateKey })
+export const LionWebSchema: DefinitionSchema = new DefinitionSchema([
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" })
         ]
-    ],
-    [
-        "ResponseMessage",
-        [
-            PropertyDef({ property: "kind", expectedType: "string" }),
-            PropertyDef({ property: "message", expectedType: "string" }),
-            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true })
+    },
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" }),
         ]
-    ],
-    [
-        "LionWebChunk",
-        [
-            PropertyDef({ property: "serializationFormatVersion", expectedType: "string", validate: validateSerializationFormatVersion }),
-            PropertyDef({ property: "languages", expectedType: "LionWebUsedLanguage", isList: true }),
-            PropertyDef({ property: "nodes", expectedType: "LionWebNode", isList: true })
+    },
+    {
+        name: "ResponseMessage",
+        properties: [
+            PropertyDef({ name: "kind", type: "JSstring" }),
+            PropertyDef({ name: "message", type: "JSstring" }),
+            PropertyDef({ name: "data", type: "JSobject", mayBeNull: true, isOptional: true })
         ]
-    ],
-    [
-        "LionWebUsedLanguage",
-        [
-            PropertyDef({ property: "key", expectedType: "string", validate: validateKey }),
-            PropertyDef({ property: "version", expectedType: "string", validate: validateVersion })
+    },
+    {
+        name: "LionWebJsonChunk",
+        properties: [
+            PropertyDef({ name: "serializationFormatVersion", type: "LionWebSerializationFormatVersion" }),
+            PropertyDef({ name: "languages", type: "LionWebJsonUsedLanguage", isList: true }),
+            PropertyDef({ name: "nodes", type: "LionWebJsonNode", isList: true })
         ]
-    ],
-    [
-        "LionWebNode",
-        [
-            PropertyDef({ property: "id", expectedType: "string", validate: validateId }),
-            PropertyDef({ property: "classifier", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "properties", expectedType: "LionWebProperty", isList: true }),
-            PropertyDef({ property: "containments", expectedType: "LionWebContainment", isList: true }),
-            PropertyDef({ property: "references", expectedType: "LionWebReference", isList: true }),
-            PropertyDef({ property: "annotations", expectedType: "string", isList: true, validate: validateId }),
-            PropertyDef({ property: "parent", expectedType: "string", mayBeNull: MAY_BE_NULL, validate: validateId }),
+    },
+    {
+        name: "LionWebJsonUsedLanguage",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" })
         ]
-    ],
-    [
-        "LionWebProperty",
-        [
-            PropertyDef({ property: "property", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "value", expectedType: "string", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonNode",
+        properties: [
+            PropertyDef({ name: "id", type: "LionWebId" }),
+            PropertyDef({ name: "classifier", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "properties", type: "LionWebJsonProperty", isList: true }),
+            PropertyDef({ name: "containments", type: "LionWebJsonContainment", isList: true }),
+            PropertyDef({ name: "references", type: "LionWebJsonReference", isList: true }),
+            PropertyDef({ name: "annotations", type: "LionWebId", isList: true }),
+            PropertyDef({ name: "parent", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
         ]
-    ],
-    [
-        "LionWebContainment",
-        [
-            PropertyDef({ property: "containment", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "children", expectedType: "string", isList: true, validate: validateId }),
+    },
+    {
+        name: "LionWebJsonProperty",
+        properties: [
+            PropertyDef({ name: "property", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "value", type: "JSstring", mayBeNull: MAY_BE_NULL }),
         ]
-    ],
-    [
-        "LionWebReference",
-        [
-            PropertyDef({ property: "reference", expectedType: "LionWebMetaPointer"}),
-            PropertyDef({ property: "targets", expectedType: "LionWebReferenceTarget", isList: true}),
+    },
+    {
+        name: "LionWebJsonContainment",
+        properties: [
+            PropertyDef({ name: "containment", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "children", type: "LionWebId", isList: true }),
         ]
-    ],
-    [
-        "LionWebReferenceTarget",
-        [
-            PropertyDef({ property: "resolveInfo", expectedType: "string", mayBeNull: MAY_BE_NULL }),
-            PropertyDef({ property: "reference", expectedType: "string", mayBeNull: MAY_BE_NULL, validate: validateId }),
+    },
+    {
+        name: "LionWebJsonReference",
+        properties: [
+            PropertyDef({ name: "reference", type: "LionWebJsonMetaPointer"}),
+            PropertyDef({ name: "targets", type: "LionWebJsonReferenceTarget", isList: true}),
         ]
-    ],
+    },
+    {
+        name: "LionWebJsonReferenceTarget",
+        properties: [
+            PropertyDef({ name: "resolveInfo", type: "JSstring", mayBeNull: MAY_BE_NULL }),
+            PropertyDef({ name: "reference", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
+        ]
+    },
     /**
-     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`.
+     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
+     * and the (optional) validate function.
      */
-    [
-        "string",
-        []
-    ],
-    [
-        "number",
-        []
-    ],
-    [
-        "boolean",
-        []
-    ],
+    PrimitiveDef({ name: "LionWebId", primitiveType: "string", validate: validateId }),
+    PrimitiveDef({ name: "LionWebKey", primitiveType: "string", validate: validateKey }),
+    PrimitiveDef({ name: "LionWebVersion",primitiveType: "string", validate: validateVersion }),
+    PrimitiveDef({ name: "LionWebSerializationFormatVersion",primitiveType: "string", validate: validateSerializationFormatVersion }),
+    PrimitiveDef({ name: "JSstring", primitiveType: "string" }),
+    PrimitiveDef({ name: "JSobject",primitiveType: "object" }),
 ])