@api-client/core 0.19.10 → 0.19.12

package/tests/unit/modeling/amf/shape_generator.spec.ts

@@ -1,26 +1,5 @@
 import { test } from '@japa/runner'
-import {
-  IApiArrayShape,
-  IApiDataExample,
-  IApiFileShape,
-  IApiNodeShape,
-  IApiScalarNode,
-  IApiScalarShape,
-  IApiUnionShape,
-  IApiXmlSerializer,
-  IShapeUnion,
-} from '../../../../src/amf/definitions/Shapes.js'
-import {
-  IAmfAnyTypes,
-  IAmfArrayTypes,
-  IAmfExampleTypes,
-  IAmfFileTypes,
-  IAmfNodeTypes,
-  IAmfPropertyTypes,
-  IAmfScalarTypes,
-  IAmfUnionTypes,
-} from '../../../../src/amf/AmfTypes.js'
-import { AmfNamespace } from '../../../../src/amf/definitions/Namespace.js'
+import { Shapes, AmfTypes, AmfNamespace } from '@api-client/amf-core'
 import { ShapeGenerator } from '../../../../src/modeling/amf/ShapeGenerator.js'
 import {
   type PropertyWebBindings,
@@ -43,10 +22,10 @@ test.group('entity()', (group) => {
   })
 
   test('returns the basic shape', ({ assert }) => {
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.equal(result.id, e1.key, 'has the id')
-    assert.deepEqual(result.types, IAmfNodeTypes, 'has the types')
+    assert.deepEqual(result.types, AmfTypes.IAmfNodeTypes, 'has the types')
     assert.deepEqual(result.values, [], 'has the values')
     assert.deepEqual(result.inherits, [], 'has the inherits')
     assert.deepEqual(result.or, [], 'has the or')
@@ -60,35 +39,35 @@ test.group('entity()', (group) => {
 
   test('returns the display name', ({ assert }) => {
     e1.info.displayName = 'e 1 name'
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.equal(result.displayName, 'e 1 name')
   })
 
   test('returns the description', ({ assert }) => {
     e1.info.description = 'e 1 description'
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.equal(result.description, 'e 1 description')
   })
 
   test('returns the deprecated', ({ assert }) => {
     e1.deprecated = true
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.isTrue(result.deprecated)
   })
 
   test('returns empty properties', ({ assert }) => {
     e1.info.description = 'e 1 description'
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.deepEqual(result.properties, [])
   })
 
   test('returns defined properties', ({ assert }) => {
     e1.addProperty({ key: 'test', info: { name: 'test' } })
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.lengthOf(result.properties, 1)
   })
@@ -96,7 +75,7 @@ test.group('entity()', (group) => {
   test('adds associations to the properties', ({ assert }) => {
     e1.addProperty({ key: 'test', info: { name: 'test' } })
     e1.addAssociation({ info: { name: 'test association' } })
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.lengthOf(result.properties, 2)
     assert.equal(result.properties[1].name, 'test association')
@@ -105,7 +84,7 @@ test.group('entity()', (group) => {
   test('adds parents to the inherits', ({ assert }) => {
     const e2 = m1.addEntity({ key: 'e2', info: { name: 'e2' } })
     e1.addParent(e2.key)
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
 
     assert.lengthOf(result.inherits, 1)
     assert.equal(result.inherits[0].name, 'e2')
@@ -128,7 +107,7 @@ test.group('property() / just data model', (group) => {
   test('returns the basic shape', ({ assert }) => {
     const result = p1.toApiShape()
     assert.equal(result.id, p1.key, 'has the id')
-    assert.deepEqual(result.types, IAmfPropertyTypes, 'has the types')
+    assert.deepEqual(result.types, AmfTypes.IAmfPropertyTypes, 'has the types')
     assert.deepEqual(result.values, [], 'has the values')
     assert.deepEqual(result.inherits, [], 'has the inherits')
     assert.deepEqual(result.or, [], 'has the or')
@@ -149,11 +128,11 @@ test.group('property() / just data model', (group) => {
     p1.info.displayName = 'string dn'
     p1.info.description = 'string desc'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `scalar-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfScalarTypes, 'has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfScalarTypes, 'has the types')
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string, 'has the dataType')
     assert.equal(range.name, 'p1', 'has the name')
     assert.equal(range.displayName, 'string dn', 'has the displayName')
@@ -163,7 +142,7 @@ test.group('property() / just data model', (group) => {
   test('handles examples', ({ assert }) => {
     p1.schema = { examples: ['example1', 'example2'] }
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.lengthOf(range.examples, 2)
     assert.property(range.examples[0], 'structuredValue')
     assert.property(range.examples[1], 'structuredValue')
@@ -172,7 +151,7 @@ test.group('property() / just data model', (group) => {
   test('handles defaultValue', ({ assert }) => {
     p1.schema = { defaultValue: { value: 'defaultValue', type: 'literal' } }
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.property(range, 'defaultValue')
     assert.containsSubset(range.defaultValue, {
       value: 'defaultValue',
@@ -182,7 +161,7 @@ test.group('property() / just data model', (group) => {
   test('handles enum', ({ assert }) => {
     p1.schema = { enum: ['enum1', 'enum2'] }
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.lengthOf(range.values, 2)
     assert.containsSubset(range.values[0], {
       dataType: AmfNamespace.w3.xmlSchema.string,
@@ -197,7 +176,7 @@ test.group('property() / just data model', (group) => {
   test('has the default range for a number', ({ assert }) => {
     p1.type = 'number'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.number, 'has the dataType')
@@ -220,7 +199,7 @@ test.group('property() / just data model', (group) => {
   test('handles multiple properties', ({ assert }) => {
     p1.multiple = true
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.property(range, 'items')
   })
 
@@ -229,7 +208,7 @@ test.group('property() / just data model', (group) => {
     const bindings = p1.getWebBinding() as PropertyWebBindings
     bindings.format = 'base64'
     const result = p1.toApiShape()
-    const range = result.range as IApiFileShape
+    const range = result.range as Shapes.IApiFileShape
     assert.equal(range.format, AmfNamespace.w3.xmlSchema.base64Binary)
   })
 
@@ -238,7 +217,7 @@ test.group('property() / just data model', (group) => {
     const bindings = p1.getWebBinding()
     bindings.format = 'int32'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.integer, 'has the dataType')
@@ -249,7 +228,7 @@ test.group('property() / just data model', (group) => {
     const bindings = p1.getWebBinding()
     bindings.format = 'int64'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.integer, 'has the dataType')
@@ -258,7 +237,7 @@ test.group('property() / just data model', (group) => {
   test('has the default range for a date', ({ assert }) => {
     p1.type = 'date'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.date, 'has the dataType')
@@ -267,7 +246,7 @@ test.group('property() / just data model', (group) => {
   test('has the default range for a datetime', ({ assert }) => {
     p1.type = 'datetime'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.dateTime, 'has the dataType')
@@ -276,7 +255,7 @@ test.group('property() / just data model', (group) => {
   test('has the default range for a time', ({ assert }) => {
     p1.type = 'time'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.dateTimeOnly, 'has the dataType')
@@ -285,7 +264,7 @@ test.group('property() / just data model', (group) => {
   // test('has the default range for a nil', ({ assert }) => {
   //   p1.type = 'nil'
   //   const result = p1.toApiShape()
-  //   const range = result.range as IApiScalarShape
+  //   const range = result.range as Shapes.IApiScalarShape
 
   //   assert.typeOf(range, 'object', 'has the range')
   //   assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.nil, 'has the dataType')
@@ -294,7 +273,7 @@ test.group('property() / just data model', (group) => {
   test('has the default range for a boolean', ({ assert }) => {
     p1.type = 'boolean'
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.boolean, 'has the dataType')
@@ -303,7 +282,7 @@ test.group('property() / just data model', (group) => {
   // test('has the default range for an any', ({ assert }) => {
   //   p1.type = 'any'
   //   const result = p1.toApiShape()
-  //   const range = result.range as IApiScalarShape
+  //   const range = result.range as Shapes.IApiScalarShape
 
   //   assert.typeOf(range, 'object', 'has the range')
   //   assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.AnyShape, 'has the dataType')
@@ -314,11 +293,11 @@ test.group('property() / just data model', (group) => {
     p1.info.displayName = 'string dn'
     p1.info.description = 'string desc'
     const result = p1.toApiShape()
-    const range = result.range as IApiFileShape
+    const range = result.range as Shapes.IApiFileShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `file-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfFileTypes, 'has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfFileTypes, 'has the types')
     assert.equal(range.name, 'p1', 'has the name')
     assert.equal(range.displayName, 'string dn', 'has the displayName')
     assert.equal(range.description, 'string desc', 'has the description')
@@ -329,17 +308,17 @@ test.group('property() / just data model', (group) => {
     p1.info.displayName = 'string dn'
     p1.info.description = 'string desc'
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `array-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfArrayTypes, 'has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfArrayTypes, 'has the types')
 
-    const items = range.items as IApiScalarShape
+    const items = range.items as Shapes.IApiScalarShape
 
     assert.typeOf(items, 'object', 'has the items')
     assert.equal(items.id, `scalar-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(items.types, IAmfScalarTypes, 'has the types')
+    assert.deepEqual(items.types, AmfTypes.IAmfScalarTypes, 'has the types')
 
     assert.equal(items.name, 'p1', 'has the name')
     assert.equal(items.displayName, 'string dn', 'has the displayName')
@@ -352,17 +331,17 @@ test.group('property() / just data model', (group) => {
     p1.info.displayName = 'string dn'
     p1.info.description = 'string desc'
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `array-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfArrayTypes, 'has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfArrayTypes, 'has the types')
 
-    const items = range.items as IApiFileShape
+    const items = range.items as Shapes.IApiFileShape
 
     assert.typeOf(items, 'object', 'has the items')
     assert.equal(items.id, `file-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(items.types, IAmfFileTypes, 'has the types')
+    assert.deepEqual(items.types, AmfTypes.IAmfFileTypes, 'has the types')
 
     assert.equal(items.name, 'p1', 'has the name')
     assert.equal(items.displayName, 'string dn', 'has the displayName')
@@ -392,7 +371,7 @@ test.group('property() / with web bindings', (group) => {
       },
     ]
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
 
     assert.equal(string.name, 'other', 'the range has the changed name')
     assert.equal(result.name, 'other', 'the property has the changed name')
@@ -409,13 +388,13 @@ test.group('property() / with web bindings', (group) => {
   //     },
   //   ]
   //   const result = p1.toApiShape()
-  //   const string = result.range as IApiScalarShape
+  //   const string = result.range as Shapes.IApiScalarShape
   //   assert.equal(string.dataType, AmfNamespace.w3.xmlSchema.date)
   // })
 
   test('sets the xml serialization', ({ assert }) => {
     const p1 = e1.addProperty({ key: 'p1', type: 'string', info: { name: 'p1' } })
-    const value: IApiXmlSerializer = {
+    const value: Shapes.IApiXmlSerializer = {
       id: '',
       types: [],
       customDomainProperties: [],
@@ -430,7 +409,7 @@ test.group('property() / with web bindings', (group) => {
       },
     ]
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.deepEqual(string.xmlSerialization, value)
   })
 
@@ -446,7 +425,7 @@ test.group('property() / with web bindings', (group) => {
       },
     ]
     const result = p1.toApiShape()
-    const file = result.range as IApiFileShape
+    const file = result.range as Shapes.IApiFileShape
     assert.deepEqual(file.fileTypes, value)
   })
 
@@ -456,7 +435,7 @@ test.group('property() / with web bindings', (group) => {
       pattern: 'a-z',
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.pattern, 'a-z')
   })
 
@@ -466,7 +445,7 @@ test.group('property() / with web bindings', (group) => {
       minimum: 1,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.minLength, 1)
   })
 
@@ -476,7 +455,7 @@ test.group('property() / with web bindings', (group) => {
       maximum: 1,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.maxLength, 1)
   })
 
@@ -486,7 +465,7 @@ test.group('property() / with web bindings', (group) => {
       minimum: 1,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.minimum, 1)
   })
 
@@ -496,7 +475,7 @@ test.group('property() / with web bindings', (group) => {
       maximum: 1,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.maximum, 1)
   })
 
@@ -506,7 +485,7 @@ test.group('property() / with web bindings', (group) => {
       multipleOf: 1,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.multipleOf, 1)
   })
 
@@ -516,7 +495,7 @@ test.group('property() / with web bindings', (group) => {
       exclusiveMinimum: true,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.isTrue(string.exclusiveMinimum)
   })
 
@@ -526,7 +505,7 @@ test.group('property() / with web bindings', (group) => {
       exclusiveMaximum: false,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.isFalse(string.exclusiveMaximum)
   })
 
@@ -536,7 +515,7 @@ test.group('property() / with web bindings', (group) => {
       exclusiveMaximum: true,
     }
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.isTrue(string.exclusiveMaximum)
   })
 
@@ -551,7 +530,7 @@ test.group('property() / with web bindings', (group) => {
       },
     ]
     const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
+    const string = result.range as Shapes.IApiScalarShape
     assert.equal(string.format, AmfNamespace.w3.xmlSchema.float)
   })
 })
@@ -573,9 +552,9 @@ test.group('property() / with schema', (group) => {
       defaultValue: { value: '123', type: 'literal' },
     }
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.defaultValue, 'object', 'has the defaultValue')
-    const value = range.defaultValue as IApiScalarNode
+    const value = range.defaultValue as Shapes.IApiScalarNode
     assert.strictEqual(value.value, '123', 'has the value')
     assert.equal(value.dataType, AmfNamespace.w3.xmlSchema.number, 'has the range data type')
   })
@@ -586,9 +565,9 @@ test.group('property() / with schema', (group) => {
       enum: ['123'],
     }
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.values, 'array', 'has the values')
-    const value = range.values[0] as IApiScalarNode
+    const value = range.values[0] as Shapes.IApiScalarNode
     assert.strictEqual(value.value, '123', 'has the value')
     assert.equal(value.dataType, AmfNamespace.w3.xmlSchema.number, 'has the range data type')
   })
@@ -599,16 +578,16 @@ test.group('property() / with schema', (group) => {
       examples: ['123'],
     }
     const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.examples, 'array', 'has the examples')
-    const example = range.examples[0] as IApiDataExample
+    const example = range.examples[0] as Shapes.IApiDataExample
 
     assert.typeOf(example.id, 'string', 'has the example.id')
     assert.isNotEmpty(example.id, 'the example.id is not empty')
-    assert.deepEqual(example.types, IAmfExampleTypes, 'the example.types')
+    assert.deepEqual(example.types, AmfTypes.IAmfExampleTypes, 'the example.types')
     assert.typeOf(example.structuredValue, 'object', 'has the example.structuredValue')
 
-    const value = example.structuredValue as IApiScalarNode
+    const value = example.structuredValue as Shapes.IApiScalarNode
     assert.strictEqual(value.value, '123', 'has the value')
     assert.equal(value.dataType, AmfNamespace.w3.xmlSchema.string, 'has the range data type')
   })
@@ -631,9 +610,9 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'random', type: 'function' } }
     const generator = new ShapeGenerator()
     const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
+    const value = range.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value.value, 'string')
     assert.lengthOf(value.value as string, 8)
   })
@@ -642,9 +621,9 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'uuid-v4', type: 'function' } }
     const generator = new ShapeGenerator()
     const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
+    const value = range.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value.value, 'string')
     assert.lengthOf(value.value as string, 36)
     assert.match(value.value as string, /^[0-9a-f-]+$/)
