@kanonak-protocol/types 1.1.0

package/dist/object/resolution/types.d.ts

@@ -0,0 +1,116 @@
+import { KanonakDocument, Version } from '../../document/models/types';
+import { KanonakUri } from '../../object/uris/types';
+/**
+ * Builds KanonakUri instances from resource names, handling alias resolution     and version resolution through imports.
+ */
+export interface KanonakUriBuilder {
+    /**
+     * Builds a KanonakUri from a resource name, resolving aliases and versions
+     */
+    buildFromNameAsync(resourceName: string, currentDocument: KanonakDocument): Promise<KanonakUri | null>;
+    /**
+     * Builds a KanonakUri from a resource name using a pre-built resource index
+     */
+    buildFromName(resourceName: string, resourceIndex: Record<string, ResourceResolutionResult>, currentDocument: KanonakDocument): KanonakUri | null;
+    /**
+     * Creates a KanonakUri directly from known components (for when resource is already resolved)
+     */
+    create(publisher: string, package_: string, name: string, version?: Version | null): KanonakUri;
+}
+/**
+ * Result of resolving a resource across namespace boundaries
+ */
+export interface ResourceResolutionResult {
+    /**
+     * Name of the resource
+     */
+    resourceName: string;
+    /**
+     * Full Kanonak URI identifying this resource uniquely
+     */
+    uri: KanonakUri;
+    /**
+     * The actual resource dictionary from the YAML document
+     */
+    resource: Map<any, any>;
+    /**
+     * Full namespace where this resource is defined (e.g., "healthcare.org/clinical@1.0.0")
+     */
+    definedInNamespace: string;
+    /**
+     * True if this resource was found in an imported namespace (vs the current document)
+     */
+    isImported: boolean;
+    /**
+     * Import chain showing how we got to this resource (for debugging/education)     Example: "example.com/app@1.0.0 → healthcare.org/clinical@1.0.0"
+     */
+    importPath?: string | null | undefined;
+}
+/**
+ * Resolves resources across namespace boundaries by following import chains transitively.     Provides robust type checking that works across imported ontologies.     Core component of the Kanonak.Object ontology engine - used by parser, validator, and all clients.
+ */
+export interface ResourceResolver {
+    /**
+     * Finds a resource in the current document or any transitively imported documents
+     */
+    resolveResourceAsync(resourceName: string, currentDocument: KanonakDocument): Promise<ResourceResolutionResult | null>;
+    /**
+     * Finds ALL matching resources across all namespaces (supports ambiguity detection and multi-definition navigation)
+     */
+    resolveAllResourcesAsync(resourceName: string, currentDocument: KanonakDocument): Promise<Array<ResourceResolutionResult>>;
+    /**
+     * Builds a complete resource index from current document and all transitive imports
+     */
+    buildResourceIndexAsync(document: KanonakDocument): Promise<Record<string, ResourceResolutionResult>>;
+    /** C# method 'ClearCache' has 2 overloads. Using overload with most parameters. */
+    /**
+     * Clears cache for a specific document.
+     */
+    clearCache(documentKey: string): void;
+    /**
+     * Checks if a class is a subclass of another class (direct or transitive)
+     */
+    isSubclassOfAsync(className: string, parentClassName: string, document: KanonakDocument): Promise<boolean>;
+    /**
+     * Checks if a property is a subproperty of another property (direct or transitive)
+     */
+    isSubpropertyOfAsync(propertyName: string, parentPropertyName: string, document: KanonakDocument): Promise<boolean>;
+}
+/**
+ * Classifies Kanonak resources by their semantic type (Class, Property, Instance, etc.).     This is the canonical source of truth for resource type classification.     Uses resolved KanonakUri, NOT document-scoped aliases.
+ */
+export interface ResourceTypeClassifier {
+}
+/**
+ * Resolves and validates types in Kanonak ontologies.     Determines if a type is a datatype vs class, validates type references.
+ */
+export interface TypeResolver {
+    /**
+     * Checks if a KanonakUri refers to an XSD datatype
+     */
+    isXsdDatatype(uri: KanonakUri | null): boolean;
+    /**
+     * Checks if a KanonakUri refers to rdfs:Literal (the superclass of all literal datatypes)
+     */
+    isLiteralType(uri: KanonakUri | null): boolean;
+    /**
+     * Checks if a type name refers to a known XSD datatype (string name check)
+     */
+    isKnownXsdDatatypeName(typeName: string): boolean;
+    /**
+     * Checks if a type name refers to a class (vs a datatype)
+     */
+    isClassTypeAsync(typeName: string, currentDocument: KanonakDocument): Promise<boolean>;
+    /**
+     * Gets the property type classification (DatatypeProperty, ObjectProperty, or Property)
+     */
+    getPropertyTypeClassification(propertyType: string | null): string;
+    /**
+     * Determines if a property should be treated as a datatype property based on its type and range
+     */
+    isEffectiveDatatypeProperty(propertyTypeClassification: string, rangeUri: KanonakUri | null): boolean;
+    /**
+     * Determines if a property should be treated as an object property based on its type and range
+     */
+    isEffectiveObjectProperty(propertyTypeClassification: string, rangeUri: KanonakUri | null): boolean;
+}

