@canon-protocol/sdk 8.0.0

package/dist/resolution/TypeResolver.js

@@ -0,0 +1,110 @@
+export class TypeResolver {
+    static KNOWN_XSD_DATATYPES = new Set([
+        'string',
+        'integer',
+        'int',
+        'boolean',
+        'bool',
+        'decimal',
+        'float',
+        'double',
+        'date',
+        'datetime',
+        'time',
+        'duration',
+        'anyuri',
+        'base64binary',
+        'hexbinary',
+        'long',
+        'short',
+        'byte',
+        'nonnegativeinteger',
+        'positiveinteger',
+        'negativeinteger',
+        'nonpositiveinteger',
+        'unsignedint',
+        'unsignedlong',
+        'unsignedshort',
+        'unsignedbyte'
+    ]);
+    resourceResolver;
+    constructor(resourceResolver) {
+        this.resourceResolver = resourceResolver;
+    }
+    isXsdDatatype(uri) {
+        if (!uri)
+            return false;
+        return uri.publisher === 'canon-protocol.org' &&
+            uri.package_ === 'core.xsd' &&
+            TypeResolver.KNOWN_XSD_DATATYPES.has(uri.name.toLowerCase());
+    }
+    isLiteralType(uri) {
+        if (!uri)
+            return false;
+        return uri.publisher === 'canon-protocol.org' &&
+            uri.package_ === 'core.rdf' &&
+            uri.name === 'Literal';
+    }
+    isKnownXsdDatatypeName(typeName) {
+        const name = typeName.includes('.') ? typeName.split('.')[1] : typeName;
+        return TypeResolver.KNOWN_XSD_DATATYPES.has(name.toLowerCase());
+    }
+    async isClassTypeAsync(typeName, currentDocument) {
+        if (this.isKnownXsdDatatypeName(typeName)) {
+            return false;
+        }
+        const result = await this.resourceResolver.resolveEntityAsync(typeName, currentDocument);
+        if (result) {
+            const typeValue = result.entity['type'];
+            if (typeValue) {
+                const typeStr = String(typeValue);
+                return typeStr === 'Class' ||
+                    typeStr === 'rdfs.Class' ||
+                    typeStr.endsWith('.Class');
+            }
+        }
+        return true;
+    }
+    getPropertyTypeClassification(propertyType) {
+        if (!propertyType || propertyType.trim().length === 0) {
+            return 'Property'; // Default to base Property
+        }
+        const typeName = propertyType.includes('.') ? propertyType.split('.')[1] : propertyType;
+        switch (typeName) {
+            case 'DatatypeProperty':
+                return 'DatatypeProperty';
+            case 'ObjectProperty':
+                return 'ObjectProperty';
+            case 'AnnotationProperty':
+                return 'AnnotationProperty';
+            case 'Property':
+                return 'Property';
+            default:
+                return 'Property'; // Unknown types default to base Property
+        }
+    }
+    isEffectiveDatatypeProperty(propertyTypeClassification, rangeUri) {
+        if (propertyTypeClassification === 'DatatypeProperty') {
+            return true;
+        }
+        if (propertyTypeClassification === 'Property' && this.isXsdDatatype(rangeUri)) {
+            return true;
+        }
+        if (propertyTypeClassification === 'Property' && this.isLiteralType(rangeUri)) {
+            return true;
+        }
+        return false;
+    }
+    isEffectiveObjectProperty(propertyTypeClassification, rangeUri) {
+        if (propertyTypeClassification === 'ObjectProperty') {
+            return true;
+        }
+        if (propertyTypeClassification === 'Property' &&
+            rangeUri &&
+            !this.isXsdDatatype(rangeUri) &&
+            !this.isLiteralType(rangeUri)) {
+            return true;
+        }
+        return false;
+    }
+}

package/dist/resolution/index.d.ts

@@ -0,0 +1,6 @@
+export { ResourceResolver } from './ResourceResolver.js';
+export type { ILogger } from './ResourceResolver.js';
+export { CanonUri } from './CanonUri.js';
+export { CanonUriBuilder } from './CanonUriBuilder.js';
+export type { ResourceResolutionResult } from './ResourceResolutionResult.js';
+export { TypeResolver } from './TypeResolver.js';