@@ -655,16 +634,16 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'incremental', type: 'function' } }
     const generator = new ShapeGenerator()
     const result1 = generator.property(p1)
-    const range1 = result1.range as IApiScalarShape
+    const range1 = result1.range as Shapes.IApiScalarShape
     assert.typeOf(range1.defaultValue, 'object')
-    const value1 = range1.defaultValue as IApiScalarNode
+    const value1 = range1.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value1.value, 'string')
     assert.equal(parseInt(value1.value as string), 0)
 
     const result2 = generator.property(p1)
-    const range2 = result2.range as IApiScalarShape
+    const range2 = result2.range as Shapes.IApiScalarShape
     assert.typeOf(range2.defaultValue, 'object')
-    const value2 = range2.defaultValue as IApiScalarNode
+    const value2 = range2.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value2.value, 'string')
     assert.equal(parseInt(value2.value as string), 1)
   })
@@ -674,9 +653,9 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'now', type: 'function' } }
     const generator = new ShapeGenerator()
     const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
+    const value = range.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value.value, 'string')
     assert.match(value.value as string, /^\d{4}-\d{2}-\d{2}$/)
   })
@@ -686,9 +665,9 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'now', type: 'function' } }
     const generator = new ShapeGenerator()
     const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
+    const value = range.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value.value, 'string')
     assert.match(value.value as string, /^\d{2}:\d{2}:\d{2}$/)
   })
