@canon-protocol/types 8.0.0

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

@@ -0,0 +1,156 @@
+import { CtlDocument } from '../../ctl/models/types';
+import { ResolvedResourceType } from '../../ctl/resolution/enums';
+import { SubjectCanon } from '../../object/canons/types';
+/**
+ * Resolves the complete entity graph for a CTL document.     Recursively resolves all referenced entities and their dependencies,     organizing them into tiers by importance.        Uses ResourceResolver from Canon.Object for proper transitive alias resolution.
+ */
+export interface CtlGraphResolver {
+    /**
+     * Resolves the complete entity graph for a CTL document.
+     */
+    resolveAsync(document: CtlDocument, maxDepth?: number): Promise<ResolvedResourceGraph>;
+}
+/**
+ * A property of a resolved Class entity.
+ */
+export interface ResolvedProperty {
+    /**
+     * The property name.
+     */
+    name: string;
+    /**
+     * The property's range types (supports RDF union types like range: [string, anyURI]).
+     */
+    rangeTypes: Array<string>;
+    /**
+     * The property's domain types (supports multiple domains like domain: [ClassA, ClassB]).
+     */
+    domains: Array<string>;
+    /**
+     * Convenience property for single range type (first in list, or "unknown" if empty).
+     */
+    readonly rangeType: string;
+    /**
+     * Whether this is an object property (reference to another entity).
+     */
+    isObjectProperty: boolean;
+    /**
+     * Whether this property is a collection.
+     */
+    isCollection: boolean;
+    /**
+     * The rdfs:comment or description of this property.
+     */
+    comment?: string | null | undefined;
+}
+/**
+ * A resolved Canon resource with metadata for documentation rendering.
+ */
+export interface ResolvedResource {
+    /**
+     * The resource name (e.g., "Farm", "tableName").
+     */
+    name: string;
+    /**
+     * The full Canon URI (e.g., "canon://spec.farm/models.farming@1.1.0/Farm").
+     */
+    canonUri: string;
+    /**
+     * The parsed SubjectCanon resource (contains all statements/properties).
+     */
+    resource: SubjectCanon;
+    /**
+     * The semantic type of this resource.
+     */
+    resourceType: ResolvedResourceType;
+    /**
+     * Parent class name (for Class entities with subClassOf).
+     */
+    parentClass?: string | null | undefined;
+    /**
+     * Multiple parent classes (for Class entities with multiple inheritance).
+     */
+    parentClasses: Array<string>;
+    /**
+     * The rdfs:comment or description of this entity.
+     */
+    comment?: string | null | undefined;
+    /**
+     * Properties defined on this entity (for Class entities).
+     */
+    properties: Array<ResolvedProperty>;
+    /**
+     * The namespace this entity belongs to.
+     */
+    namespace_: string;
+    /**
+     * The depth at which this entity was resolved (0 = direct reference).
+     */
+    resolutionDepth: number;
+    /**
+     * For Instance resources, the type/class this is an instance of.
+     */
+    instanceOf_?: string | null | undefined;
+}
+/**
+ * Represents a fully resolved entity graph from a CTL document.     Entities are organized into tiers by importance/proximity to the source document.
+ */
+export interface ResolvedResourceGraph {
+    /**
+     * The source file path (if available).
+     */
+    sourceFile?: string | null | undefined;
+    /**
+     * The original markdown content of the CTL document.
+     */
+    originalContent: string;
+    /**
+     * The title extracted from the first H1 heading, if present.
+     */
+    title?: string | null | undefined;
+    /**
+     * Direct references - entities explicitly referenced in the template via can:// links.     These are the most important and appear first in output.
+     */
+    directReferences: Array<ResolvedResource>;
+    /**
+     * Inherited references - parent classes (subClassOf), property ranges, etc.     These are referenced by direct entities but not explicitly in the template.
+     */
+    inheritedReferences: Array<ResolvedResource>;
+    /**
+     * Foundation types - core ontology types (rdf:Class, rdfs:Resource, owl:Thing, etc.).     These form the base of the type hierarchy.
+     */
+    foundationTypes: Array<ResolvedResource>;
+    /**
+     * Total number of resolved resources across all tiers.
+     */
+    readonly totalResourceCount: number;
+    /**
+     * All resolved resources across all tiers (for iteration).
+     */
+    readonly allResources: Array<ResolvedResource>;
+    /**
+     * Maximum depth reached during resolution.
+     */
+    maxDepthReached: number;
+    /**
+     * Whether resolution was truncated due to depth limit.
+     */
+    wasTruncated: boolean;
+    /**
+     * Resources that failed to resolve (for diagnostic purposes).
+     */
+    unresolvedResources: Array<UnresolvedResource>;
+}
+/**
+ * An entity that failed to resolve.
+ */
+export interface UnresolvedResource {
+    /**
+     * The entity name or URI that failed to resolve.
+     */
+    reference: string;
+    /**
+     * The reason for failure.
+     */
+    reason: string;
+}