package/dist/object/statements/index.d.ts

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

package/dist/object/statements/types.d.ts

@@ -0,0 +1,20 @@
+import { Kanonak, EmbeddedKanonak, ReferenceKanonak } from '../../object/kanonaks/types';
+import { IStatement } from '../../object/statements/index';
+export interface Statement<TObject> extends IStatement {
+    predicate: ReferenceKanonak;
+    object_: TObject;
+}
+export interface ScalarStatement<TScalar> extends Statement<TScalar> {
+}
+export interface BooleanStatement extends ScalarStatement<boolean> {
+}
+export interface EmbeddedStatement extends Statement<EmbeddedKanonak> {
+}
+export interface ListStatement extends Statement<Array<Kanonak>> {
+}
+export interface NumberStatement extends ScalarStatement<number> {
+}
+export interface ReferenceStatement extends Statement<ReferenceKanonak> {
+}
+export interface StringStatement extends ScalarStatement<string> {
+}

package/dist/object/uris/types.d.ts

@@ -0,0 +1,17 @@
+import { Version } from '../../document/models/types';
+/**
+ * Represents a Kanonak Resource URI that uniquely identifies a resource within a package.     Format: publisher/package[@version]/resource     Examples:      - stories.org/characters@1.0.0/romeo-montague (specific version)      - stories.org/characters/romeo-montague (latest version)        Note: This is distinct from a Kanonak Package URI (publisher/package[@version])     which identifies a package but not a specific resource within it.
+ */
+export interface KanonakUri {
+    publisher: string;
+    package_: string;
+    name: string;
+    /**
+     * The version of the package. If null, represents "latest" version.
+     */
+    version?: Version | null | undefined;
+    /**
+     * Converts the Kanonak URI to its string representation.
+     */
+    toString(): string;
+}

package/dist/object/validation/enums.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Severity levels for validation issues
+ */
+export declare enum ValidationSeverity {
+    /**
+     * Non-critical issue that should be addressed
+     */
+    Warning = 0,
+    /**
+     * Critical issue that must be fixed
+     */
+    Error = 1
+}

package/dist/object/validation/enums.js

@@ -0,0 +1 @@
+var m=(g=>(g[g.Warning=0]="Warning",g[g.Error=1]="Error",g))(m||{});export{m as ValidationSeverity};

package/dist/object/validation/index.d.ts

@@ -0,0 +1,19 @@
+import { IKanonakDocumentRepository } from '../../document/models/index';
+import { KanonakDocument } from '../../document/models/types';
+import { OntologyValidationResult } from '../../object/validation/types';
+export { IKanonakDocumentRepository };
+export { KanonakDocument };
+export { OntologyValidationResult };
+/**
+ * Interface for validating Kanonak documents at the ontology level
+ */
+export interface IKanonakObjectValidator {
+    /**
+     * Validates a Kanonak document for ontological correctness
+     */
+    validateAsync(document: KanonakDocument, repository?: IKanonakDocumentRepository | null): Promise<OntologyValidationResult>;
+    /**
+     * Validates a Kanonak document from YAML text
+     */
+    validateYamlAsync(yamlText: string, repository?: IKanonakDocumentRepository | null): Promise<OntologyValidationResult>;
+}

package/dist/object/validation/index.js