package/dist/resolution/index.js

@@ -0,0 +1,4 @@
+export { ResourceResolver } from './ResourceResolver.js';
+export { CanonUri } from './CanonUri.js';
+export { CanonUriBuilder } from './CanonUriBuilder.js';
+export { TypeResolver } from './TypeResolver.js';

package/dist/statements/BooleanStatement.d.ts

@@ -0,0 +1,3 @@
+import { ScalarStatement } from './ScalarStatement.js';
+export declare class BooleanStatement extends ScalarStatement<boolean> {
+}

package/dist/statements/BooleanStatement.js

@@ -0,0 +1,3 @@
+import { ScalarStatement } from './ScalarStatement.js';
+export class BooleanStatement extends ScalarStatement {
+}

package/dist/statements/EmbeddedStatement.d.ts

@@ -0,0 +1,4 @@
+import { Statement } from './Statement.js';
+import type { EmbeddedCanon } from '../canons/EmbeddedCanon.js';
+export declare class EmbeddedStatement extends Statement<EmbeddedCanon> {
+}

package/dist/statements/EmbeddedStatement.js

@@ -0,0 +1,3 @@
+import { Statement } from './Statement.js';
+export class EmbeddedStatement extends Statement {
+}

package/dist/statements/IStatement.d.ts

@@ -0,0 +1,2 @@
+export interface IStatement {
+}

package/dist/statements/IStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ListStatement.d.ts

@@ -0,0 +1,4 @@
+import { Statement } from './Statement.js';
+import type { Canon } from '../canons/Canon.js';
+export declare class ListStatement extends Statement<Canon[]> {
+}

package/dist/statements/ListStatement.js

@@ -0,0 +1,3 @@
+import { Statement } from './Statement.js';
+export class ListStatement extends Statement {
+}

package/dist/statements/NumberStatement.d.ts

@@ -0,0 +1,4 @@
+import { ScalarStatement } from './ScalarStatement.js';
+export declare class NumberStatement extends ScalarStatement<number> {
+    static parse(predicateCanonUri: string, objectValue: number): NumberStatement;
+}

package/dist/statements/NumberStatement.js

@@ -0,0 +1,10 @@
+import { ScalarStatement } from './ScalarStatement.js';
+import { ReferenceCanon } from '../canons/ReferenceCanon.js';
+export class NumberStatement extends ScalarStatement {
+    static parse(predicateCanonUri, objectValue) {
+        const stmt = new NumberStatement();
+        stmt.predicate = ReferenceCanon.parse(predicateCanonUri);
+        stmt.object = objectValue;
+        return stmt;
+    }
+}

package/dist/statements/ReferenceStatement.d.ts

@@ -0,0 +1,5 @@
+import { Statement } from './Statement.js';
+import { ReferenceCanon } from '../canons/ReferenceCanon.js';
+export declare class ReferenceStatement extends Statement<ReferenceCanon> {
+    static parse(predicateCanonUri: string, objectCanonUri: string): ReferenceStatement;
+}

package/dist/statements/ReferenceStatement.js

@@ -0,0 +1,10 @@
+import { Statement } from './Statement.js';
+import { ReferenceCanon } from '../canons/ReferenceCanon.js';
+export class ReferenceStatement extends Statement {
+    static parse(predicateCanonUri, objectCanonUri) {
+        const stmt = new ReferenceStatement();
+        stmt.predicate = ReferenceCanon.parse(predicateCanonUri);
+        stmt.object = ReferenceCanon.parse(objectCanonUri);
+        return stmt;
+    }
+}

package/dist/statements/ScalarStatement.d.ts

@@ -0,0 +1,3 @@
+import { Statement } from './Statement.js';
+export declare abstract class ScalarStatement<TScalar> extends Statement<TScalar> {
+}

package/dist/statements/ScalarStatement.js

@@ -0,0 +1,3 @@
+import { Statement } from './Statement.js';
+export class ScalarStatement extends Statement {
+}

package/dist/statements/Statement.d.ts