package/dist/ctl/resolution/types.js

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

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

@@ -0,0 +1,10 @@
+import { CtlDocument, CtlValidationResult } from '../../ctl/models/types';
+/**
+ * Validates CTL documents by resolving all Canon URI references.     CTL only supports entity-level references (Entity and DeepLink URIs).     Package and publisher-level URIs are not supported.
+ */
+export interface CtlValidator {
+    /**
+     * Validates a CTL document by resolving all Canon URI references.
+     */
+    validateAsync(document: CtlDocument): Promise<CtlValidationResult>;
+}

package/dist/ctl/validation/types.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.CTL\Validation\CtlValidator.cs
+// SourceHash: sha256-42749bb4e59250ddc768f7b819f4879f31ac6630b37fe9c037603a5239a73baa
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/document/constants/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Centralized constants for core Canon Protocol package names and identifiers.     All package name references should use these constants for maintainability.
+ */
+export interface CorePackageConstants {
+}

package/dist/document/constants/types.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Constants\CorePackageConstants.cs
+// SourceHash: sha256-9611765721146ac8fd17225b61b74595345a8cfbfe8dcff3fdd4889cb48362b2
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/document/filtering/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Interface for filtering files based on .gitignore rules
+ */
+export interface IGitIgnoreFilter {
+    /**
+     * Checks if a file path should be ignored based on gitignore rules
+     */
+    shouldIgnore(absolutePath: string): boolean;
+    /**
+     * Checks if a directory path should be ignored based on gitignore rules.     Used to skip entire directory trees before traversing them.
+     */
+    shouldIgnoreDirectory(absoluteDirectoryPath: string): boolean;
+}

package/dist/document/filtering/index.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Filtering\IGitIgnoreFilter.cs
+// SourceHash: sha256-aa344789a9cec0636546e34be71710e93530a8a0d8d8b111c87f019d730296c4
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/document/filtering/types.d.ts

@@ -0,0 +1,14 @@
+import { IGitIgnoreFilter } from '../../document/filtering/index';
+/**
+ * Filters files based on .gitignore rules using the MAB.DotIgnore library
+ */
+export interface GitIgnoreFilter extends IGitIgnoreFilter {
+    /**
+     * Checks if a file should be ignored based on the loaded .gitignore rules
+     */
+    shouldIgnore(absolutePath: string): boolean;
+    /**
+     * Checks if a directory should be ignored based on the loaded .gitignore rules.     Used to skip entire directory trees before traversing them.
+     */
+    shouldIgnoreDirectory(absoluteDirectoryPath: string): boolean;
+}

package/dist/document/filtering/types.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Filtering\GitIgnoreFilter.cs
+// SourceHash: sha256-f32af7a28fd3c633051f3583193d8582c3236e03d68ec478ccc18d11f7bc2427
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/document/models/enums.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents the version operator used in import specifications
+ */
+export declare enum VersionOperator {
+    /**
+     * Any version (*) - Accepts any version
+     */
+    Any = 0,
+    /**
+     * Compatible version (~) - Accepts patch and minor updates
+     */
+    Compatible = 1,
+    /**
+     * Major version (^) - Accepts minor and patch updates
+     */
+    Major = 2,
+    /**
+     * Exact version (=) - Requires exact version match
+     */
+    Exact = 3
+}