@@ -0,0 +1 @@
+import{IKanonakDocumentRepository as o}from"../../document/models/index";import{KanonakDocument as t}from"../../document/models/types";import{OntologyValidationResult as n}from"../../object/validation/types";export{o as IKanonakDocumentRepository,t as KanonakDocument,n as OntologyValidationResult};

package/dist/object/validation/rules/document/index.d.ts

@@ -0,0 +1,17 @@
+import { KanonakDocument } from '../../../../document/models/types';
+import { OntologyValidationError } from '../../../../object/validation/types';
+export { KanonakDocument };
+export { OntologyValidationError };
+/**
+ * Interface for validation rules that operate on a document in isolation     without needing external dependencies like repositories
+ */
+export interface IDocumentValidationRule {
+    /**
+     * The name of this validation rule
+     */
+    readonly ruleName: string;
+    /**
+     * Validates a Kanonak document against this rule
+     */
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}

package/dist/object/validation/rules/document/index.js

@@ -0,0 +1 @@
+import{KanonakDocument as o}from"../../../../document/models/types";import{OntologyValidationError as r}from"../../../../object/validation/types";export{o as KanonakDocument,r as OntologyValidationError};

package/dist/object/validation/rules/document/types.d.ts

@@ -0,0 +1,52 @@
+import { KanonakDocument } from '../../../../document/models/types';
+import { IDocumentValidationRule } from '../../../../object/validation/rules/document/index';
+import { OntologyValidationError } from '../../../../object/validation/types';
+/**
+ * Validates that embedded Kanonak objects (nested objects within properties) do NOT have explicit 'type' properties.     Embedded objects automatically infer their type from the parent property's range.     This enforces proper ontology modeling and prevents redundant type declarations.
+ */
+export interface EmbeddedKanonakNoExplicitTypeRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}
+/**
+ * Validates that namespace prefixes with colons are not used in Kanonak YAML.     Kanonak uses dot notation for namespace aliases, not colon notation
+ */
+export interface NamespacePrefixRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}
+/**
+ * Validates that Package declarations have required properties: publisher, version.     This rule applies to documents using the new Package format (type: Package).
+ */
+export interface PackagePropertiesRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}
+/**
+ * Validates that a Kanonak document contains exactly one Package declaration.     The Package entry is identified by having 'type: Package'.
+ */
+export interface PackageRequiredRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}
+/**
+ * Validates that properties use specific types (DatatypeProperty, ObjectProperty, etc.)     rather than generic Property type
+ */
+export interface PropertyTypeSpecificityRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}
+/**
+ * Validates that resource names follow Kanonak naming conventions     Resource names must start with a letter and can only contain letters, numbers, and underscores
+ */
+export interface ResourceNamingRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}
+/**
+ * Validates that all Subject Kanonaks (top-level entities) have an explicit 'type' property.     Subject Kanonaks must declare their type since there is no parent property to infer from.
+ */
+export interface SubjectKanonakTypeRequiredRule extends IDocumentValidationRule {
+    readonly ruleName: string;
+    validate(document: KanonakDocument): Array<OntologyValidationError>;
+}

package/dist/object/validation/rules/repository/index.d.ts

@@ -0,0 +1,19 @@
+import { IKanonakDocumentRepository } from '../../../../document/models/index';
+import { KanonakDocument } from '../../../../document/models/types';
+import { OntologyValidationError } from '../../../../object/validation/types';
+export { IKanonakDocumentRepository };
+export { KanonakDocument };
+export { OntologyValidationError };
+/**
+ * Interface for validation rules that require repository access     to validate external dependencies and imports
+ */
+export interface IRepositoryValidationRule {
+    /**
+     * The name of this validation rule
+     */
+    readonly ruleName: string;
+    /**
+     * Validates a Kanonak document against this rule using repository for external lookups
+     */
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}

package/dist/object/validation/rules/repository/index.js

@@ -0,0 +1 @@
+import{IKanonakDocumentRepository as o}from"../../../../document/models/index";import{KanonakDocument as r}from"../../../../document/models/types";import{OntologyValidationError as t}from"../../../../object/validation/types";export{o as IKanonakDocumentRepository,r as KanonakDocument,t as OntologyValidationError};

package/dist/object/validation/rules/repository/types.d.ts

