@api-client/core 0.19.10 → 0.19.12

package/src/modeling/amf/ShapeGenerator.ts

@@ -2,31 +2,9 @@ import { type AssociationBindings, type PropertyWebBindings } from '../Bindings.
 import type { DomainAssociation } from '../DomainAssociation.js'
 import type { DomainProperty } from '../DomainProperty.js'
 import type { DomainEntity } from '../DomainEntity.js'
-import { IAmfExampleTypes, modelTypeToAmfDataType } from '../../amf/AmfTypes.js'
-import { AmfNamespace } from '../../amf/definitions/Namespace.js'
-import {
-  anyShape,
-  arrayShape,
-  fileShape,
-  IApiAnyShape,
-  IApiArrayShape,
-  IApiDataExample,
-  IApiFileShape,
-  IApiNodeShape,
-  IApiPropertyShape,
-  IApiRecursiveShape,
-  IApiScalarShape,
-  IApiShape,
-  IApiUnionShape,
-  IShapeUnion,
-  nodeShape,
-  propertyShape,
-  recursiveShape,
-  scalarShape,
-  unionShape,
-} from '../../amf/definitions/Shapes.js'
-import { AmfDataNode } from '../../amf/models/AmfDataNode.js'
-import { DataValueGenerator } from '../../amf/DataValueGenerator.js'
+import { modelTypeToAmfDataType } from './core_types.js'
+import { AmfNamespace, type Shapes, AmfDataNode, AmfTypes, ShapeHelpers } from '@api-client/amf-core'
+import { DataValueGenerator } from './DataValueGenerator.js'
 import { nanoid } from '../../nanoid.js'
 import { DomainEntityKind, DomainPropertyKind } from '../../models/kinds.js'
 import type { PropertySchema } from '../types.js'