@@ -0,0 +1,6 @@
+import type { IStatement } from './IStatement.js';
+import type { ReferenceCanon } from '../canons/ReferenceCanon.js';
+export declare abstract class Statement<TObject> implements IStatement {
+    predicate: ReferenceCanon;
+    object: TObject;
+}

package/dist/statements/Statement.js

@@ -0,0 +1,4 @@
+export class Statement {
+    predicate;
+    object;
+}

package/dist/statements/StringStatement.d.ts

@@ -0,0 +1,4 @@
+import { ScalarStatement } from './ScalarStatement.js';
+export declare class StringStatement extends ScalarStatement<string> {
+    static parse(predicateCanonUri: string, objectValue: string): StringStatement;
+}

package/dist/statements/StringStatement.js

@@ -0,0 +1,10 @@
+import { ScalarStatement } from './ScalarStatement.js';
+import { ReferenceCanon } from '../canons/ReferenceCanon.js';
+export class StringStatement extends ScalarStatement {
+    static parse(predicateCanonUri, objectValue) {
+        const stmt = new StringStatement();
+        stmt.predicate = ReferenceCanon.parse(predicateCanonUri);
+        stmt.object = objectValue;
+        return stmt;
+    }
+}

package/dist/statements/index.d.ts

@@ -0,0 +1,9 @@
+export type { IStatement } from './IStatement.js';
+export { Statement } from './Statement.js';
+export { ScalarStatement } from './ScalarStatement.js';
+export { StringStatement } from './StringStatement.js';
+export { NumberStatement } from './NumberStatement.js';
+export { BooleanStatement } from './BooleanStatement.js';
+export { ReferenceStatement } from './ReferenceStatement.js';
+export { EmbeddedStatement } from './EmbeddedStatement.js';
+export { ListStatement } from './ListStatement.js';

package/dist/statements/index.js

@@ -0,0 +1,8 @@
+export { Statement } from './Statement.js';
+export { ScalarStatement } from './ScalarStatement.js';
+export { StringStatement } from './StringStatement.js';
+export { NumberStatement } from './NumberStatement.js';
+export { BooleanStatement } from './BooleanStatement.js';
+export { ReferenceStatement } from './ReferenceStatement.js';
+export { EmbeddedStatement } from './EmbeddedStatement.js';
+export { ListStatement } from './ListStatement.js';

package/dist/validation/CanonObjectValidator.d.ts

@@ -0,0 +1,21 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+import type { ICanonObjectValidator } from './ICanonObjectValidator.js';
+import type { IDocumentValidationRule } from './rules/document/IDocumentValidationRule.js';
+import type { IRepositoryValidationRule } from './rules/repository/IRepositoryValidationRule.js';
+import { OntologyValidationResult } from './OntologyValidationResult.js';
+export declare class CanonObjectValidator implements ICanonObjectValidator {
+    private readonly parser;
+    private readonly documentRules;
+    private readonly repositoryRules;
+    includeWarnings: boolean;
+    constructor(parser?: ICanonParser);
+    validateAsync(document: CanonDocument, repository?: ICanonDocumentRepository | null): Promise<OntologyValidationResult>;
+    validateYamlAsync(yamlText: string, repository?: ICanonDocumentRepository | null): Promise<OntologyValidationResult>;
+    addDocumentRule(rule: IDocumentValidationRule): void;
+    addRepositoryRule(rule: IRepositoryValidationRule): void;
+    removeDocumentRule<T extends IDocumentValidationRule>(ruleType: new () => T): void;
+    removeRepositoryRule<T extends IRepositoryValidationRule>(ruleType: new () => T): void;
+    private addErrorsToResult;
+}

package/dist/validation/CanonObjectValidator.js