package/dist/document/models/enums.js

@@ -0,0 +1,26 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Models\VersionOperator.cs
+// SourceHash: sha256-8d43eda1be57ff8cf7ff83b6184ff78ad02e30009a8c9ebbeb16ed011589cb11
+// DO NOT EDIT - changes will be overwritten
+/**
+ * Represents the version operator used in import specifications
+ */
+export var VersionOperator;
+(function (VersionOperator) {
+    /**
+     * Any version (*) - Accepts any version
+     */
+    VersionOperator[VersionOperator["Any"] = 0] = "Any";
+    /**
+     * Compatible version (~) - Accepts patch and minor updates
+     */
+    VersionOperator[VersionOperator["Compatible"] = 1] = "Compatible";
+    /**
+     * Major version (^) - Accepts minor and patch updates
+     */
+    VersionOperator[VersionOperator["Major"] = 2] = "Major";
+    /**
+     * Exact version (=) - Requires exact version match
+     */
+    VersionOperator[VersionOperator["Exact"] = 3] = "Exact";
+})(VersionOperator || (VersionOperator = {}));

package/dist/document/models/index.d.ts

@@ -0,0 +1,47 @@
+import { CanonDocument, DocumentReference, Import } from '../../document/models/types';
+export { CanonDocument, DocumentReference, Import };
+/**
+ * Repository interface for managing Canon documents
+ */
+export interface ICanonDocumentRepository {
+    /**
+     * Loads all Canon documents from the repository
+     */
+    getAllDocumentsAsync(): Promise<Array<CanonDocument>>;
+    /**
+     * Loads a specific Canon document by path or identifier
+     */
+    getDocumentAsync(identifier: string): Promise<CanonDocument | null>;
+    /**
+     * Loads all Canon documents from a specific namespace
+     */
+    getDocumentsByNamespaceAsync(publisher: string, package_: string): Promise<Array<CanonDocument>>;
+    /**
+     * Finds the highest compatible version of a document that matches the import specification
+     */
+    getHighestCompatibleVersionAsync(publisher: string, import_: Import): Promise<CanonDocument | null>;
+    /**
+     * Saves a Canon document to the repository
+     */
+    saveDocumentAsync(document: CanonDocument, identifier: string): Promise<void>;
+    /**
+     * Deletes a Canon document from the repository
+     */
+    deleteDocumentAsync(identifier: string): Promise<void>;
+    /**
+     * Removes all documents from a specific namespace
+     */
+    clearNamespaceAsync(publisher: string, package_: string): Promise<void>;
+    /**
+     * Gets references to all documents in the repository, including documents that failed to parse.     Used for workspace-wide validation to ensure all documents are checked, even those with syntax errors.
+     */
+    getAllDocumentReferencesAsync(): Promise<Array<DocumentReference>>;
+    /**
+     * Gets the raw content of a document by identifier.     This is used for validation and diagnostics where the actual YAML content is needed.
+     */
+    getDocumentContentAsync(identifier: string): Promise<string | null>;
+    /**
+     * Gets the URI for a specific document by identifier.     Used for navigation (go-to-definition) where the target URI is needed.
+     */
+    getDocumentUriAsync(identifier: string): Promise<string | null>;
+}

package/dist/document/models/index.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Models\ICanonDocumentRepository.cs
+// SourceHash: sha256-6fdc69d495e3e615a710d0b4133ce3348719d44fbbc053f94e286858bcd11046
+// DO NOT EDIT - changes will be overwritten
+export {};

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