@@ -698,9 +677,9 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'now', type: 'function' } }
     const generator = new ShapeGenerator()
     const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
+    const value = range.defaultValue as Shapes.IApiScalarNode
     assert.typeOf(value.value, 'string')
     assert.match(value.value as string, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/)
   })
@@ -709,7 +688,7 @@ test.group('property() / default value functions', (group) => {
     p1.schema = { defaultValue: { value: 'unsupported', type: 'function' } }
     const generator = new ShapeGenerator()
     const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.isUndefined(range.defaultValue)
   })
 })
@@ -730,8 +709,8 @@ test.group('refactorArrayToShape()', (group) => {
   test('returns the array items', ({ assert }) => {
     p1.multiple = true
     const parameter = p1.toApiShape()
-    const range = parameter.range as IApiArrayShape
-    const shape = range.items as IApiScalarShape
+    const range = parameter.range as Shapes.IApiArrayShape
+    const shape = range.items as Shapes.IApiScalarShape
     assert.deepEqual(range.items, shape)
   })
 })
@@ -751,15 +730,15 @@ test.group('refactorShapeToArray()', (group) => {
 
   test('returns the array items', ({ assert }) => {
     const parameter = p1.toApiShape()
-    const range = parameter.range as IApiScalarShape
+    const range = parameter.range as Shapes.IApiScalarShape
     const generator = new ShapeGenerator()
     const result = generator['refactorShapeToArray'](p1.key, range)
 
     assert.typeOf(result, 'object', 'has the range')
     assert.equal(result.id, `array-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(result.types, IAmfArrayTypes, 'has the types')
+    assert.deepEqual(result.types, AmfTypes.IAmfArrayTypes, 'has the types')
 
-    const items = result.items as IApiScalarShape
+    const items = result.items as Shapes.IApiScalarShape
     assert.deepEqual(items, range)
   })
 })
@@ -787,7 +766,7 @@ test.group('associationProperty()', (group) => {
     assert.typeOf(result, 'object')
 
     assert.equal(result.id, a1.key, 'has the id')
-    assert.deepEqual(result.types, IAmfPropertyTypes, 'has the types')
+    assert.deepEqual(result.types, AmfTypes.IAmfPropertyTypes, 'has the types')
     assert.deepEqual(result.values, [], 'has the values')
     assert.deepEqual(result.inherits, [], 'has the inherits')
     assert.deepEqual(result.or, [], 'has the or')
@@ -795,19 +774,19 @@ test.group('associationProperty()', (group) => {
     assert.deepEqual(result.xone, [], 'has the xone')
     assert.equal(result.path, AmfNamespace.aml.vocabularies.data.key + 'a1', 'has the path')
 
-    const range = result.range as IApiNodeShape
+    const range = result.range as Shapes.IApiNodeShape
     assert.typeOf(range, 'object', 'has the range')
-    assert.deepEqual(range.types, IAmfNodeTypes, 'range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfNodeTypes, 'range has the types')
     assert.equal(range.name, 'e2', 'range has the name')
     assert.lengthOf(range.properties, 1, 'range has the properties')
 
     const [prop] = range.properties
     assert.equal(prop.id, p2.key, 'property has the id')
-    assert.deepEqual(prop.types, IAmfPropertyTypes, 'property has the types')
+    assert.deepEqual(prop.types, AmfTypes.IAmfPropertyTypes, 'property has the types')
 
-    const pRange = prop.range as IApiScalarShape
+    const pRange = prop.range as Shapes.IApiScalarShape
     assert.typeOf(pRange, 'object', 'property range is an object')
-    assert.deepEqual(pRange.types, IAmfScalarTypes, 'property range has the types')
+    assert.deepEqual(pRange.types, AmfTypes.IAmfScalarTypes, 'property range has the types')
     assert.equal(pRange.name, 'p2', 'property range has the name')
     assert.equal(pRange.dataType, AmfNamespace.w3.xmlSchema.number, 'property range has the dataType')
   })
@@ -836,9 +815,9 @@ test.group('associationProperty()', (group) => {
   test('returns a link definition when created on the schema', ({ assert }) => {
     a1.schema = { linked: true }
     const result = a1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.equal(range.id, `link-${a1.key}`)
-    assert.deepEqual(range.types, IAmfScalarTypes)
+    assert.deepEqual(range.types, AmfTypes.IAmfScalarTypes)
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string)
   })
 
@@ -846,16 +825,16 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfUnionTypes, 'the range has the types')
     assert.lengthOf(range.anyOf, 2, 'has the anyOf array')
-    const [p1, p2] = range.anyOf as IApiNodeShape[]
+    const [p1, p2] = range.anyOf as Shapes.IApiNodeShape[]
 
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
+    assert.deepEqual(p1.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(p2.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(p1.properties, 1, 'p1 has the properties')
     assert.lengthOf(p2.properties, 0, 'p2 has the properties')
   })
@@ -869,12 +848,12 @@ test.group('associationProperty()', (group) => {
   test('returns an array shape when multiple', ({ assert }) => {
     a1.multiple = true
     const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
-    assert.deepEqual(range.types, IAmfArrayTypes)
+    const range = result.range as Shapes.IApiArrayShape
+    assert.deepEqual(range.types, AmfTypes.IAmfArrayTypes)
 
-    const arrayRange = range.items as IApiNodeShape
+    const arrayRange = range.items as Shapes.IApiNodeShape
     assert.typeOf(arrayRange, 'object', 'has the range')
-    assert.deepEqual(arrayRange.types, IAmfNodeTypes, 'range has the types')
+    assert.deepEqual(arrayRange.types, AmfTypes.IAmfNodeTypes, 'range has the types')
     assert.equal(arrayRange.name, 'e2', 'range has the name')
     assert.lengthOf(arrayRange.properties, 1, 'range has the properties')
   })
@@ -885,16 +864,16 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfUnionTypes, 'the range has the types')
     assert.lengthOf(range.anyOf, 2, 'has the anyOf array')
-    const [p1, p2] = range.anyOf as IApiNodeShape[]
+    const [p1, p2] = range.anyOf as Shapes.IApiNodeShape[]
 
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
+    assert.deepEqual(p1.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(p2.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(p1.properties, 1, 'p1 has the properties')
     assert.lengthOf(p2.properties, 0, 'p2 has the properties')
   })
@@ -905,16 +884,16 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfUnionTypes, 'the range has the types')
     assert.lengthOf(range.and, 2, 'has the anyOf array')
-    const [p1, p2] = range.and as IApiNodeShape[]
+    const [p1, p2] = range.and as Shapes.IApiNodeShape[]
 
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
+    assert.deepEqual(p1.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(p2.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(p1.properties, 1, 'p1 has the properties')
     assert.lengthOf(p2.properties, 0, 'p2 has the properties')
   })
@@ -925,16 +904,16 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfUnionTypes, 'the range has the types')
     assert.lengthOf(range.xone, 2, 'has the oneOf array')
-    const [p1, p2] = range.xone as IApiNodeShape[]
+    const [p1, p2] = range.xone as Shapes.IApiNodeShape[]
 
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
+    assert.deepEqual(p1.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(p2.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(p1.properties, 1, 'p1 has the properties')
     assert.lengthOf(p2.properties, 0, 'p2 has the properties')
   })
@@ -945,16 +924,16 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfUnionTypes, 'the range has the types')
     assert.typeOf(range.not, 'object', 'has the not object')
 
-    const not = range.not as IApiNodeShape
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p2 has the types')
+    const not = range.not as Shapes.IApiNodeShape
+    assert.deepEqual(not.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(not.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(not.properties, 1, 'p1 has the properties')
   })
 
@@ -962,16 +941,16 @@ test.group('associationProperty()', (group) => {
     a1.schema = { unionType: 'not' }
 
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `not-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfAnyTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfAnyTypes, 'the range has the types')
     assert.typeOf(range.not, 'object', 'has the not object')
 
-    const not = range.not as IApiNodeShape
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p2 has the types')
+    const not = range.not as Shapes.IApiNodeShape
+    assert.deepEqual(not.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(not.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(not.properties, 1, 'p1 has the properties')
   })
 
@@ -982,19 +961,19 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
 
     assert.typeOf(range, 'object', 'has the range')
     assert.equal(range.id, `array-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfArrayTypes, 'the range has the types')
+    assert.deepEqual(range.types, AmfTypes.IAmfArrayTypes, 'the range has the types')
 
-    const items = range.items as IApiUnionShape
+    const items = range.items as Shapes.IApiUnionShape
 
     assert.lengthOf(items.anyOf, 2, 'has the anyOf array')
-    const [p1, p2] = items.anyOf as IApiNodeShape[]
+    const [p1, p2] = items.anyOf as Shapes.IApiNodeShape[]
 
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
+    assert.deepEqual(p1.types, AmfTypes.IAmfNodeTypes, 'p1 has the types')
+    assert.deepEqual(p2.types, AmfTypes.IAmfNodeTypes, 'p2 has the types')
     assert.lengthOf(p1.properties, 1, 'p1 has the properties')
     assert.lengthOf(p2.properties, 0, 'p2 has the properties')
   })
@@ -1002,7 +981,7 @@ test.group('associationProperty()', (group) => {
   test('handles linked schema', ({ assert }) => {
     a1.schema = { linked: true }
     const result = a1.toApiShape()
-    const range = result.range as IApiScalarShape
+    const range = result.range as Shapes.IApiScalarShape
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string)
   })
 
@@ -1010,7 +989,7 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
     assert.lengthOf(range.anyOf, 2)
   })
 
@@ -1019,7 +998,7 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
+    const range = result.range as Shapes.IApiUnionShape
     assert.lengthOf(range.and, 2)
   })
 
@@ -1029,8 +1008,8 @@ test.group('associationProperty()', (group) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
-    const items = range.items as IShapeUnion
+    const range = result.range as Shapes.IApiArrayShape
+    const items = range.items as Shapes.IApiUnionShape
     assert.lengthOf(items.and, 2)
   })
 })
@@ -1056,7 +1035,7 @@ test.group('AI Generated tests', (group) => {
     const p3 = e1.addProperty({ key: 'p3', info: { name: 'p3' } })
     const bindings = p3.getWebBinding()
     bindings.hidden = true
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
     assert.lengthOf(result.properties, 2)
     assert.isFalse(result.properties.some((prop) => prop.id === p3.key))
   })
@@ -1068,7 +1047,7 @@ test.group('AI Generated tests', (group) => {
     fd1.info.version = '1.0.0'
     root.registerForeignDomain(fd1)
     const a2 = e1.addAssociation({ targets: [{ key: e3.key, domain: fd1.key }], key: 'a2', info: { name: 'a2' } })
-    const result = e1.toApiShape() as IApiNodeShape
+    const result = e1.toApiShape() as Shapes.IApiNodeShape
     assert.lengthOf(result.properties, 3)
     assert.isTrue(result.properties.some((prop) => prop.id === a2.key))
   })
@@ -1077,7 +1056,7 @@ test.group('AI Generated tests', (group) => {
     p1.multiple = true
     p1.schema = { examples: ['example1', 'example2'] }
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
     assert.lengthOf(range.examples, 1)
     assert.property(range.examples[0], 'structuredValue')
@@ -1087,7 +1066,7 @@ test.group('AI Generated tests', (group) => {
     p1.multiple = true
     p1.schema = { defaultValue: { value: 'defaultValue', type: 'literal' } }
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
     assert.property(range, 'defaultValue')
     assert.containsSubset(range.defaultValue, {
@@ -1099,7 +1078,7 @@ test.group('AI Generated tests', (group) => {
     p1.multiple = true
     p1.schema = { enum: ['enum1', 'enum2'] }
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
     assert.lengthOf(range.values, 2)
     assert.containsSubset(range.values[0], {
@@ -1116,9 +1095,9 @@ test.group('AI Generated tests', (group) => {
     p1.multiple = true
     p1.schema = { minimum: 1, maximum: 10 }
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
-    const items = range.items as IApiScalarShape
+    const items = range.items as Shapes.IApiScalarShape
     assert.equal(items.minLength, 1)
     assert.equal(items.maxLength, 10)
   })
@@ -1134,8 +1113,8 @@ test.group('AI Generated tests', (group) => {
       },
     ]
     const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
-    const items = range.items as IApiScalarShape
+    const range = result.range as Shapes.IApiArrayShape
+    const items = range.items as Shapes.IApiScalarShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
     assert.equal(items.format, AmfNamespace.w3.xmlSchema.integer)
   })
@@ -1144,9 +1123,9 @@ test.group('AI Generated tests', (group) => {
     a1.multiple = true
     a1.schema = { linked: false }
     const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
-    const items = range.items as IApiScalarShape
+    const items = range.items as Shapes.IApiScalarShape
     assert.ok(items)
   })
 
@@ -1161,9 +1140,9 @@ test.group('AI Generated tests', (group) => {
       },
     ]
     const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
+    const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
-    const items = range.items as IApiNodeShape
+    const items = range.items as Shapes.IApiNodeShape
     assert.ok(items.properties)
   })
 })