@@ -0,0 +1,150 @@
+import { CanonParser } from '../parsing/CanonParser.js';
+import { OntologyValidationResult } from './OntologyValidationResult.js';
+import { OntologyValidationError } from './OntologyValidationError.js';
+import { ValidationSeverity } from './ValidationSeverity.js';
+import { NamespacePrefixRule } from './rules/document/NamespacePrefixRule.js';
+import { ResourceNamingRule } from './rules/document/ResourceNamingRule.js';
+import { PropertyTypeSpecificityRule } from './rules/document/PropertyTypeSpecificityRule.js';
+import { SubjectCanonTypeRequiredRule } from './rules/document/SubjectCanonTypeRequiredRule.js';
+import { EmbeddedCanonNoExplicitTypeRule } from './rules/document/EmbeddedCanonNoExplicitTypeRule.js';
+import { ImportExistenceRule } from './rules/repository/ImportExistenceRule.js';
+import { UnresolvedReferenceRule } from './rules/repository/UnresolvedReferenceRule.js';
+import { TypeAmbiguityRule } from './rules/repository/TypeAmbiguityRule.js';
+import { ClassHierarchyCycleRule } from './rules/repository/ClassHierarchyCycleRule.js';
+import { PropertyHierarchyCycleRule } from './rules/repository/PropertyHierarchyCycleRule.js';
+import { PropertyRangeRequiredRule } from './rules/repository/PropertyRangeRequiredRule.js';
+import { SubClassOfReferenceRule } from './rules/repository/SubClassOfReferenceRule.js';
+import { SubPropertyOfReferenceRule } from './rules/repository/SubPropertyOfReferenceRule.js';
+import { NamespaceImportCycleRule } from './rules/repository/NamespaceImportCycleRule.js';
+import { InstancePropertyReferenceRule } from './rules/repository/InstancePropertyReferenceRule.js';
+import { DefinitionPropertyReferenceRule } from './rules/repository/DefinitionPropertyReferenceRule.js';
+import { XsdImportRule } from './rules/repository/XsdImportRule.js';
+import { AmbiguousReferenceRule } from './rules/repository/AmbiguousReferenceRule.js';
+import { PropertyRangeReferenceRule } from './rules/repository/PropertyRangeReferenceRule.js';
+import { ObjectPropertyImportRule } from './rules/repository/ObjectPropertyImportRule.js';
+import { ObjectPropertyValueValidationRule } from './rules/repository/ObjectPropertyValueValidationRule.js';
+import { PropertyDomainRule } from './rules/repository/PropertyDomainRule.js';
+import { PropertyValueTypeRule } from './rules/repository/PropertyValueTypeRule.js';
+import { ClassDefinitionRule } from './rules/repository/ClassDefinitionRule.js';
+export class CanonObjectValidator {
+    parser;
+    documentRules;
+    repositoryRules;
+    includeWarnings = true;
+    constructor(parser) {
+        this.parser = parser ?? new CanonParser();
+        this.documentRules = [
+            new NamespacePrefixRule(),
+            new ResourceNamingRule(),
+            new PropertyTypeSpecificityRule(),
+            new SubjectCanonTypeRequiredRule(),
+            new EmbeddedCanonNoExplicitTypeRule()
+        ];
+        this.repositoryRules = [
+            new ImportExistenceRule(),
+            new UnresolvedReferenceRule(),
+            new TypeAmbiguityRule(),
+            new ClassHierarchyCycleRule(),
+            new PropertyHierarchyCycleRule(),
+            new PropertyRangeRequiredRule(),
+            new SubClassOfReferenceRule(),
+            new SubPropertyOfReferenceRule(),
+            new NamespaceImportCycleRule(),
+            new InstancePropertyReferenceRule(),
+            new DefinitionPropertyReferenceRule(),
+            new XsdImportRule(),
+            new AmbiguousReferenceRule(),
+            new PropertyRangeReferenceRule(),
+            new ObjectPropertyImportRule(),
+            new ObjectPropertyValueValidationRule(),
+            new PropertyDomainRule(),
+            new PropertyValueTypeRule(),
+            new ClassDefinitionRule()
+        ];
+    }
+    async validateAsync(document, repository) {
+        const result = new OntologyValidationResult();
+        for (const rule of this.documentRules) {
+            try {
+                const ruleErrors = rule.validate(document);
+                this.addErrorsToResult(result, ruleErrors);
+            }
+            catch (error) {
+                const validationError = new OntologyValidationError();
+                validationError.ruleType = rule.ruleName;
+                validationError.severity = ValidationSeverity.Error;
+                validationError.message = `Validation rule '${rule.ruleName}' failed: ${error instanceof Error ? error.message : String(error)}`;
+                result.errors.push(validationError);
+            }
+        }
+        if (repository) {
+            for (const rule of this.repositoryRules) {
+                try {
+                    const ruleErrors = await rule.validateAsync(document, repository);
+                    this.addErrorsToResult(result, ruleErrors);
+                }
+                catch (error) {
+                    const validationError = new OntologyValidationError();
+                    validationError.ruleType = rule.ruleName;
+                    validationError.severity = ValidationSeverity.Error;
+                    validationError.message = `Validation rule '${rule.ruleName}' failed: ${error instanceof Error ? error.message : String(error)}`;
+                    result.errors.push(validationError);
+                }
+            }
+        }
+        result.isValid = result.errors.length === 0;
+        return result;
+    }
+    async validateYamlAsync(yamlText, repository) {
+        const parseResult = this.parser.parseWithErrors(yamlText);
+        if (!parseResult.isValid) {
+            const result = new OntologyValidationResult();
+            result.isValid = false;
+            for (const parseError of parseResult.errors) {
+                const validationError = new OntologyValidationError();
+                validationError.ruleType = 'ParseError';
+                validationError.severity = ValidationSeverity.Error;
+                validationError.lineNumber = parseError.line;
+                validationError.column = parseError.column;
+                validationError.message = parseError.message;
+                if (parseError.keyName) {
+                    validationError.entityName = parseError.keyName; // For duplicate keys, store the key name
+                }
+                if (parseError.errorType === 'DuplicateKey') {
+                    validationError.suggestion = 'All property names must be unique across the entire document. Rename one of the duplicate properties to make them unique.';
+                }
+                result.errors.push(validationError);
+            }
+            return result;
+        }
+        return await this.validateAsync(parseResult.document, repository);
+    }
+    addDocumentRule(rule) {
+        this.documentRules.push(rule);
+    }
+    addRepositoryRule(rule) {
+        this.repositoryRules.push(rule);
+    }
+    removeDocumentRule(ruleType) {
+        const index = this.documentRules.findIndex(r => r instanceof ruleType);
+        if (index >= 0) {
+            this.documentRules.splice(index, 1);
+        }
+    }
+    removeRepositoryRule(ruleType) {
+        const index = this.repositoryRules.findIndex(r => r instanceof ruleType);
+        if (index >= 0) {
+            this.repositoryRules.splice(index, 1);
+        }
+    }
+    addErrorsToResult(result, errors) {
+        for (const error of errors) {
+            if (error.severity === ValidationSeverity.Error) {
+                result.errors.push(error);
+            }
+            else if (this.includeWarnings) {
+                result.warnings.push(error);
+            }
+        }
+    }
+}