@@ -107,13 +85,13 @@ export class ShapeGenerator {
    * const amfShape = generator.entity(myDomainEntity);
    * ```
    */
-  entity(input: DomainEntity, visited = new Set<string>()): IApiNodeShape | IApiRecursiveShape {
+  entity(input: DomainEntity, visited = new Set<string>()): Shapes.IApiNodeShape | Shapes.IApiRecursiveShape {
     if (visited.has(input.key)) {
       // create a recursive shape.
       return this.createRecursiveShape(input)
     }
     visited.add(input.key)
-    const result = nodeShape(input.key)
+    const result = ShapeHelpers.nodeShape(input.key)
     result.id = input.key
     this.updateBaseProperties(input, result)
     result.properties = []
@@ -158,9 +136,9 @@ export class ShapeGenerator {
    * const amfShape = generator.property(myDomainProperty);
    * ```
    */
-  property(input: DomainProperty): IApiPropertyShape {
+  property(input: DomainProperty): Shapes.IApiPropertyShape {
     const { required, key } = input
-    const result = propertyShape(key)
+    const result = ShapeHelpers.propertyShape(key)
     result.path = `${AmfNamespace.aml.vocabularies.data.key}${input.info.name}`
     if (required) {
       result.minCount = 1
@@ -198,9 +176,9 @@ export class ShapeGenerator {
    * const amfShape = generator.associationProperty(myDomainAssociation);
    * ```
    */
-  associationProperty(input: DomainAssociation, visited: Set<string> = new Set<string>()): IApiPropertyShape {
+  associationProperty(input: DomainAssociation, visited: Set<string> = new Set<string>()): Shapes.IApiPropertyShape {
     const { required, key } = input
-    const result = propertyShape(key)
+    const result = ShapeHelpers.propertyShape(key)
     result.path = `${AmfNamespace.aml.vocabularies.data.key}${input.info.name}`
     if (required) {
       result.minCount = 1
@@ -219,7 +197,7 @@ export class ShapeGenerator {
    *                recursive shape generation and avoids infinite loops. Defaults to a new empty `Set`.
    * @returns The range value for the PropertyShape.
    */
-  associationShape(input: DomainAssociation, visited: Set<string> = new Set<string>()): IShapeUnion | undefined {
+  associationShape(input: DomainAssociation, visited: Set<string> = new Set<string>()): Shapes.IShapeUnion | undefined {
     const schema = input.schema
     if (schema && schema.linked) {
       return this.createLinkedShape(input)
@@ -235,7 +213,7 @@ export class ShapeGenerator {
     if (unionType === UNION_TYPE_NOT) {
       // Need to investigate more about "not" union type.
       // AMF supports it, but I am not sure how to handle it.
-      const wrapper = anyShape(input.key)
+      const wrapper = ShapeHelpers.anyShape(input.key)
       wrapper.id = `not-shape-${input.key}`
       wrapper.not = items
       return wrapper
@@ -250,17 +228,20 @@ export class ShapeGenerator {
    * @param input The data association instance.
    * @returns An AMF API scalar shape with the link to the schema.
    */
-  protected createLinkedShape(input: DomainAssociation): IApiScalarShape {
+  protected createLinkedShape(input: DomainAssociation): Shapes.IApiScalarShape {
     // This is a link to the schema. In an API that would be the id
     // of a resource to request the data from.
-    const range = scalarShape(input.key)
+    const range = ShapeHelpers.scalarShape(input.key)
     range.id = `link-${input.key}`
     range.dataType = modelTypeToAmfDataType(DATA_TYPE_STRING)
     return range
   }
 
-  protected createUnionShape(input: DomainAssociation, items: IShapeUnion[]): IApiUnionShape | IApiArrayShape {
-    const range = unionShape(input.key)
+  protected createUnionShape(
+    input: DomainAssociation,
+    items: Shapes.IShapeUnion[]
+  ): Shapes.IApiUnionShape | Shapes.IApiArrayShape {
+    const range = ShapeHelpers.unionShape(input.key)
     this.updateBaseProperties(input, range)
     range.anyOf = []
     const unionType = (input.schema && input.schema.unionType) || UNION_TYPE_ANY_OF
@@ -291,8 +272,8 @@ export class ShapeGenerator {
   associationUnion(
     input: DomainAssociation,
     visited: Set<string> = new Set<string>()
-  ): IShapeUnion | IShapeUnion[] | undefined {
-    const result: IShapeUnion[] = []
+  ): Shapes.IShapeUnion | Shapes.IShapeUnion[] | undefined {
+    const result: Shapes.IShapeUnion[] = []
     for (const item of input.listTargets()) {
       result.push(this.entity(item, visited))
     }
@@ -312,7 +293,7 @@ export class ShapeGenerator {
    *
    * @param input
    */
-  protected getRange(input: DomainProperty): IApiArrayShape | IApiFileShape | IApiScalarShape {
+  protected getRange(input: DomainProperty): Shapes.IApiArrayShape | Shapes.IApiFileShape | Shapes.IApiScalarShape {
     const bindings = input.readBinding('web') as PropertyWebBindings | undefined
     let schema: PropertySchema | undefined
     if (input.schema) {
@@ -339,7 +320,7 @@ export class ShapeGenerator {
    */
   protected setShapeSchema(
     input: DomainProperty,
-    result: IApiAnyShape,
+    result: Shapes.IApiAnyShape,
     schema: PropertySchema,
     type: string,
     isArray?: boolean
@@ -374,8 +355,8 @@ export class ShapeGenerator {
     input: DomainProperty,
     schema?: PropertySchema,
     bindings?: PropertyWebBindings
-  ): IApiArrayShape {
-    const result = arrayShape(input.key)
+  ): Shapes.IApiArrayShape {
+    const result = ShapeHelpers.arrayShape(input.key)
     const { type } = input
     if (type === DATA_TYPE_BINARY) {
       // we do not pass schema to the range generator as we set schema's properties on the array shape.
@@ -384,7 +365,7 @@ export class ShapeGenerator {
       result.items = this.createScalarShape(input, undefined, bindings)
     }
     if (schema) {
-      const type = (result.items as IApiScalarShape).dataType as string
+      const type = (result.items as Shapes.IApiScalarShape).dataType as string
       this.setShapeSchema(input, result, schema, type, input.multiple)
     }
     return result
@@ -394,8 +375,8 @@ export class ShapeGenerator {
     input: DomainProperty,
     schema?: PropertySchema,
     bindings?: PropertyWebBindings
-  ): IApiScalarShape {
-    const result = scalarShape(input.key)
+  ): Shapes.IApiScalarShape {
+    const result = ShapeHelpers.scalarShape(input.key)
     this.updateBaseProperties(input, result)
     this.setScalarCommonProperties(result, input, bindings)
     if (!result.dataType) {
@@ -407,14 +388,14 @@ export class ShapeGenerator {
     return result
   }
 
-  protected createExamples(examples: string[], type: string): IApiDataExample[] {
-    const result: IApiDataExample[] = []
+  protected createExamples(examples: string[], type: string): Shapes.IApiDataExample[] {
+    const result: Shapes.IApiDataExample[] = []
     for (const current of examples) {
-      const item: IApiDataExample = {
+      const item: Shapes.IApiDataExample = {
         id: nanoid(),
         customDomainProperties: [],
         strict: true,
-        types: IAmfExampleTypes,
+        types: [...AmfTypes.IAmfExampleTypes],
         structuredValue: AmfDataNode.scalar(current, type).toJSON(),
       }
       result.push(item)
@@ -422,12 +403,12 @@ export class ShapeGenerator {
     return result
   }
 
-  protected createArrayExamples(examples: string[], type: string): IApiDataExample[] {
-    const item: IApiDataExample = {
+  protected createArrayExamples(examples: string[], type: string): Shapes.IApiDataExample[] {
+    const item: Shapes.IApiDataExample = {
       id: nanoid(),
       customDomainProperties: [],
       strict: true,
-      types: IAmfExampleTypes,
+      types: [...AmfTypes.IAmfExampleTypes],
     }
     const value = new AmfDataNode('array')
     for (const item of examples) {
@@ -438,8 +419,8 @@ export class ShapeGenerator {
     return [item]
   }
 
-  protected createFileShape(input: DomainProperty, bindings?: PropertyWebBindings): IApiFileShape {
-    const result = fileShape(input.key)
+  protected createFileShape(input: DomainProperty, bindings?: PropertyWebBindings): Shapes.IApiFileShape {
+    const result = ShapeHelpers.fileShape(input.key)
     this.updateBaseProperties(input, result)
     if (bindings) {
       if (Array.isArray(bindings.fileTypes)) {
@@ -454,7 +435,7 @@ export class ShapeGenerator {
   }
 
   protected setScalarCommonProperties(
-    result: IApiFileShape | IApiScalarShape,
+    result: Shapes.IApiFileShape | Shapes.IApiScalarShape,
     input: DomainProperty,
     bindings?: PropertyWebBindings
   ): void {
@@ -521,7 +502,10 @@ export class ShapeGenerator {
     }
   }
 
-  protected updateBaseProperties(input: DomainProperty | DomainAssociation | DomainEntity, target: IApiShape): void {
+  protected updateBaseProperties(
+    input: DomainProperty | DomainAssociation | DomainEntity,
+    target: Shapes.IApiShape
+  ): void {
     target.name = input.info.name
     target.displayName = input.info.displayName
     target.description = input.info.description
@@ -532,8 +516,8 @@ export class ShapeGenerator {
     }
   }
 
-  protected createRecursiveShape(input: DomainEntity): IApiRecursiveShape {
-    return recursiveShape(input.key, input.key)
+  protected createRecursiveShape(input: DomainEntity): Shapes.IApiRecursiveShape {
+    return ShapeHelpers.recursiveShape(input.key, input.key)
   }
 
   /**
@@ -544,8 +528,8 @@ export class ShapeGenerator {
    * @param shape The shape to wrap as an array.
    * @returns Array shape.
    */
-  protected refactorShapeToArray(id: string, shape: IShapeUnion): IApiArrayShape {
-    const result = arrayShape(id)
+  protected refactorShapeToArray(id: string, shape: Shapes.IShapeUnion): Shapes.IApiArrayShape {
+    const result = ShapeHelpers.arrayShape(id)
     result.items = shape
     return result
   }

package/src/modeling/amf/core_types.ts

@@ -0,0 +1,47 @@
+import { PropertyWebBindings } from '../Bindings.js'
+import { DomainPropertyType } from '../DataFormat.js'
+import { AmfNamespace } from '@api-client/amf-core'
+
+/**
+ * Translates the DomainProperty type to an AMF data type.
+ * @param type The property data type
+ * @returns AMF shape dataType
+ */
+export function modelTypeToAmfDataType(type: DomainPropertyType, bindings?: PropertyWebBindings): string {
+  if (type === 'number') {
+    if (bindings?.format === 'int32' || bindings?.format === 'int64') {
+      return AmfNamespace.w3.xmlSchema.integer
+    }
+    return AmfNamespace.w3.xmlSchema.number
+  }
+  if (type === 'boolean') {
+    return AmfNamespace.aml.vocabularies.shapes.boolean
+  }
+  if (type === 'date') {
+    return AmfNamespace.w3.xmlSchema.date
+  }
+  if (type === 'datetime') {
+    return AmfNamespace.w3.xmlSchema.dateTime
+  }
+  if (type === 'time') {
+    return AmfNamespace.aml.vocabularies.shapes.dateTimeOnly
+  }
+  if (type === 'binary' && bindings && bindings.format === 'base64') {
+    return AmfNamespace.w3.xmlSchema.base64Binary
+  }
+  return AmfNamespace.w3.xmlSchema.string
+  // switch (type) {
+  //   // case 'nil':
+  //   //   return AmfNamespace.aml.vocabularies.shapes.nil
+  //   // case 'any':
+  //   //   return AmfNamespace.aml.vocabularies.shapes.AnyShape
+  //   default:
+  //     if (type === 'binary' && bindings && bindings.format === 'base64') {
+  //       return AmfNamespace.w3.xmlSchema.base64Binary
+  //     }
+  //     // if (bindings && bindings.format === 'binary') {
+  //     //   return AmfNamespace.w3.xmlSchema.base64Binary
+  //     // }
+  //     return AmfNamespace.w3.xmlSchema.string
+  // }
+}

package/src/modeling/validation/api_model_rules.ts

@@ -6,7 +6,7 @@ import { DeleteAction } from '../actions/DeleteAction.js'
 import { UpdateAction } from '../actions/UpdateAction.js'
 import { SearchAction } from '../actions/SearchAction.js'
 import type { RolesBasedAccessControl, UsernamePasswordConfiguration } from '../types.js'
-import type { ApiModelValidationItem, ApiModelValidationResult, ApiModelValidationContext } from '../types.js'
+import type { ApiModelValidationItem, ApiModelValidationContext } from '../types.js'
 import { ApiModelKind, ExposedEntityKind } from '../../models/kinds.js'
 import { SemanticType } from '../Semantics.js'
 
@@ -608,33 +608,3 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
 
   return issues
 }
-
-export function validateApiModel(model: ApiModel): ApiModelValidationResult {
-  const issues: ApiModelValidationItem[] = []
-
-  issues.push(...validateApiModelInfo(model))
-  issues.push(...validateApiModelDependency(model))
-  issues.push(...validateApiModelSecurity(model))
-  issues.push(...validateApiModelMetadata(model))
-
-  if (!model.exposes || model.exposes.size === 0) {
-    issues.push({
-      code: createCode('API', 'NO_EXPOSURES'),
-      message: 'Your API currently has no exposed data for external clients to request.',
-      suggestion: 'Expose a data model so apps can communicate with it.',
-      severity: 'warning',
-      context: { apiModelKey: model.key, kind: ApiModelKind, key: model.key, property: 'exposes' },
-    })
-  } else {
-    for (const exposure of model.exposes.values()) {
-      issues.push(...validateExposedEntity(exposure, model))
-    }
-  }
-
-  const hasErrors = issues.some((i) => i.severity === 'error')
-
-  return {
-    isValid: !hasErrors,
-    issues,
-  }
-}

package/src/modeling/validation/association_validation.ts

@@ -2,7 +2,7 @@ import { DomainAssociationKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import type { DomainAssociation } from '../DomainAssociation.js'
 import type { DomainEntity } from '../DomainEntity.js'
-import { type DomainValidation, validatePropertyName } from './rules.js'
+import { type DomainValidationSchema, validatePropertyName } from './rules.js'
 
 /**
  * AssociationValidation is a class that performs validation on associations in a data domain.
@@ -16,8 +16,8 @@ export class AssociationValidation {
    * @param target The target association to validate. Can be a string with
    *               the association key or a DomainAssociation object.
    */
-  validate(target: string | DomainAssociation): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(target: string | DomainAssociation): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let association: DomainAssociation | undefined
     if (typeof target === 'string') {
       association = this.domain.findAssociation(target)
@@ -58,7 +58,7 @@ export class AssociationValidation {
    *   - (recommendation) Column names should be in lower case.
    * @param association The association to validate
    */
-  validateName(association: DomainAssociation): DomainValidation[] {
+  validateName(association: DomainAssociation): DomainValidationSchema[] {
     return validatePropertyName(association)
   }
 
@@ -66,8 +66,8 @@ export class AssociationValidation {
    * Validates the association targets.
    * @param association The association to validate
    */
-  validateTargets(association: DomainAssociation): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validateTargets(association: DomainAssociation): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const label = association.info.getLabel()
     const parentEntity = association.getParentInstance() as DomainEntity
     if (!association.targets.length) {

package/src/modeling/validation/entity_validation.ts

@@ -2,7 +2,7 @@ import { DomainEntityKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import type { DomainEntity } from '../DomainEntity.js'
 import { ReservedKeywords } from './postgresql.js'
-import type { DomainValidation } from './rules.js'
+import type { DomainValidationSchema } from './rules.js'
 
 /**
  * EntityValidation is a class that performs validation on entities in a data domain.
@@ -20,8 +20,8 @@ export class EntityValidation {
    * @param target The target entity to validate. Can be a string with
    *               the entity key or a DomainEntity object.
    */
-  validate(target: string | DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(target: string | DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let entity: DomainEntity | undefined
     if (typeof target === 'string') {
       entity = this.domain.findEntity(target)
@@ -57,8 +57,8 @@ export class EntityValidation {
    * Validates the entity primary key.
    * @param entity The entity to validate
    */
-  validatePrimaryKey(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validatePrimaryKey(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const primary = entity.primaryKey()
     if (!primary) {
       const message = `The "${entity.info.getLabel()}" entity has no identifier.`
@@ -124,8 +124,8 @@ export class EntityValidation {
    * Checks if the entity has the minimum required properties.
    * @param entity The entity to validate
    */
-  minimumRequiredProperties(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  minimumRequiredProperties(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     // Check if entity has properties or associations through entire inheritance chain
     const hasProperties = this.hasPropertiesInherited(entity)
@@ -161,8 +161,8 @@ export class EntityValidation {
    *   - Should not be a reserved word (for example: "IN", "SELECT", "FROM", etc.).
    * @param entity The entity to validate
    */
-  validateName(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validateName(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const label = entity.info.getLabel()
     if (!entity.info.name) {
       const message = `The "${label}" entity has no name.`
@@ -252,8 +252,8 @@ export class EntityValidation {
    * Checks if the entity name is unique in the data domain.
    * @param entity The entity to validate
    */
-  uniqueName(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  uniqueName(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const name = entity.info.name?.toLowerCase()
     if (!name) {
       return results

package/src/modeling/validation/property_validation.ts

@@ -1,7 +1,7 @@
 import { DomainPropertyKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import type { DomainProperty } from '../DomainProperty.js'
-import { type DomainValidation, validatePropertyName } from './rules.js'
+import { type DomainValidationSchema, validatePropertyName } from './rules.js'
 
 export class PropertyValidation {
   constructor(protected domain: DataDomain) {}
@@ -12,8 +12,8 @@ export class PropertyValidation {
    * @param target The target property to validate. Can be a string with
    *               the property key or a DomainProperty object.
    */
-  validate(target: string | DomainProperty): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(target: string | DomainProperty): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let property: DomainProperty | undefined
     if (typeof target === 'string') {
       property = this.domain.findProperty(target)
@@ -52,7 +52,7 @@ export class PropertyValidation {
    *   - (recommendation) Column names should be in lower case.
    * @param property The property to validate
    */
-  validateName(property: DomainProperty): DomainValidation[] {
+  validateName(property: DomainProperty): DomainValidationSchema[] {
     return validatePropertyName(property)
   }
 }

package/src/modeling/validation/rules.ts

@@ -12,7 +12,10 @@ import { DomainPropertyKind } from '../../models/kinds.js'
  * - `type` -> unused
  * - `relationship` -> unused
  */
-export interface DomainValidation extends Omit<DomainImpactItem, 'type' | 'impact' | 'relationship' | 'resolution'> {
+export interface DomainValidationSchema extends Omit<
+  DomainImpactItem,
+  'type' | 'impact' | 'relationship' | 'resolution'
+> {
   /**
    * The field that did not pass validation.
    */
@@ -55,8 +58,8 @@ export interface DomainValidation extends Omit<DomainImpactItem, 'type' | 'impac
  *
  * @param property The property to validate
  */
-export function validatePropertyName(property: DomainProperty | DomainAssociation): DomainValidation[] {
-  const results: DomainValidation[] = []
+export function validatePropertyName(property: DomainProperty | DomainAssociation): DomainValidationSchema[] {
+  const results: DomainValidationSchema[] = []
   const label = property.info.getLabel()
   const parentEntity = property.getParentInstance() as DomainEntity
   const type = property.kind === DomainPropertyKind ? 'property' : 'association'

package/src/modeling/validation/semantic_validation.ts

@@ -1,7 +1,7 @@
 import { DomainEntityKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import { DataSemantics, isPropertySemantic, SemanticType } from '../Semantics.js'
-import type { DomainValidation } from './rules.js'
+import type { DomainValidationSchema } from './rules.js'
 
 /**
  * SemanticValidation is a class that performs validation on semantics in a data domain.
@@ -14,8 +14,8 @@ export class SemanticValidation {
    * Performs all the semantic validation rules on the domain.
    * @returns The list of validation messages.
    */
-  validate(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     // Check for User entity semantic
     const hasUserEntity = this.validateUserEntity()
@@ -40,8 +40,8 @@ export class SemanticValidation {
    * Validates if there is at least one entity with the User semantic.
    * This is a recommended semantic for authentication purposes.
    */
-  private validateUserEntity(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validateUserEntity(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let hasUserEntity = false
 
     for (const entity of this.domain.listEntities()) {
@@ -70,8 +70,8 @@ export class SemanticValidation {
    * Validates if entities have the recommended timestamp semantics.
    * This includes CreatedTimestamp and UpdatedTimestamp.
    */
-  private validateTimestampSemantics(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validateTimestampSemantics(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     for (const entity of this.domain.listEntities()) {
       let hasCreatedTimestamp = false
@@ -118,8 +118,8 @@ export class SemanticValidation {
    * Validates if entities have the recommended soft delete semantics.
    * This includes either DeletedTimestamp or DeletedFlag.
    */
-  private validateSoftDeleteSemantics(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validateSoftDeleteSemantics(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     for (const entity of this.domain.listEntities()) {
       let hasSoftDelete = false
@@ -150,8 +150,8 @@ export class SemanticValidation {
   /**
    * Validates if property semantics are applied to properties with compatible data types.
    */
-  private validatePropertySemanticsDataTypes(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validatePropertySemanticsDataTypes(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     for (const entity of this.domain.listEntities()) {
       for (const property of entity.listProperties()) {

package/src/models/http-flows/LegacyTranslator.ts

@@ -10,7 +10,7 @@ import {
   DataSourceConfiguration,
 } from '../../models/legacy/actions/Actions.js'
 import { IHttpFlow, IHttpAction, FlowSourceEnum, FlowRequestDataEnum, FlowResponseDataEnum } from './HttpFlows.js'
-import { AmfNamespace } from '../../amf/definitions/Namespace.js'
+import { AmfNamespace } from '@api-client/amf-core'
 import { IHttpStep } from './HttpStep.js'
 import { IReadDataStep, ReadDataStep, ReadDataStepKind } from './steps/data/ReadDataStep.js'
 import { ISetDataStep, SetDataStepKind } from './steps/data/SetDataStep.js'

package/src/runtime/http-runner/HttpFlows.ts

@@ -27,7 +27,7 @@ import { ISubstringStep, SubstringStepKind } from '../../models/http-flows/steps
 import { TrimStepKind } from '../../models/http-flows/steps/transformation/TrimStep.js'
 import { EqualAssertionKind, IEqualAssertion } from '../../models/http-flows/steps/assertion/EqualAssertion.js'
 import { INotEqualAssertion, NotEqualAssertionKind } from '../../models/http-flows/steps/assertion/NotEqualAssertion.js'
-import { ApiSchemaValues } from '../../amf/ApiSchemaValues.js'
+import { ApiSchemaValues } from '@api-client/amf-core'
 import {
   GreaterThanAssertionKind,
   IGreaterThanAssertion,

package/tests/unit/{amf → modeling/amf}/data_value_generator.spec.ts

@@ -1,6 +1,6 @@
 import { test } from '@japa/runner'
-import { DataValueGenerator, noValue } from '../../../src/amf/DataValueGenerator.js'
-import type { DomainPropertyType } from '../../../src/modeling/DataFormat.js'
+import { DataValueGenerator, noValue } from '../../../../src/modeling/amf/DataValueGenerator.js'
+import type { DomainPropertyType } from '../../../../src/modeling/DataFormat.js'
 
 test.group('DataValueGenerator', (group) => {
   let generator: DataValueGenerator