@@ -0,0 +1,194 @@
+import { VersionOperator } from '../../document/models/enums';
+/**
+ * Represents a Canon document in universal bundle format
+ */
+export interface CanonDocument {
+    metadata: CanonMetadata;
+    body: Record<string, any | null>;
+    toString(): string;
+}
+/**
+ * Metadata for a Canon document (Package declaration)
+ */
+export interface CanonMetadata {
+    /**
+     * The type of the metadata entry. Always "Package".
+     */
+    type_?: string | null | undefined;
+    /**
+     * The namespace of the Canon document (publisher/package/version)
+     */
+    namespace_?: Namespace | null | undefined;
+    /**
+     * Imports with optional namespace aliases.     Key is the publisher (e.g., "canon-protocol.org"), value is list of Import objects.     Imports are stored grouped by publisher for efficient lookup.
+     */
+    imports?: Record<string, Array<Import>> | undefined;
+    /**
+     * Gets all imports as a flat list.
+     */
+    readonly allImports: Array<Import>;
+}
+/**
+ * Reference to a Canon document in a repository, including metadata for validation scenarios.     Used by workspace validators to enumerate all documents, including those with parse errors.
+ */
+export interface DocumentReference {
+    /**
+     * Unique identifier for the document (namespace string or repository-specific ID)
+     */
+    identifier: string;
+    /**
+     * URI for publishing diagnostics (e.g., file:// for local files, http:// for remote, canon:// for API-based)
+     */
+    uri: string;
+    /**
+     * Indicates whether this document failed to parse (e.g., duplicate keys, syntax errors)
+     */
+    hasParseError: boolean;
+}
+/**
+ * Represents an import with optional namespace alias
+ */
+export interface Import {
+    /**
+     * The full package specification (e.g., "classes ~ 1.0.0")     This is computed from the other properties
+     */
+    package_: string;
+    /**
+     * The publisher domain (e.g., "canon-protocol.org")
+     */
+    publisher?: string | null | undefined;
+    /**
+     * The package name without version (e.g., "classes")
+     */
+    packageName: string;
+    /**
+     * The version operator (*, ~, ^, =)
+     */
+    versionOperator: VersionOperator;
+    /**
+     * The semantic version
+     */
+    version: Version;
+    /**
+     * Optional namespace alias for the import (e.g., "cls")
+     */
+    alias?: string | null | undefined;
+    /**
+     * Gets the minimum version allowed by this import specification
+     */
+    readonly minVersion: Version;
+    /**
+     * Gets the maximum version allowed by this import specification
+     */
+    readonly maxVersion: Version;
+    /**
+     * Converts this Import to an embedded object dictionary for serialization
+     */
+    toEmbeddedObject(): Record<string, any>;
+    /**
+     * Returns the string representation of the import
+     */
+    toString(): string;
+}
+/**
+ * Represents a Canon namespace with Publisher, Package, and optional Version components
+ */
+export interface Namespace {
+    /**
+     * The publisher component (e.g., "geography.org", "test")
+     */
+    publisher: string;
+    /**
+     * The package component (e.g., "rivers", "entities")
+     */
+    package_: string;
+    /**
+     * The version component (optional, e.g., "1.0.0")
+     */
+    version?: Version | null | undefined;
+    /**
+     * Returns the string representation of the namespace
+     */
+    toString(): string;
+    /**
+     * Determines whether the specified object is equal to the current namespace
+     */
+    equals(obj: any | null): boolean;
+    /**
+     * Returns the hash code for this namespace
+     */
+    getHashCode(): number;
+}
+/**
+ * Represents a parse-time error with position information
+ */
+export interface ParseError {
+    /**
+     * Line number where error occurred (1-based)
+     */
+    line: number;
+    /**
+     * Column number where error occurred (1-based)
+     */
+    column: number;
+    /**
+     * Human-readable error message
+     */
+    message: string;
+    /**
+     * Type of error (e.g., "DuplicateKey", "SyntaxError", "InvalidYaml")
+     */
+    errorType: string;
+    /**
+     * For duplicate key errors, the name of the duplicate key
+     */
+    keyName?: string | null | undefined;
+    toString(): string;
+}
+/**
+ * Result of parsing a Canon YAML document, including any parse-level errors
+ */
+export interface ParseResult {
+    /**
+     * The parsed Canon document (null if parsing failed)
+     */
+    document?: CanonDocument | null | undefined;
+    /**
+     * List of parse errors encountered
+     */
+    errors: Array<ParseError>;
+    /**
+     * True if parsing succeeded with no errors
+     */
+    readonly isValid: boolean;
+}
+/**
+ * Represents a semantic version with Major, Minor, and Patch components
+ */
+export interface Version {
+    /**
+     * Major version number
+     */
+    major: number;
+    /**
+     * Minor version number
+     */
+    minor: number;
+    /**
+     * Patch version number
+     */
+    patch: number;
+    /**
+     * Returns the string representation of the version
+     */
+    toString(): string;
+    /** C# method 'Equals' has 2 overloads. Using overload with most parameters. */
+    equals(obj: any | null): boolean;
+    getHashCode(): number;
+    compareTo(other: Version): number;
+}
+/**
+ * Helper methods for VersionOperator
+ */
+export interface VersionOperatorExtensions {
+}