package/dist/validation/ICanonObjectValidator.d.ts

@@ -0,0 +1,7 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { OntologyValidationResult } from './OntologyValidationResult.js';
+export interface ICanonObjectValidator {
+    validateAsync(document: CanonDocument, repository?: ICanonDocumentRepository | null): Promise<OntologyValidationResult>;
+    validateYamlAsync(yamlText: string, repository?: ICanonDocumentRepository | null): Promise<OntologyValidationResult>;
+}

package/dist/validation/ICanonObjectValidator.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/OntologyValidationError.d.ts

@@ -0,0 +1,15 @@
+import { ValidationSeverity } from './ValidationSeverity.js';
+export declare class OntologyValidationError {
+    ruleType: string;
+    severity: ValidationSeverity;
+    lineNumber?: number;
+    column?: number;
+    entityName?: string;
+    propertyName?: string;
+    propertyPath?: string;
+    message: string;
+    suggestion?: string;
+    actualValue?: string;
+    expectedValue?: string;
+    toString(): string;
+}

package/dist/validation/OntologyValidationError.js

@@ -0,0 +1,25 @@
+import { ValidationSeverity } from './ValidationSeverity.js';
+export class OntologyValidationError {
+    ruleType = '';
+    severity = ValidationSeverity.Error;
+    lineNumber;
+    column;
+    entityName;
+    propertyName;
+    propertyPath;
+    message = '';
+    suggestion;
+    actualValue;
+    expectedValue;
+    toString() {
+        let result = '';
+        if (this.lineNumber !== undefined) {
+            result += `Line ${this.lineNumber}: `;
+        }
+        if (this.entityName) {
+            result += `[${this.entityName}] `;
+        }
+        result += this.message;
+        return result;
+    }
+}