@@ -0,0 +1,148 @@
+import { IKanonakDocumentRepository } from '../../../../document/models/index';
+import { KanonakDocument } from '../../../../document/models/types';
+import { KanonakUri } from '../../../../object/uris/types';
+import { IRepositoryValidationRule } from '../../../../object/validation/rules/repository/index';
+import { OntologyValidationError } from '../../../../object/validation/types';
+/**
+ * Validates that references to entities or properties are unambiguous.     When multiple imports define the same entity/property name, namespace aliases     MUST be used to disambiguate (e.g., 'people.name' vs 'heroes.name').     When only one source defines an entity, aliases are optional.     Design Philosophy:     - Aliases are document-scoped only (not transitive)     - Aliases are required ONLY when ambiguity exists     - Aliases are optional when references are unambiguous
+ */
+export interface AmbiguousReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that all classes used as entity types are properly defined or imported
+ */
+export interface ClassDefinitionRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Detects circular dependencies in class hierarchies (subClassOf chains)
+ */
+export interface ClassHierarchyCycleRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that properties used on Class and Property definitions are actually defined.     When a class or property definition uses a property (e.g., "icon: ✅"),     this rule ensures that the property "icon" is defined as an ObjectProperty     or DatatypeProperty either locally or in imported namespaces.
+ */
+export interface DefinitionPropertyReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+export interface ImportErrorDetails {
+    message: string;
+    suggestion: string;
+    expectedValue: string;
+}
+/**
+ * Validates that all imported namespaces actually exist in the repository     and that version constraints can be satisfied
+ */
+export interface ImportExistenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that properties used in entity instances are actually defined.     When an entity instance uses a property (e.g., "assignedTo: some-agent"),     this rule ensures that the property "assignedTo" is defined as an ObjectProperty     or DatatypeProperty either locally or in imported namespaces.
+ */
+export interface InstancePropertyReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Detects circular dependencies in namespace imports.     Circular dependencies prevent proper package resolution,     so these must be caught during validation.
+ */
+export interface NamespaceImportCycleRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that namespaces for ObjectProperty range classes are imported
+ */
+export interface ObjectPropertyImportRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that ALL ObjectProperty values point to existing entities.     Uses TypeResolver to determine which properties are ObjectProperties (explicit or inferred from range).
+ */
+export interface ObjectPropertyValueValidationRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that properties are only used on instances of their declared domain class.     Ensures properties are used on the correct types (domain validation).
+ */
+export interface PropertyDomainRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Detects circular dependencies in property hierarchies (subPropertyOf chains)
+ */
+export interface PropertyHierarchyCycleRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+export interface PropertyInfo {
+    propertyType: string;
+    range?: string | null | undefined;
+    rangeUri?: KanonakUri | null | undefined;
+}
+/**
+ * Validates that property range references point to valid types.     For ObjectProperty, ensures the range refers to a defined class.     For DatatypeProperty, ensures the range is a valid primitive type.
+ */
+export interface PropertyRangeReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that all property definitions have a 'range' specified.     This is required for type inference and proper semantic validation.
+ */
+export interface PropertyRangeRequiredRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that instance property values match their declared property types and ranges.     Prevents setting complex objects on DatatypeProperties and ensures ObjectProperty values are valid.
+ */
+export interface PropertyValueTypeRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that subClassOf references point to existing classes
+ */
+export interface SubClassOfReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that subPropertyOf references point to existing properties
+ */
+export interface SubPropertyOfReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that there are no ambiguous type references when multiple imported namespaces     define the same type. Suggests using namespace aliases to resolve ambiguity.
+ */
+export interface TypeAmbiguityRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that ObjectProperty instance references (Reference Statements) can be resolved.     Checks that when an entity references another entity via an ObjectProperty,     the referenced entity exists in the current document or imported namespaces.
+ */
+export interface UnresolvedReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that XSD namespace is imported when DatatypeProperty uses XSD types
+ */
+export interface XsdImportRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: KanonakDocument, repository: IKanonakDocumentRepository): Promise<Array<OntologyValidationError>>;
+}

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

