@canon-protocol/sdk 8.0.0

package/dist/parsing/CanonParser.js

@@ -0,0 +1,457 @@
+import * as yaml from 'js-yaml';
+export class CanonParser {
+    parse(yamlText) {
+        const result = this.parseWithErrors(yamlText);
+        if (!result.isValid) {
+            const firstError = result.errors[0];
+            throw new Error(`YAML parse error at line ${firstError.line}, column ${firstError.column}: ${firstError.message}`);
+        }
+        return result.document;
+    }
+    parseWithErrors(yamlText) {
+        const errors = [];
+        let document = undefined;
+        try {
+            yamlText = yamlText.replace(/^\uFEFF/, '');
+            const rawData = yaml.load(yamlText);
+            if (!rawData || typeof rawData !== 'object') {
+                document = {
+                    metadata: this.createEmptyMetadata(),
+                    body: {},
+                    toString: () => 'CanonDocument(empty)'
+                };
+                return { document, errors, isValid: true };
+            }
+            const metadata = this.extractMetadata(rawData);
+            const body = this.extractBody(rawData, metadata);
+            document = {
+                metadata,
+                body,
+                toString: function () {
+                    return this.metadata.namespace_
+                        ? `CanonDocument(${this.metadata.namespace_.publisher}/${this.metadata.namespace_.package_})`
+                        : 'CanonDocument(no namespace)';
+                }
+            };
+            return { document, errors, isValid: true };
+        }
+        catch (error) {
+            const err = error;
+            const parseError = {
+                message: err.message || 'Unknown parse error',
+                line: err.mark?.line ?? 0,
+                column: err.mark?.column ?? 0,
+                errorType: err.name === 'YAMLException' ? 'SyntaxError' : 'Unknown',
+                toString: () => `${err.name === 'YAMLException' ? 'SyntaxError' : 'Unknown'} at line ${err.mark?.line ?? 0}: ${err.message || 'Unknown parse error'}`
+            };
+            errors.push(parseError);
+            return { document: undefined, errors, isValid: false };
+        }
+    }
+    save(document) {
+        const output = {};
+        if (document.metadata.namespace_) {
+            const ns = document.metadata.namespace_;
+            const packageEntry = {
+                type: 'Package',
+                publisher: ns.publisher
+            };
+            if (ns.version) {
+                packageEntry.version = `${ns.version.major}.${ns.version.minor}.${ns.version.patch}`;
+            }
+            if (document.metadata.imports) {
+                packageEntry.imports = this.serializeImports(document.metadata.imports);
+            }
+            output[ns.package_] = packageEntry;
+        }
+        Object.assign(output, document.body);
+        return yaml.dump(output, {
+            indent: 2,
+            noRefs: true,
+            sortKeys: false
+        });
+    }
+    createEmptyMetadata() {
+        return {
+            get allImports() {
+                return [];
+            }
+        };
+    }
+    addAllImportsGetter(metadata) {
+        const imports = metadata.imports;
+        Object.defineProperty(metadata, 'allImports', {
+            get: function () {
+                if (!imports)
+                    return [];
+                const result = [];
+                for (const importList of Object.values(imports)) {
+                    result.push(...importList);
+                }
+                return result;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return metadata;
+    }
+    createVersion(major, minor, patch) {
+        const version = {
+            major,
+            minor,
+            patch,
+            toString: () => `${major}.${minor}.${patch}`,
+            equals: (obj) => {
+                if (!obj || typeof obj !== 'object')
+                    return false;
+                return obj.major === major && obj.minor === minor && obj.patch === patch;
+            },
+            getHashCode: () => {
+                return (major << 20) | (minor << 10) | patch;
+            },
+            compareTo: (other) => {
+                if (major !== other.major)
+                    return major - other.major;
+                if (minor !== other.minor)
+                    return minor - other.minor;
+                return patch - other.patch;
+            }
+        };
+        return version;
+    }
+    extractMetadata(rawData) {
+        const metadata = this.createEmptyMetadata();
+        for (const [key, value] of Object.entries(rawData)) {
+            if (value && typeof value === 'object' && value.type === 'Package') {
+                metadata.type_ = 'Package';
+                const packageName = key;
+                const publisher = value.publisher;
+                const version = value.version ? this.parseVersion(value.version) : undefined;
+                if (publisher && packageName) {
+                    metadata.namespace_ = {
+                        publisher,
+                        package_: packageName,
+                        version,
+                        toString: function () {
+                            return `${this.publisher}/${this.package_}@${this.version?.major ?? 1}.${this.version?.minor ?? 0}.${this.version?.patch ?? 0}`;
+                        },
+                        equals: (obj) => {
+                            if (!obj || typeof obj !== 'object')
+                                return false;
+                            return obj.publisher === publisher && obj.package_ === packageName &&
+                                (!version || !obj.version || version.equals(obj.version));
+                        },
+                        getHashCode: () => {
+                            let hash = 0;
+                            for (let i = 0; i < publisher.length; i++)
+                                hash = ((hash << 5) - hash) + publisher.charCodeAt(i);
+                            for (let i = 0; i < packageName.length; i++)
+                                hash = ((hash << 5) - hash) + packageName.charCodeAt(i);
+                            return hash | 0;
+                        }
+                    };
+                }
+                if (value.imports && Array.isArray(value.imports)) {
+                    metadata.imports = this.parseImportsV3(value.imports);
+                }
+                return this.addAllImportsGetter(metadata);
+            }
+        }
+        if (rawData.canon && typeof rawData.canon === 'object') {
+            const canonSection = rawData.canon;
+            if (canonSection.publisher || canonSection.package || canonSection.version) {
+                metadata.namespace_ = this.parseNamespace(canonSection);
+            }
+            if (canonSection.imports && typeof canonSection.imports === 'object') {
+                metadata.imports = this.parseImportsLegacy(canonSection.imports);
+            }
+            return this.addAllImportsGetter(metadata);
+        }
+        return metadata;
+    }
+    extractBody(rawData, metadata) {
+        const body = {};
+        let packageEntryKey;
+        for (const [key, value] of Object.entries(rawData)) {
+            if (value && typeof value === 'object' && value.type === 'Package') {
+                packageEntryKey = key;
+                break;
+            }
+        }
+        for (const [key, value] of Object.entries(rawData)) {
+            if (key !== packageEntryKey && key !== 'canon' && key !== 'namespace' && key !== 'imports') {
+                body[key] = value;
+            }
+        }
+        return body;
+    }
+    parseNamespace(ns) {
+        if (typeof ns === 'string') {
+            const match = ns.match(/^([^/]+)\/([^@]+)(?:@(.+))?$/);
+            if (match) {
+                const version = match[3] ? this.parseVersion(match[3]) : this.createVersion(1, 0, 0);
+                return {
+                    publisher: match[1],
+                    package_: match[2],
+                    version,
+                    toString: () => ns,
+                    equals: (obj) => {
+                        if (!obj || typeof obj !== 'object')
+                            return false;
+                        return obj.publisher === match[1] && obj.package_ === match[2] &&
+                            (!version || !obj.version || version.equals(obj.version));
+                    },
+                    getHashCode: () => {
+                        let hash = 0;
+                        for (let i = 0; i < match[1].length; i++)
+                            hash = ((hash << 5) - hash) + match[1].charCodeAt(i);
+                        for (let i = 0; i < match[2].length; i++)
+                            hash = ((hash << 5) - hash) + match[2].charCodeAt(i);
+                        return hash | 0;
+                    }
+                };
+            }
+        }
+        const publisher = ns.publisher || '';
+        const package_ = ns.package || '';
+        const version = ns.version ? this.parseVersion(ns.version) : this.createVersion(1, 0, 0);
+        return {
+            publisher,
+            package_,
+            version,
+            toString: function () {
+                return `${this.publisher}/${this.package_}@${this.version?.major ?? 1}.${this.version?.minor ?? 0}.${this.version?.patch ?? 0}`;
+            },
+            equals: (obj) => {
+                if (!obj || typeof obj !== 'object')
+                    return false;
+                return obj.publisher === publisher && obj.package_ === package_ &&
+                    (!version || !obj.version || version.equals(obj.version));
+            },
+            getHashCode: () => {
+                let hash = 0;
+                for (let i = 0; i < publisher.length; i++)
+                    hash = ((hash << 5) - hash) + publisher.charCodeAt(i);
+                for (let i = 0; i < package_.length; i++)
+                    hash = ((hash << 5) - hash) + package_.charCodeAt(i);
+                return hash | 0;
+            }
+        };
+    }
+    parseVersion(version) {
+        if (typeof version === 'string') {
+            const parts = version.split('.').map(Number);
+            return this.createVersion(parts[0] || 0, parts[1] || 0, parts[2] || 0);
+        }
+        return this.createVersion(version.major || 0, version.minor || 0, version.patch || 0);
+    }
+    parseImportsV3(imports) {
+        const result = {};
+        for (const item of imports) {
+            if (!item || typeof item !== 'object')
+                continue;
+            if (item.packages && Array.isArray(item.packages)) {
+                const publisher = item.publisher;
+                if (!publisher) {
+                    throw new Error("PublisherImport requires 'publisher' property");
+                }
+                if (!result[publisher]) {
+                    result[publisher] = [];
+                }
+                for (const pkgItem of item.packages) {
+                    if (!pkgItem || typeof pkgItem !== 'object')
+                        continue;
+                    const imp = this.parseImportFromEmbeddedObject(pkgItem, publisher);
+                    result[publisher].push(imp);
+                }
+            }
+            else {
+                const imp = this.parseImportFromEmbeddedObject(item, item.publisher);
+                const publisher = imp.publisher || '';
+                if (!result[publisher]) {
+                    result[publisher] = [];
+                }
+                result[publisher].push(imp);
+            }
+        }
+        return result;
+    }
+    parseImportsLegacy(imports) {
+        const result = {};
+        for (const [publisher, packages] of Object.entries(imports)) {
+            if (!Array.isArray(packages))
+                continue;
+            result[publisher] = packages.map(pkg => this.parseImport(pkg, publisher));
+        }
+        return result;
+    }
+    parseImportFromEmbeddedObject(obj, publisher) {
+        const packageName = obj.package;
+        if (!packageName) {
+            throw new Error("Import requires 'package' property");
+        }
+        const match = obj.match;
+        if (!match) {
+            throw new Error("Import requires 'match' property");
+        }
+        const versionStr = obj.version;
+        if (!versionStr) {
+            throw new Error("Import requires 'version' property");
+        }
+        const version = this.parseVersion(versionStr);
+        const versionOperator = this.parseVersionOperator(match);
+        const maxVersion = this.calculateMaxVersion(match, version);
+        const alias = obj.alias;
+        return {
+            package_: `${packageName} ${match} ${version.toString()}`,
+            publisher,
+            packageName,
+            versionOperator,
+            version,
+            alias,
+            minVersion: version,
+            maxVersion,
+            toEmbeddedObject: () => {
+                const result = {
+                    package: packageName,
+                    match,
+                    version: version.toString()
+                };
+                if (alias)
+                    result.alias = alias;
+                return result;
+            },
+            toString: () => alias
+                ? `${packageName} ${match} ${version.toString()} as ${alias}`
+                : `${packageName} ${match} ${version.toString()}`
+        };
+    }
+    parseImport(pkg, publisher) {
+        if (typeof pkg === 'string') {
+            const aliasMatch = pkg.match(/^(.+?)\s*([~^=*])\s*(\S+)\s+as\s+(\S+)$/);
+            if (aliasMatch) {
+                const packageName = aliasMatch[1].trim();
+                const operator = aliasMatch[2];
+                const version = this.parseVersion(aliasMatch[3].trim());
+                const alias = aliasMatch[4].trim();
+                const versionOperator = this.parseVersionOperator(operator);
+                const maxVersion = this.calculateMaxVersion(operator, version);
+                return {
+                    package_: pkg,
+                    publisher,
+                    packageName,
+                    versionOperator,
+                    version,
+                    alias,
+                    minVersion: version,
+                    maxVersion,
+                    toEmbeddedObject: () => {
+                        const result = {
+                            package: packageName,
+                            match: operator,
+                            version: version.toString()
+                        };
+                        if (alias)
+                            result.alias = alias;
+                        return result;
+                    },
+                    toString: () => `${packageName} ${operator} ${version.toString()} as ${alias}`
+                };
+            }
+            const match = pkg.match(/^(.+?)\s*([~^=*])\s*(.+)$/);
+            if (match) {
+                const packageName = match[1].trim();
+                const operator = match[2];
+                const version = this.parseVersion(match[3].trim());
+                const versionOperator = this.parseVersionOperator(operator);
+                const maxVersion = this.calculateMaxVersion(operator, version);
+                return {
+                    package_: pkg,
+                    publisher,
+                    packageName,
+                    versionOperator,
+                    version,
+                    alias: undefined,
+                    minVersion: version,
+                    maxVersion,
+                    toEmbeddedObject: () => ({
+                        package: packageName,
+                        match: operator,
+                        version: version.toString()
+                    }),
+                    toString: () => `${packageName} ${operator} ${version.toString()}`
+                };
+            }
+        }
+        const versionOperator = this.parseVersionOperator(pkg.operator || '~');
+        const version = this.parseVersion(pkg.version || '1.0.0');
+        const packageName = pkg.packageName || pkg.package || '';
+        const operator = ['=', '~', '^', '*'][versionOperator];
+        const maxVersion = this.calculateMaxVersion(pkg.operator || '~', version);
+        return {
+            package_: pkg.package || '',
+            publisher,
+            packageName,
+            versionOperator,
+            version,
+            alias: pkg.alias,
+            minVersion: version,
+            maxVersion,
+            toEmbeddedObject: () => {
+                const result = {
+                    package: packageName,
+                    match: operator,
+                    version: version.toString()
+                };
+                if (pkg.alias)
+                    result.alias = pkg.alias;
+                return result;
+            },
+            toString: () => `${packageName} ${operator} ${version.toString()}`
+        };
+    }
+    parseVersionOperator(op) {
+        switch (op) {
+            case '=': return 0; // Exact
+            case '~': return 1; // Compatible
+            case '^': return 2; // Major
+            case '*': return 3; // Any
+            default: return 1; // Default to Compatible
+        }
+    }
+    calculateMaxVersion(operator, version) {
+        switch (operator) {
+            case '~': // Compatible: < next minor
+                return this.createVersion(version.major, version.minor + 1, 0);
+            case '^': // Major: < next major (or next minor for 0.x)
+                if (version.major === 0) {
+                    return this.createVersion(0, version.minor + 1, 0);
+                }
+                return this.createVersion(version.major + 1, 0, 0);
+            default:
+                return this.createVersion(999, 999, 999);
+        }
+    }
+    serializeImports(imports) {
+        const result = [];
+        for (const [publisher, importList] of Object.entries(imports)) {
+            const publisherImport = {
+                publisher,
+                packages: importList.map(imp => {
+                    const operator = ['=', '~', '^', '*'][imp.versionOperator];
+                    const pkgObj = {
+                        package: imp.packageName,
+                        match: operator,
+                        version: `${imp.version.major}.${imp.version.minor}.${imp.version.patch}`
+                    };
+                    if (imp.alias) {
+                        pkgObj.alias = imp.alias;
+                    }
+                    return pkgObj;
+                })
+            };
+            result.push(publisherImport);
+        }
+        return result;
+    }
+}

package/dist/parsing/ICanonObjectParser.d.ts

@@ -0,0 +1,7 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { Canon } from '../canons/Canon.js';
+export interface ICanonObjectParser {
+    parseCanons(documentRepository: ICanonDocumentRepository): Promise<Canon[]>;
+    saveCanons(canons: Canon[], documentRepository: ICanonDocumentRepository): Promise<void>;
+    serializeToYaml(canons: Canon[], namespaceString: string): Promise<string>;
+}

package/dist/parsing/ICanonObjectParser.js

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

package/dist/parsing/PropertyMetadata.d.ts

@@ -0,0 +1,7 @@
+export declare class PropertyMetadata {
+    propertyUri: string;
+    propertyType: 'DatatypeProperty' | 'ObjectProperty';
+    range?: string;
+    isImported: boolean;
+    definedInNamespace: string;
+}

package/dist/parsing/PropertyMetadata.js

@@ -0,0 +1,7 @@
+export class PropertyMetadata {
+    propertyUri;
+    propertyType;
+    range;
+    isImported;
+    definedInNamespace;
+}

package/dist/parsing/index.d.ts

@@ -0,0 +1,6 @@
+export { CanonParser } from './CanonParser.js';
+export { CanonObjectParser } from './CanonObjectParser.js';
+export type { ICanonObjectParser } from './ICanonObjectParser.js';
+export { PropertyMetadata } from './PropertyMetadata.js';
+export type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export type { CanonDocument, CanonMetadata, Namespace, Import, Version, ParseResult, ParseError } from '@canon-protocol/types/document/models/types';

package/dist/parsing/index.js

@@ -0,0 +1,3 @@
+export { CanonParser } from './CanonParser.js';
+export { CanonObjectParser } from './CanonObjectParser.js';
+export { PropertyMetadata } from './PropertyMetadata.js';

package/dist/repositories/CompositeCanonDocumentRepository.d.ts

@@ -0,0 +1,28 @@
+import type { CanonDocument, Import, DocumentReference } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+import { FileSystemCanonDocumentRepository } from './FileSystemCanonDocumentRepository.js';
+export declare enum DocumentLocation {
+    NotFound = "NotFound",
+    Workspace = "Workspace",
+    Cache = "Cache"
+}
+export declare class CompositeCanonDocumentRepository implements ICanonDocumentRepository {
+    private readonly cache;
+    private readonly workspace;
+    constructor(cachePath: string, workspacePath: string, parser?: ICanonParser);
+    getCache(): FileSystemCanonDocumentRepository;
+    getWorkspace(): FileSystemCanonDocumentRepository;
+    getAllDocumentsAsync(): Promise<CanonDocument[]>;
+    getDocumentAsync(identifier: string): Promise<CanonDocument | null>;
+    getDocumentsByNamespaceAsync(publisher: string, packageName: string): Promise<CanonDocument[]>;
+    getHighestCompatibleVersionAsync(publisher: string, import_: Import): Promise<CanonDocument | null>;
+    saveDocumentAsync(document: CanonDocument, identifier: string): Promise<void>;
+    saveToCacheAsync(document: CanonDocument, identifier: string): Promise<void>;
+    deleteDocumentAsync(identifier: string): Promise<void>;
+    clearNamespaceAsync(publisher: string, packageName: string): Promise<void>;
+    getAllDocumentReferencesAsync(): Promise<DocumentReference[]>;
+    getDocumentContentAsync(identifier: string): Promise<string | null>;
+    getDocumentUriAsync(identifier: string): Promise<string | null>;
+    getDocumentLocationAsync(identifier: string): Promise<DocumentLocation>;
+}

package/dist/repositories/CompositeCanonDocumentRepository.js

@@ -0,0 +1,125 @@
+import { FileSystemCanonDocumentRepository } from './FileSystemCanonDocumentRepository.js';
+import { CanonParser } from '../parsing/CanonParser.js';
+import * as fs from 'fs';
+export var DocumentLocation;
+(function (DocumentLocation) {
+    DocumentLocation["NotFound"] = "NotFound";
+    DocumentLocation["Workspace"] = "Workspace";
+    DocumentLocation["Cache"] = "Cache";
+})(DocumentLocation || (DocumentLocation = {}));
+export class CompositeCanonDocumentRepository {
+    cache;
+    workspace;
+    constructor(cachePath, workspacePath, parser) {
+        const canonParser = parser ?? new CanonParser();
+        if (!fs.existsSync(cachePath)) {
+            fs.mkdirSync(cachePath, { recursive: true });
+        }
+        if (!fs.existsSync(workspacePath)) {
+            fs.mkdirSync(workspacePath, { recursive: true });
+        }
+        this.cache = new FileSystemCanonDocumentRepository(cachePath, true, canonParser);
+        this.workspace = new FileSystemCanonDocumentRepository(workspacePath, true, canonParser);
+    }
+    getCache() {
+        return this.cache;
+    }
+    getWorkspace() {
+        return this.workspace;
+    }
+    async getAllDocumentsAsync() {
+        const workspaceDocs = await this.workspace.getAllDocumentsAsync();
+        const cacheDocs = await this.cache.getAllDocumentsAsync();
+        const allDocs = new Map();
+        for (const doc of cacheDocs) {
+            if (doc.metadata.namespace_) {
+                const key = doc.metadata.namespace_.toString();
+                allDocs.set(key, doc);
+            }
+        }
+        for (const doc of workspaceDocs) {
+            if (doc.metadata.namespace_) {
+                const key = doc.metadata.namespace_.toString();
+                allDocs.set(key, doc);
+            }
+        }
+        return Array.from(allDocs.values());
+    }
+    async getDocumentAsync(identifier) {
+        const doc = await this.workspace.getDocumentAsync(identifier);
+        if (doc) {
+            return doc;
+        }
+        return await this.cache.getDocumentAsync(identifier);
+    }
+    async getDocumentsByNamespaceAsync(publisher, packageName) {
+        const workspaceDocs = await this.workspace.getDocumentsByNamespaceAsync(publisher, packageName);
+        const cacheDocs = await this.cache.getDocumentsByNamespaceAsync(publisher, packageName);
+        const allDocs = new Map();
+        for (const doc of cacheDocs) {
+            if (doc.metadata.namespace_?.version) {
+                const key = doc.metadata.namespace_.version.toString();
+                allDocs.set(key, doc);
+            }
+        }
+        for (const doc of workspaceDocs) {
+            if (doc.metadata.namespace_?.version) {
+                const key = doc.metadata.namespace_.version.toString();
+                allDocs.set(key, doc);
+            }
+        }
+        return Array.from(allDocs.values());
+    }
+    async getHighestCompatibleVersionAsync(publisher, import_) {
+        const workspaceDoc = await this.workspace.getHighestCompatibleVersionAsync(publisher, import_);
+        if (workspaceDoc) {
+            return workspaceDoc;
+        }
+        return await this.cache.getHighestCompatibleVersionAsync(publisher, import_);
+    }
+    async saveDocumentAsync(document, identifier) {
+        await this.workspace.saveDocumentAsync(document, identifier);
+    }
+    async saveToCacheAsync(document, identifier) {
+        await this.cache.saveDocumentAsync(document, identifier);
+    }
+    async deleteDocumentAsync(identifier) {
+        await this.workspace.deleteDocumentAsync(identifier);
+    }
+    async clearNamespaceAsync(publisher, packageName) {
+        await this.workspace.clearNamespaceAsync(publisher, packageName);
+    }
+    async getAllDocumentReferencesAsync() {
+        const workspaceRefs = await this.workspace.getAllDocumentReferencesAsync();
+        const cacheRefs = await this.cache.getAllDocumentReferencesAsync();
+        const allRefs = [];
+        allRefs.push(...workspaceRefs);
+        allRefs.push(...cacheRefs);
+        return allRefs;
+    }
+    async getDocumentContentAsync(identifier) {
+        const content = await this.workspace.getDocumentContentAsync(identifier);
+        if (content) {
+            return content;
+        }
+        return await this.cache.getDocumentContentAsync(identifier);
+    }
+    async getDocumentUriAsync(identifier) {
+        const uri = await this.workspace.getDocumentUriAsync(identifier);
+        if (uri) {
+            return uri;
+        }
+        return await this.cache.getDocumentUriAsync(identifier);
+    }
+    async getDocumentLocationAsync(identifier) {
+        const workspaceDoc = await this.workspace.getDocumentAsync(identifier);
+        if (workspaceDoc) {
+            return DocumentLocation.Workspace;
+        }
+        const cacheDoc = await this.cache.getDocumentAsync(identifier);
+        if (cacheDoc) {
+            return DocumentLocation.Cache;
+        }
+        return DocumentLocation.NotFound;
+    }
+}

package/dist/repositories/FileSystemCanonDocumentRepository.d.ts

@@ -0,0 +1,28 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument, Import, DocumentReference } from '@canon-protocol/types/document/models/types';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export declare class FileSystemCanonDocumentRepository implements ICanonDocumentRepository {
+    private readonly rootPath;
+    private readonly recursive;
+    private readonly parser;
+    private readonly documentCache;
+    private readonly filePathsByIdentifier;
+    private cacheInitialized;
+    private cacheInitPromise;
+    readonly parsingErrors: Map<string, string>;
+    constructor(rootPath: string, recursive?: boolean, parser?: ICanonParser);
+    getAllDocumentsAsync(): Promise<CanonDocument[]>;
+    getDocumentAsync(identifier: string): Promise<CanonDocument | null>;
+    getDocumentsByNamespaceAsync(publisher: string, package_: string): Promise<CanonDocument[]>;
+    getHighestCompatibleVersionAsync(publisher: string, import_: Import): Promise<CanonDocument | null>;
+    saveDocumentAsync(document: CanonDocument, identifier: string): Promise<void>;
+    deleteDocumentAsync(identifier: string): Promise<void>;
+    clearNamespaceAsync(publisher: string, package_: string): Promise<void>;
+    getAllDocumentReferencesAsync(): Promise<DocumentReference[]>;
+    getDocumentContentAsync(identifier: string): Promise<string | null>;
+    getDocumentUriAsync(identifier: string): Promise<string | null>;
+    refreshAsync(): Promise<void>;
+    private ensureCacheInitialized;
+    private loadDocuments;
+    private findYamlFiles;
+}