@canon-protocol/types 8.0.0

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

@@ -0,0 +1,148 @@
+import { ICanonDocumentRepository } from '../../../../document/models/index';
+import { CanonDocument } from '../../../../document/models/types';
+import { CanonUri } 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Detects circular dependencies in class hierarchies (subClassOf chains)
+ */
+export interface ClassHierarchyCycleRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that namespaces for ObjectProperty range classes are imported
+ */
+export interface ObjectPropertyImportRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Detects circular dependencies in property hierarchies (subPropertyOf chains)
+ */
+export interface PropertyHierarchyCycleRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+export interface PropertyInfo {
+    propertyType: string;
+    range?: string | null | undefined;
+    rangeUri?: CanonUri | 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that subClassOf references point to existing classes
+ */
+export interface SubClassOfReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that subPropertyOf references point to existing properties
+ */
+export interface SubPropertyOfReferenceRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): 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: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}
+/**
+ * Validates that XSD namespace is imported when DatatypeProperty uses XSD types
+ */
+export interface XsdImportRule extends IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<Array<OntologyValidationError>>;
+}

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

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: 19 files in namespace
+// SourceHash: sha256-463f3acf34fe77663a40c80eaebe034d73b8f9c36b71cc1cba448c2919b2eda2
+// DO NOT EDIT - changes will be overwritten
+export {};

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