@@ -0,0 +1,134 @@
+import { IKanonakDocumentRepository } from '../../document/models/index';
+import { KanonakDocument } from '../../document/models/types';
+import { PropertyMetadata } from '../../object/parsing/types';
+import { ValidationSeverity } from '../../object/validation/enums';
+import { IKanonakObjectValidator } from '../../object/validation/index';
+import { IDocumentValidationRule } from '../../object/validation/rules/document/index';
+import { IRepositoryValidationRule } from '../../object/validation/rules/repository/index';
+/**
+ * Main validator for Kanonak documents at the ontology level
+ */
+export interface KanonakObjectValidator extends IKanonakObjectValidator {
+    /**
+     * Gets or sets whether to include warnings in validation results
+     */
+    includeWarnings: boolean;
+    validateAsync(document: KanonakDocument, repository?: IKanonakDocumentRepository | null): Promise<OntologyValidationResult>;
+    validateYamlAsync(yamlText: string, repository?: IKanonakDocumentRepository | null): Promise<OntologyValidationResult>;
+    /**
+     * Adds a custom document validation rule
+     */
+    addDocumentRule(rule: IDocumentValidationRule): void;
+    /**
+     * Adds a custom repository validation rule
+     */
+    addRepositoryRule(rule: IRepositoryValidationRule): void;
+    /**
+     * Removes a document validation rule by type
+     */
+    removeDocumentRule<T>(): void;
+    /**
+     * Removes a repository validation rule by type
+     */
+    removeRepositoryRule<T>(): void;
+}
+/**
+ * Represents a validation error or warning for ontological issues
+ */
+export interface OntologyValidationError {
+    /**
+     * The type of validation rule that was violated
+     */
+    ruleType: string;
+    /**
+     * Severity level of the issue
+     */
+    severity: ValidationSeverity;
+    /**
+     * Line number in the source file where the error occurred (if available)
+     */
+    lineNumber?: number | null | undefined;
+    /**
+     * Column number in the source file where the error occurred (if available, primarily for parse errors)
+     */
+    column?: number | null | undefined;
+    /**
+     * The resource (class, property, instance) where the error occurred
+     */
+    resourceName?: string | null | undefined;
+    /**
+     * The property within the entity where the error occurred
+     */
+    propertyName?: string | null | undefined;
+    /**
+     * The full path to the property, including nested paths and array indices.     Examples: "hasTasks[0].hasDependency.dependsOn", "flowsThrough[2]", "simpleProperty"     Used for positioning diagnostics in deeply nested structures.
+     */
+    propertyPath?: string | null | undefined;
+    /**
+     * Human-readable error message
+     */
+    message: string;
+    /**
+     * Suggestion for how to fix the issue
+     */
+    suggestion?: string | null | undefined;
+    /**
+     * The actual value that caused the validation error
+     */
+    actualValue?: string | null | undefined;
+    /**
+     * The expected or corrected value
+     */
+    expectedValue?: string | null | undefined;
+    toString(): string;
+}
+/**
+ * Result of ontology validation for a Kanonak document
+ */
+export interface OntologyValidationResult {
+    /**
+     * Whether the validation passed without errors
+     */
+    isValid: boolean;
+    /**
+     * List of validation errors found
+     */
+    errors: Array<OntologyValidationError>;
+    /**
+     * List of validation warnings (non-fatal issues)
+     */
+    warnings: Array<OntologyValidationError>;
+    /**
+     * Total count of issues (errors + warnings)
+     */
+    readonly totalIssues: number;
+}
+/**
+ * Context for validation operations, carrying metadata needed for type inference and validation
+ */
+export interface ValidationContext {
+    /**
+     * The parent property metadata for the current embedded object being validated.     Used to infer the expected type from the property's range.
+     */
+    parentProperty?: PropertyMetadata | null | undefined;
+    /**
+     * All resolved documents in the current validation scope (includes imports)
+     */
+    resolvedDocuments: Array<KanonakDocument>;
+    /**
+     * The current path in the document hierarchy (for error reporting)
+     */
+    currentResourcePath?: string | null | undefined;
+    /**
+     * Gets the inferred type for the current embedded object based on parent property's range
+     */
+    getInferredType(): string | null;
+    /**
+     * Creates a new validation context with updated parent property metadata
+     */
+    withParentProperty(metadata: PropertyMetadata | null): ValidationContext;
+    /**
+     * Creates a new validation context with updated resource path
+     */
+    withPath(path: string): ValidationContext;
+}