package/dist/document/models/types.js

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

package/dist/document/parsing/index.d.ts

@@ -0,0 +1,19 @@
+import { CanonDocument, ParseResult } from '../../document/models/types';
+export { CanonDocument, ParseResult };
+/**
+ * Interface for parsing and saving Canon YAML documents
+ */
+export interface ICanonParser {
+    /**
+     * Parses a Canon YAML document from text
+     */
+    parse(yamlText: string): CanonDocument;
+    /**
+     * Parses a Canon YAML document from text, returning errors instead of throwing
+     */
+    parseWithErrors(yamlText: string): ParseResult;
+    /**
+     * Saves a CanonDocument to YAML format
+     */
+    save(document: CanonDocument): string;
+}

package/dist/document/parsing/index.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Parsing\ICanonParser.cs
+// SourceHash: sha256-2231324bdf79500108ca3f8b2e3d0215283858cfdac31e098153386b7f551ece
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/document/parsing/types.d.ts

@@ -0,0 +1,10 @@
+import { CanonDocument, ParseResult } from '../../document/models/types';
+import { ICanonParser } from '../../document/parsing/index';
+/**
+ * Parser for Canon YAML documents
+ */
+export interface CanonParser extends ICanonParser {
+    parse(yamlText: string): CanonDocument;
+    parseWithErrors(yamlText: string): ParseResult;
+    save(document: CanonDocument): string;
+}

package/dist/document/parsing/types.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Parsing\CanonParser.cs
+// SourceHash: sha256-33ccc509e140f483bf083292e7c64d72f175e16d83f0f1d2611ef0c7e870ee53
+// DO NOT EDIT - changes will be overwritten
+export {};

package/dist/document/repositories/enums.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Indicates where a document is located
+ */
+export declare enum DocumentLocation {
+    /**
+     * Document not found
+     */
+    NotFound = 0,
+    /**
+     * Document is in workspace (user file, should be committed)
+     */
+    Workspace = 1,
+    /**
+     * Document is in cache (downloaded package, gitignored)
+     */
+    Cache = 2
+}

package/dist/document/repositories/enums.js

@@ -0,0 +1,22 @@
+// This file was auto-generated by Canon SDK Transpiler v1.0.0
+// Source: canon-sdk-csharp\Canon.Document\Repositories\CompositeCanonDocumentRepository.cs
+// SourceHash: sha256-52ad39ced6b6f4649b4683acc1593211fa4617663b235ae3a6d3da716c5cbd09
+// DO NOT EDIT - changes will be overwritten
+/**
+ * Indicates where a document is located
+ */
+export var DocumentLocation;
+(function (DocumentLocation) {
+    /**
+     * Document not found
+     */
+    DocumentLocation[DocumentLocation["NotFound"] = 0] = "NotFound";
+    /**
+     * Document is in workspace (user file, should be committed)
+     */
+    DocumentLocation[DocumentLocation["Workspace"] = 1] = "Workspace";
+    /**
+     * Document is in cache (downloaded package, gitignored)
+     */
+    DocumentLocation[DocumentLocation["Cache"] = 2] = "Cache";
+})(DocumentLocation || (DocumentLocation = {}));