@@ -0,0 +1,134 @@
+import { ICanonDocumentRepository } from '../../document/models/index';
+import { CanonDocument } from '../../document/models/types';
+import { PropertyMetadata } from '../../object/parsing/types';
+import { ValidationSeverity } from '../../object/validation/enums';
+import { ICanonObjectValidator } from '../../object/validation/index';
+import { IDocumentValidationRule } from '../../object/validation/rules/document/index';
+import { IRepositoryValidationRule } from '../../object/validation/rules/repository/index';
+/**
+ * Main validator for Canon documents at the ontology level
+ */
+export interface CanonObjectValidator extends ICanonObjectValidator {
+    /**
+     * Gets or sets whether to include warnings in validation results
+     */
+    includeWarnings: boolean;
+    validateAsync(document: CanonDocument, repository?: ICanonDocumentRepository | null): Promise<OntologyValidationResult>;
+    validateYamlAsync(yamlText: string, repository?: ICanonDocumentRepository | 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 Canon 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<CanonDocument>;
+    /**
+     * 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;
+}

package/dist/object/validation/types.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: 4 files in namespace
+// SourceHash: sha256-e762aeed53776b88892c27a119fe881322eaf615e290a9b1e688873da0901fe1
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/registry/models/types.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Canon CLI configuration loaded from system and user config files     Supports registry overrides, discovery settings, and enterprise deployments
+ */
+export interface CanonConfiguration {
+    /**
+     * Registry overrides by domain pattern (supports wildcards)
+     */
+    registryOverrides: Record<string, RegistryOverride>;
+    /**
+     * Discovery service settings
+     */
+    discovery: DiscoverySettings;
+    /**
+     * Find registry override for a given domain     Supports exact match and wildcard patterns (*.acme.internal)
+     */
+    getOverride(domain: string): RegistryOverride | null;
+    /**
+     * Merge another configuration into this one     Used to combine system and user configs (user overrides system)
+     */
+    merge(other: CanonConfiguration): void;
+}
+/**
+ * Represents a single locked package entry
+ */
+export interface CanonLockEntry {
+    /**
+     * The resolved version (e.g., "1.0.0")
+     */
+    version: string;
+    /**
+     * The full OCI reference where this package was resolved from     (e.g., "ghcr.io/canon-protocol-org/core-rdf:1.0.1")
+     */
+    resolved: string;
+    /**
+     * Content integrity hash (SHA256 digest from OCI manifest)     Format: "sha256:abc123..."
+     */
+    integrity: string;
+    /**
+     * Direct dependencies of this package (namespace → version)     e.g., {"canon-protocol.org/core-rdfs": "1.0.1", "canon-protocol.org/core-owl": "1.0.1"}
+     */
+    dependencies?: Record<string, string> | undefined;
+    /**
+     * Timestamp when this package was installed
+     */
+    installedAt?: unknown | null | undefined;
+}
+/**
+ * Represents the canon.lock file that locks package versions for reproducible builds.     Similar to package-lock.json (npm) or Cargo.lock (Rust).
+ */
+export interface CanonLockFile {
+    /**
+     * Lock file format version (currently "1")
+     */
+    version: string;
+    /**
+     * Map of package references to resolved package information     Key format: "publisher/package" (e.g., "canon-protocol.org/core-rdf")
+     */
+    packages: Record<string, CanonLockEntry>;
+    /**
+     * Timestamp when this lock file was last updated
+     */
+    lastUpdated?: unknown | null | undefined;
+}
+/**
+ * Represents a Canon package reference that can be resolved from an OCI registry.     Supports multiple formats:     - Short form: "canon-protocol.org/core-rdf" or "canon-protocol.org/core-rdf@1.0.1"     - Full OCI reference: "ghcr.io/canon-protocol-org/core-rdf:1.0.1"
+ */
+export interface CanonPackageReference {
+    /**
+     * The registry hostname (e.g., "ghcr.io", "docker.io", "harbor.company.internal")     If null, the default registry from configuration will be used.
+     */
+    registry?: string | null | undefined;
+    /**
+     * The publisher/organization (e.g., "canon-protocol", "stories")
+     */
+    publisher: string;
+    /**
+     * The package name (e.g., "rdf", "trading")
+     */
+    package_: string;
+    /**
+     * The version or tag (e.g., "1.0.0", "latest")     If null, will resolve to latest or use version from lock file.
+     */
+    version?: string | null | undefined;
+    /**
+     * The original reference string as provided by the user
+     */
+    originalReference: string;
+    /**
+     * Convert to OCI reference format (registry/publisher/package:version)
+     */
+    toOciReference(defaultRegistry?: string): string;
+    /**
+     * Convert to Canon import format (publisher/package@version)
+     */
+    toCanonImport(): string;
+    /**
+     * Get the file path for this package in the .canon/ directory     Format: .canon/publisher/package@version.can.yml
+     */
+    getLocalFilePath(workspaceRoot: string): string;
+    toString(): string;
+}
+/**
+ * Configuration for Canon registry settings (.canonrc or canon.json).     Allows users to customize registry behavior, auth, mirrors, etc.
+ */
+export interface CanonRegistryConfig {
+    /**
+     * Registry configuration options
+     */
+    registries: RegistryConfiguration;
+}
+/**
+ * Configuration for a custom/private registry
+ */
+export interface CustomRegistryConfig {
+    /**
+     * The full URL of the registry     (e.g., "https://harbor.company.internal")
+     */
+    url?: string | null | undefined;
+    /**
+     * Authentication method:     - "docker-config" - use ~/.docker/config.json     - "azure-cli" - use Azure CLI for ACR     - "aws-cli" - use AWS CLI for ECR     - "gcloud-cli" - use Google Cloud CLI for GAR     - "github-token" - use GITHUB_TOKEN environment variable     - "env" - use environment variables (CANON_USERNAME, CANON_PASSWORD)     - "token" - use static token from config
+     */
+    auth: string;
+    /**
+     * Static token (only used if Auth = "token")     Not recommended for sensitive credentials - use credential helpers instead
+     */
+    token?: string | null | undefined;
+    /**
+     * Whether to use HTTPS (default: true)
+     */
+    useHttps: boolean;
+    /**
+     * Whether to skip TLS verification (insecure, for development only)
+     */
+    skipTlsVerify: boolean;
+}
+/**
+ * Discovery service settings
+ */
+export interface DiscoverySettings {
+    /**
+     * Enable/disable .well-known discovery globally     Set to false for air-gapped environments
+     */
+    enabled?: boolean | null | undefined;
+    /**
+     * Timeout for .well-known fetches in seconds
+     */
+    timeout?: number | null | undefined;
+}
+/**
+ * Configuration for publishing packages
+ */
+export interface PublishingConfiguration {
+    /**
+     * Default registry to publish to (e.g., "ghcr.io")
+     */
+    registry?: string | null | undefined;
+    /**
+     * Default namespace/publisher (e.g., "my-org")
+     */
+    namespace_?: string | null | undefined;
+}
+export interface RegistryConfiguration {
+    /**
+     * Default registry to use for package resolution     (e.g., "ghcr.io", "docker.io", "harbor.company.internal")
+     */
+    default_: string;
+    /**
+     * List of mirror registries to try if default fails     (e.g., ["ghcr.io", "docker.io"])
+     */
+    mirrors: Array<string>;
+    /**
+     * Custom registry configurations by hostname     Allows specifying auth methods and URLs for private registries
+     */
+    custom: Record<string, CustomRegistryConfig>;
+    /**
+     * Publishing configuration (where to publish packages)
+     */
+    publishing?: PublishingConfiguration | null | undefined;
+}
+/**
+ * Represents registry discovery metadata from .well-known/canon-registry.can.yml     Enables domain-based publishers to specify where their packages are hosted
+ */
+export interface RegistryMetadata {
+    /**
+     * Discovery protocol version (currently "1")
+     */
+    version: string;
+    /**
+     * OCI registry hostname (e.g., "ghcr.io", "harbor.company.com:5000")
+     */
+    registry: string;
+    /**
+     * Namespace/account on the registry (can contain slashes for nested paths, or be empty)     Examples:     - "username" (GitHub, Docker Hub)     - "project/repo" (Google Artifact Registry)     - "" (Azure ACR, AWS ECR with account in hostname)
+     */
+    namespace_: string;
+    /**
+     * URI scheme for registry connection (default: "https")     Set to "http" for insecure private registries
+     */
+    scheme: string;
+    /**
+     * Cache time-to-live in seconds (default: 3600 = 1 hour)
+     */
+    ttl: number;
+    /**
+     * Optional human-readable description
+     */
+    description?: string | null | undefined;
+    /**
+     * Optional contact URL (e.g., contact form, GitHub issues, support page)
+     */
+    contactUrl?: string | null | undefined;
+    /**
+     * Timestamp when this metadata was cached
+     */
+    cachedAt: unknown;
+    /**
+     * Construct OCI reference from discovered metadata
+     */
+    toOciReference(package_: string, version: string): string;
+    /**
+     * Check if cached metadata is still valid based on TTL
+     */
+    isExpired(): boolean;
+}
+/**
+ * Registry override configuration for a domain pattern
+ */
+export interface RegistryOverride {
+    /**
+     * OCI registry hostname (e.g., "harbor.acme.com")
+     */
+    registry: string;
+    /**
+     * Namespace on the registry (can contain slashes or be empty)
+     */
+    namespace_: string;
+    /**
+     * Skip .well-known discovery and use this override directly     If false, tries .well-known first, falls back to this override
+     */
+    skipDiscovery: boolean;
+    /**
+     * Optional URI scheme (default: https)
+     */
+    scheme: string;
+    /**
+     * Optional TTL override for cached metadata
+     */
+    ttl?: number | null | undefined;
+    /**
+     * Convert to RegistryMetadata for use by discovery service
+     */
+    toMetadata(): RegistryMetadata;
+}

package/dist/registry/models/types.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: 5 files in namespace
+// SourceHash: sha256-54cd9269963eb222405c8ed00b7699d85c4d6a7cd93333efbf7cbf4ef84d2927
+// DO NOT EDIT - changes will be overwritten
+export {};