package/dist/validation/OntologyValidationResult.d.ts

@@ -0,0 +1,7 @@
+import { OntologyValidationError } from './OntologyValidationError.js';
+export declare class OntologyValidationResult {
+    isValid: boolean;
+    errors: OntologyValidationError[];
+    warnings: OntologyValidationError[];
+    get totalIssues(): number;
+}

package/dist/validation/OntologyValidationResult.js

@@ -0,0 +1,8 @@
+export class OntologyValidationResult {
+    isValid = false;
+    errors = [];
+    warnings = [];
+    get totalIssues() {
+        return this.errors.length + this.warnings.length;
+    }
+}

package/dist/validation/ValidationContext.d.ts

@@ -0,0 +1,6 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+export declare class ValidationContext {
+    resolvedDocuments: CanonDocument[];
+    currentEntityPath?: string;
+    withPath(path: string): ValidationContext;
+}

package/dist/validation/ValidationContext.js

@@ -0,0 +1,10 @@
+export class ValidationContext {
+    resolvedDocuments = [];
+    currentEntityPath;
+    withPath(path) {
+        const newContext = new ValidationContext();
+        newContext.resolvedDocuments = this.resolvedDocuments;
+        newContext.currentEntityPath = path;
+        return newContext;
+    }
+}

package/dist/validation/ValidationSeverity.d.ts

@@ -0,0 +1,4 @@
+export declare enum ValidationSeverity {
+    Warning = "Warning",
+    Error = "Error"
+}

package/dist/validation/ValidationSeverity.js

@@ -0,0 +1,5 @@
+export var ValidationSeverity;
+(function (ValidationSeverity) {
+    ValidationSeverity["Warning"] = "Warning";
+    ValidationSeverity["Error"] = "Error";
+})(ValidationSeverity || (ValidationSeverity = {}));

package/dist/validation/index.d.ts

@@ -0,0 +1,10 @@
+export { OntologyValidationResult } from './OntologyValidationResult.js';
+export { OntologyValidationError } from './OntologyValidationError.js';
+export { ValidationSeverity } from './ValidationSeverity.js';
+export { ValidationContext } from './ValidationContext.js';
+export type { ICanonObjectValidator } from './ICanonObjectValidator.js';
+export { CanonObjectValidator } from './CanonObjectValidator.js';
+export type { IDocumentValidationRule } from './rules/document/IDocumentValidationRule.js';
+export type { IRepositoryValidationRule } from './rules/repository/IRepositoryValidationRule.js';
+export { NamespacePrefixRule, ResourceNamingRule, PropertyTypeSpecificityRule, SubjectCanonTypeRequiredRule, EmbeddedCanonNoExplicitTypeRule } from './rules/document/index.js';
+export { ImportExistenceRule, UnresolvedReferenceRule, TypeAmbiguityRule, ClassHierarchyCycleRule, PropertyHierarchyCycleRule, PropertyRangeRequiredRule, SubClassOfReferenceRule, SubPropertyOfReferenceRule, NamespaceImportCycleRule, InstancePropertyReferenceRule, DefinitionPropertyReferenceRule, XsdImportRule, AmbiguousReferenceRule, PropertyRangeReferenceRule, ObjectPropertyImportRule, ObjectPropertyValueValidationRule, PropertyDomainRule, PropertyValueTypeRule, ClassDefinitionRule } from './rules/repository/index.js';

package/dist/validation/index.js

@@ -0,0 +1,7 @@
+export { OntologyValidationResult } from './OntologyValidationResult.js';
+export { OntologyValidationError } from './OntologyValidationError.js';
+export { ValidationSeverity } from './ValidationSeverity.js';
+export { ValidationContext } from './ValidationContext.js';
+export { CanonObjectValidator } from './CanonObjectValidator.js';
+export { NamespacePrefixRule, ResourceNamingRule, PropertyTypeSpecificityRule, SubjectCanonTypeRequiredRule, EmbeddedCanonNoExplicitTypeRule } from './rules/document/index.js';
+export { ImportExistenceRule, UnresolvedReferenceRule, TypeAmbiguityRule, ClassHierarchyCycleRule, PropertyHierarchyCycleRule, PropertyRangeRequiredRule, SubClassOfReferenceRule, SubPropertyOfReferenceRule, NamespaceImportCycleRule, InstancePropertyReferenceRule, DefinitionPropertyReferenceRule, XsdImportRule, AmbiguousReferenceRule, PropertyRangeReferenceRule, ObjectPropertyImportRule, ObjectPropertyValueValidationRule, PropertyDomainRule, PropertyValueTypeRule, ClassDefinitionRule } from './rules/repository/index.js';

package/dist/validation/rules/document/EmbeddedCanonNoExplicitTypeRule.d.ts

@@ -0,0 +1,8 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { IDocumentValidationRule } from './IDocumentValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class EmbeddedCanonNoExplicitTypeRule implements IDocumentValidationRule {
+    get ruleName(): string;
+    validate(document: CanonDocument): OntologyValidationError[];
+    private checkForEmbeddedTypeViolations;
+}

package/dist/validation/rules/document/EmbeddedCanonNoExplicitTypeRule.js

@@ -0,0 +1,53 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class EmbeddedCanonNoExplicitTypeRule {
+    get ruleName() {
+        return 'EmbeddedCanonNoExplicitType';
+    }
+    validate(document) {
+        const errors = [];
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                this.checkForEmbeddedTypeViolations(entityName, entityDef, errors, 0);
+            }
+        }
+        return errors;
+    }
+    checkForEmbeddedTypeViolations(path, dict, errors, depth) {
+        for (const [key, value] of Object.entries(dict)) {
+            const propertyName = key;
+            if (depth > 0 && propertyName.toLowerCase() === 'type') {
+                const typeValue = value?.toString();
+                const rootEntity = path.split('.')[0];
+                const error = new OntologyValidationError();
+                error.ruleType = this.ruleName;
+                error.severity = ValidationSeverity.Error;
+                error.entityName = rootEntity; // Root entity for lookup
+                error.propertyName = path; // Full nested path for navigation
+                error.actualValue = 'type'; // Property to find at end of path
+                error.message = `Embedded object at '${path}' cannot have explicit 'type' property.`;
+                error.suggestion =
+                    `Remove the 'type: ${typeValue}' line.\n\n` +
+                        "Type is automatically inferred from the containing property's range.\n" +
+                        "If you need a different type, modify the 'range' of the parent property and version it appropriately.\n\n" +
+                        "Example: If the parent property is 'hasCharacter' with range 'Character', " +
+                        "all embedded objects in that property will be typed as 'Character' automatically.";
+                error.expectedValue = "No explicit type (inferred from parent property's range)";
+                errors.push(error);
+            }
+            if (typeof value === 'object' && value !== null) {
+                if (Array.isArray(value)) {
+                    for (let i = 0; i < value.length; i++) {
+                        const item = value[i];
+                        if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+                            this.checkForEmbeddedTypeViolations(`${path}.${propertyName}[${i}]`, item, errors, depth + 1);
+                        }
+                    }
+                }
+                else {
+                    this.checkForEmbeddedTypeViolations(`${path}.${propertyName}`, value, errors, depth + 1);
+                }
+            }
+        }
+    }
+}

package/dist/validation/rules/document/IDocumentValidationRule.d.ts

@@ -0,0 +1,6 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { OntologyValidationError } from '../../OntologyValidationError.js';
+export interface IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: CanonDocument): OntologyValidationError[];
+}

package/dist/validation/rules/document/IDocumentValidationRule.js

@@ -0,0 +1 @@
+export {};