@canon-protocol/sdk 8.0.0

package/dist/repositories/FileSystemCanonDocumentRepository.js

@@ -0,0 +1,295 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { CanonParser } from '../parsing/CanonParser.js';
+export class FileSystemCanonDocumentRepository {
+    rootPath;
+    recursive;
+    parser;
+    documentCache;
+    filePathsByIdentifier;
+    cacheInitialized = false;
+    cacheInitPromise = null;
+    parsingErrors = new Map();
+    constructor(rootPath, recursive = true, parser) {
+        if (!rootPath || rootPath.trim().length === 0) {
+            throw new Error('Root path cannot be null or empty');
+        }
+        this.rootPath = path.resolve(rootPath);
+        this.recursive = recursive;
+        this.parser = parser ?? new CanonParser();
+        this.documentCache = new Map();
+        this.filePathsByIdentifier = new Map();
+    }
+    async getAllDocumentsAsync() {
+        await this.ensureCacheInitialized();
+        const uniqueDocuments = new Set(this.documentCache.values());
+        return Array.from(uniqueDocuments);
+    }
+    async getDocumentAsync(identifier) {
+        await this.ensureCacheInitialized();
+        let document = this.documentCache.get(identifier);
+        if (document) {
+            return document;
+        }
+        const fullPath = path.join(this.rootPath, identifier);
+        document = this.documentCache.get(fullPath);
+        if (document) {
+            return document;
+        }
+        for (const ext of ['.can.yml', '.yml', '.yaml']) {
+            if (!identifier.endsWith(ext)) {
+                const withExt = identifier + ext;
+                document = this.documentCache.get(withExt);
+                if (document) {
+                    return document;
+                }
+                const fullWithExt = path.join(this.rootPath, withExt);
+                document = this.documentCache.get(fullWithExt);
+                if (document) {
+                    return document;
+                }
+            }
+        }
+        return null;
+    }
+    async getDocumentsByNamespaceAsync(publisher, package_) {
+        await this.ensureCacheInitialized();
+        const uniqueDocuments = new Set(this.documentCache.values());
+        return Array.from(uniqueDocuments).filter(doc => doc.metadata.namespace_?.toString().includes(publisher) &&
+            doc.metadata.namespace_?.toString().includes(package_));
+    }
+    async getHighestCompatibleVersionAsync(publisher, import_) {
+        await this.ensureCacheInitialized();
+        const uniqueDocuments = new Set(this.documentCache.values());
+        const candidates = Array.from(uniqueDocuments).filter(doc => {
+            const ns = doc.metadata.namespace_?.toString() || '';
+            return ns.includes(publisher) && ns.includes(import_.packageName);
+        });
+        if (candidates.length === 0) {
+            return null;
+        }
+        return candidates[0] || null;
+    }
+    async saveDocumentAsync(document, identifier) {
+        let filePath;
+        const ns = document.metadata.namespace_?.toString();
+        if (ns && ns.includes('@') && ns.includes('/')) {
+            const parts = ns.split('/');
+            const publisher = parts[0];
+            const packageVersion = parts[1];
+            const fileName = packageVersion.replace('@', '@') + '.can.yml';
+            filePath = path.join(this.rootPath, publisher, fileName);
+        }
+        else {
+            filePath = path.join(this.rootPath, identifier);
+            if (!filePath.endsWith('.yml') && !filePath.endsWith('.yaml') && !filePath.endsWith('.can.yml')) {
+                filePath += '.can.yml';
+            }
+        }
+        const directory = path.dirname(filePath);
+        await fs.mkdir(directory, { recursive: true });
+        const yaml = this.parser.save(document);
+        await fs.writeFile(filePath, yaml, 'utf8');
+        if (ns) {
+            this.documentCache.set(ns, document);
+        }
+        this.documentCache.set(filePath, document);
+        const relativePath = path.relative(this.rootPath, filePath);
+        this.documentCache.set(relativePath, document);
+    }
+    async deleteDocumentAsync(identifier) {
+        const document = await this.getDocumentAsync(identifier);
+        if (!document) {
+            return;
+        }
+        const filePathToDelete = this.filePathsByIdentifier.get(identifier);
+        if (!filePathToDelete) {
+            return;
+        }
+        try {
+            await fs.unlink(filePathToDelete);
+        }
+        catch {
+        }
+        const ns = document.metadata.namespace_?.toString();
+        if (ns) {
+            this.documentCache.delete(ns);
+        }
+        this.documentCache.delete(identifier);
+        this.documentCache.delete(filePathToDelete);
+        const relativePath = path.relative(this.rootPath, filePathToDelete);
+        this.documentCache.delete(relativePath);
+    }
+    async clearNamespaceAsync(publisher, package_) {
+        await this.ensureCacheInitialized();
+        const documentsToRemove = [];
+        for (const [key, doc] of this.documentCache.entries()) {
+            const ns = doc.metadata.namespace_?.toString() || '';
+            if (ns.includes(publisher) && ns.includes(package_)) {
+                documentsToRemove.push([key, doc]);
+            }
+        }
+        const publisherDir = path.join(this.rootPath, publisher);
+        try {
+            const files = await fs.readdir(publisherDir);
+            for (const file of files) {
+                if (file.includes(package_) && file.endsWith('.can.yml')) {
+                    await fs.unlink(path.join(publisherDir, file));
+                }
+            }
+        }
+        catch {
+        }
+        for (const [key] of documentsToRemove) {
+            this.documentCache.delete(key);
+        }
+    }
+    async getAllDocumentReferencesAsync() {
+        await this.ensureCacheInitialized();
+        const filePaths = new Set(this.filePathsByIdentifier.values());
+        const references = [];
+        for (const filePath of filePaths) {
+            const uri = `file://${filePath}`;
+            let namespaceIdentifier;
+            for (const [key, doc] of this.documentCache.entries()) {
+                const mappedPath = this.filePathsByIdentifier.get(key);
+                if (mappedPath === filePath && doc.metadata.namespace_) {
+                    namespaceIdentifier = doc.metadata.namespace_.toString();
+                    break;
+                }
+            }
+            const identifier = namespaceIdentifier ?? path.relative(this.rootPath, filePath);
+            const hasParseError = this.parsingErrors.has(filePath);
+            references.push({
+                identifier,
+                uri,
+                hasParseError
+            });
+        }
+        return references;
+    }
+    async getDocumentContentAsync(identifier) {
+        await this.ensureCacheInitialized();
+        let filePath = this.filePathsByIdentifier.get(identifier);
+        if (!filePath) {
+            try {
+                await fs.access(identifier);
+                filePath = identifier;
+            }
+            catch {
+                const fullPath = path.join(this.rootPath, identifier);
+                try {
+                    await fs.access(fullPath);
+                    filePath = fullPath;
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        try {
+            return await fs.readFile(filePath, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async getDocumentUriAsync(identifier) {
+        await this.ensureCacheInitialized();
+        let filePath = this.filePathsByIdentifier.get(identifier);
+        if (!filePath) {
+            try {
+                await fs.access(identifier);
+                filePath = identifier;
+            }
+            catch {
+                const fullPath = path.join(this.rootPath, identifier);
+                try {
+                    await fs.access(fullPath);
+                    filePath = fullPath;
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        return `file://${filePath}`;
+    }
+    async refreshAsync() {
+        this.documentCache.clear();
+        this.filePathsByIdentifier.clear();
+        this.parsingErrors.clear();
+        this.cacheInitialized = false;
+        this.cacheInitPromise = null;
+        await this.ensureCacheInitialized();
+    }
+    async ensureCacheInitialized() {
+        if (this.cacheInitialized) {
+            return;
+        }
+        if (this.cacheInitPromise) {
+            await this.cacheInitPromise;
+            return;
+        }
+        this.cacheInitPromise = this.loadDocuments();
+        await this.cacheInitPromise;
+        this.cacheInitialized = true;
+    }
+    async loadDocuments() {
+        try {
+            await fs.mkdir(this.rootPath, { recursive: true });
+        }
+        catch {
+        }
+        const yamlFiles = await this.findYamlFiles(this.rootPath, this.recursive);
+        const loadTasks = yamlFiles.map(async (filePath) => {
+            try {
+                const content = await fs.readFile(filePath, 'utf8');
+                const document = this.parser.parse(content);
+                return { filePath, document, error: null };
+            }
+            catch (ex) {
+                return { filePath, document: null, error: ex instanceof Error ? ex.message : String(ex) };
+            }
+        });
+        const results = await Promise.all(loadTasks);
+        for (const { filePath, document, error } of results) {
+            const relativePath = path.relative(this.rootPath, filePath);
+            if (document && document.metadata.namespace_) {
+                const namespaceKey = document.metadata.namespace_.toString();
+                this.documentCache.set(namespaceKey, document);
+                this.documentCache.set(filePath, document);
+                this.documentCache.set(relativePath, document);
+                this.filePathsByIdentifier.set(namespaceKey, filePath);
+                this.filePathsByIdentifier.set(filePath, filePath);
+                this.filePathsByIdentifier.set(relativePath, filePath);
+            }
+            else {
+                this.filePathsByIdentifier.set(filePath, filePath);
+                this.filePathsByIdentifier.set(relativePath, filePath);
+            }
+            if (error) {
+                this.parsingErrors.set(filePath, error);
+            }
+        }
+    }
+    async findYamlFiles(dir, recursive) {
+        const files = [];
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory() && recursive) {
+                    const subFiles = await this.findYamlFiles(fullPath, recursive);
+                    files.push(...subFiles);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.can.yml')) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+        }
+        return files;
+    }
+}

package/dist/repositories/HttpCanonDocumentRepository.d.ts

@@ -0,0 +1,24 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument, Import, DocumentReference } from '@canon-protocol/types/document/models/types';
+export declare class HttpCanonDocumentRepository implements ICanonDocumentRepository {
+    private readonly parser;
+    private readonly publisherIndex;
+    private readonly documents;
+    private readonly contentCache;
+    private readonly onFetch;
+    private readonly getFromCache;
+    constructor(options?: {
+        onFetch?: (publisher: string, packageName: string, version: string, content: string) => void;
+        getFromCache?: (publisher: string, packageName: string, version: string) => string | null;
+    });
+    getHighestCompatibleVersionAsync(publisher: string, import_: Import): Promise<CanonDocument | null>;
+    getAllDocumentsAsync(): Promise<CanonDocument[]>;
+    getDocumentAsync(identifier: string): Promise<CanonDocument | null>;
+    getDocumentsByNamespaceAsync(publisher: string, package_: string): Promise<CanonDocument[]>;
+    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>;
+}

package/dist/repositories/HttpCanonDocumentRepository.js

@@ -0,0 +1,79 @@
+import { CanonParser } from '../parsing/CanonParser.js';
+import { PublisherIndex } from './PublisherIndex.js';
+export class HttpCanonDocumentRepository {
+    parser = new CanonParser();
+    publisherIndex = new PublisherIndex();
+    documents = new Map();
+    contentCache = new Map();
+    onFetch;
+    getFromCache;
+    constructor(options) {
+        this.onFetch = options?.onFetch;
+        this.getFromCache = options?.getFromCache;
+    }
+    async getHighestCompatibleVersionAsync(publisher, import_) {
+        const version = await this.publisherIndex.resolveVersion(publisher, import_);
+        if (!version)
+            return null;
+        const key = `${publisher}/${import_.packageName}@${version}`;
+        const cached = this.documents.get(key);
+        if (cached)
+            return cached;
+        if (this.getFromCache) {
+            const cachedContent = this.getFromCache(publisher, import_.packageName, version);
+            if (cachedContent) {
+                const doc = this.parser.parse(cachedContent);
+                this.documents.set(key, doc);
+                this.contentCache.set(key, cachedContent);
+                return doc;
+            }
+        }
+        const url = await this.publisherIndex.getPackageUrl(publisher, import_.packageName, version);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Canon package: ${url} (${response.status} ${response.statusText})`);
+        }
+        const content = await response.text();
+        if (this.onFetch) {
+            this.onFetch(publisher, import_.packageName, version, content);
+        }
+        const doc = this.parser.parse(content);
+        this.documents.set(key, doc);
+        this.contentCache.set(key, content);
+        return doc;
+    }
+    async getAllDocumentsAsync() {
+        return Array.from(this.documents.values());
+    }
+    async getDocumentAsync(identifier) {
+        return this.documents.get(identifier) ?? null;
+    }
+    async getDocumentsByNamespaceAsync(publisher, package_) {
+        return Array.from(this.documents.values()).filter(doc => {
+            const ns = doc.metadata.namespace_;
+            return ns && ns.publisher === publisher && ns.package_ === package_;
+        });
+    }
+    async saveDocumentAsync(_document, _identifier) {
+        throw new Error('HttpCanonDocumentRepository is read-only');
+    }
+    async deleteDocumentAsync(_identifier) {
+        throw new Error('HttpCanonDocumentRepository is read-only');
+    }
+    async clearNamespaceAsync(_publisher, _package) {
+        throw new Error('HttpCanonDocumentRepository is read-only');
+    }
+    async getAllDocumentReferencesAsync() {
+        return [];
+    }
+    async getDocumentContentAsync(identifier) {
+        return this.contentCache.get(identifier) ?? null;
+    }
+    async getDocumentUriAsync(identifier) {
+        const match = identifier.match(/^(.+?)\/(.+?)@(.+)$/);
+        if (!match)
+            return null;
+        const [, publisher, packageName, version] = match;
+        return this.publisherIndex.getPackageUrl(publisher, packageName, version);
+    }
+}

package/dist/repositories/InMemoryCanonDocumentRepository.d.ts

@@ -0,0 +1,23 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument, DocumentReference, Import } from '@canon-protocol/types/document/models/types';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export declare class InMemoryCanonDocumentRepository implements ICanonDocumentRepository {
+    private readonly documents;
+    private readonly documentContents;
+    private readonly parser;
+    constructor(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>;
+    private versionsEqual;
+    private compareVersions;
+    private isCompatibleVersion;
+    private isMajorCompatible;
+}

package/dist/repositories/InMemoryCanonDocumentRepository.js

@@ -0,0 +1,149 @@
+export class InMemoryCanonDocumentRepository {
+    documents = new Map();
+    documentContents = new Map();
+    parser;
+    constructor(parser) {
+        this.parser = parser;
+    }
+    async getAllDocumentsAsync() {
+        return Array.from(this.documents.values());
+    }
+    async getDocumentAsync(identifier) {
+        return this.documents.get(identifier) ?? null;
+    }
+    async getDocumentsByNamespaceAsync(publisher, package_) {
+        const results = [];
+        for (const doc of this.documents.values()) {
+            if (doc.metadata?.namespace_?.publisher === publisher &&
+                doc.metadata?.namespace_?.package_ === package_) {
+                results.push(doc);
+            }
+        }
+        return results;
+    }
+    async getHighestCompatibleVersionAsync(publisher, import_) {
+        const candidates = [];
+        for (const doc of this.documents.values()) {
+            if (doc.metadata?.namespace_?.publisher === publisher &&
+                doc.metadata?.namespace_?.package_ === import_.packageName &&
+                doc.metadata?.namespace_?.version !== undefined) {
+                candidates.push(doc);
+            }
+        }
+        if (candidates.length === 0) {
+            return null;
+        }
+        const compatible = candidates.filter(doc => {
+            const docVersion = doc.metadata.namespace_.version;
+            if (!docVersion)
+                return false;
+            switch (import_.versionOperator) {
+                case 0: // VersionOperator.Exact
+                    return this.versionsEqual(docVersion, import_.version);
+                case 1: // VersionOperator.Compatible (~)
+                    return this.isCompatibleVersion(docVersion, import_.version);
+                case 2: // VersionOperator.Major (^)
+                    return this.isMajorCompatible(docVersion, import_.version);
+                case 3: // VersionOperator.Any (>=)
+                    return this.compareVersions(docVersion, import_.minVersion) >= 0;
+                default:
+                    return false;
+            }
+        });
+        if (compatible.length === 0) {
+            return null;
+        }
+        compatible.sort((a, b) => {
+            const versionA = a.metadata.namespace_.version;
+            const versionB = b.metadata.namespace_.version;
+            if (!versionA && !versionB)
+                return 0;
+            if (!versionA)
+                return 1;
+            if (!versionB)
+                return -1;
+            return this.compareVersions(versionB, versionA); // Descending order
+        });
+        return compatible[0];
+    }
+    async saveDocumentAsync(document, identifier) {
+        this.documents.set(identifier, document);
+        const content = this.parser.save(document);
+        this.documentContents.set(identifier, content);
+    }
+    async deleteDocumentAsync(identifier) {
+        this.documents.delete(identifier);
+        this.documentContents.delete(identifier);
+    }
+    async clearNamespaceAsync(publisher, package_) {
+        const keysToRemove = [];
+        for (const [key, doc] of this.documents.entries()) {
+            if (doc.metadata?.namespace_?.publisher === publisher &&
+                doc.metadata?.namespace_?.package_ === package_) {
+                keysToRemove.push(key);
+            }
+        }
+        for (const key of keysToRemove) {
+            this.documents.delete(key);
+            this.documentContents.delete(key);
+        }
+    }
+    async getAllDocumentReferencesAsync() {
+        const references = [];
+        for (const doc of this.documents.values()) {
+            if (doc.metadata?.namespace_) {
+                references.push({
+                    identifier: doc.metadata.namespace_.toString(),
+                    uri: `canon://${doc.metadata.namespace_}`,
+                    hasParseError: false // In-memory documents are always valid
+                });
+            }
+        }
+        return references;
+    }
+    async getDocumentContentAsync(identifier) {
+        const storedContent = this.documentContents.get(identifier);
+        if (storedContent !== undefined) {
+            return storedContent;
+        }
+        const document = this.documents.get(identifier);
+        if (document !== undefined) {
+            return this.parser.save(document);
+        }
+        return null;
+    }
+    async getDocumentUriAsync(identifier) {
+        const document = this.documents.get(identifier);
+        if (!document) {
+            return null;
+        }
+        if (document.metadata?.namespace_) {
+            return `canon://${document.metadata.namespace_}`;
+        }
+        return `canon://${identifier}`;
+    }
+    versionsEqual(a, b) {
+        return a.major === b.major && a.minor === b.minor && a.patch === b.patch;
+    }
+    compareVersions(a, b) {
+        if (a.major !== b.major)
+            return a.major - b.major;
+        if (a.minor !== b.minor)
+            return a.minor - b.minor;
+        return a.patch - b.patch;
+    }
+    isCompatibleVersion(docVersion, requiredVersion) {
+        return this.compareVersions(docVersion, requiredVersion) >= 0 &&
+            docVersion.major === requiredVersion.major &&
+            docVersion.minor === requiredVersion.minor;
+    }
+    isMajorCompatible(docVersion, requiredVersion) {
+        if (requiredVersion.major === 0) {
+            return this.compareVersions(docVersion, requiredVersion) >= 0 &&
+                docVersion.major === 0 &&
+                docVersion.minor === requiredVersion.minor;
+        }
+        return this.compareVersions(docVersion, requiredVersion) >= 0 &&
+            docVersion.major === requiredVersion.major;
+    }
+}

package/dist/repositories/PublisherConfig.d.ts

@@ -0,0 +1,12 @@
+export interface PublisherConfig {
+    version: number;
+    index?: string;
+    package?: string;
+}
+export declare class PublisherConfigResolver {
+    private readonly cache;
+    getConfig(publisher: string): Promise<PublisherConfig>;
+    private fetchConfig;
+    resolveIndexUrl(publisher: string, config: PublisherConfig): string;
+    resolvePackageUrl(publisher: string, packageName: string, version: string, config: PublisherConfig): string;
+}

package/dist/repositories/PublisherConfig.js

@@ -0,0 +1,62 @@
+const DEFAULT_INDEX_TEMPLATE = 'https://{publisher}/index.txt';
+const DEFAULT_PACKAGE_TEMPLATE = 'https://{publisher}/{package}/{version}.can.yml';
+const DEFAULT_CONFIG = { version: 1 };
+export class PublisherConfigResolver {
+    cache = new Map();
+    async getConfig(publisher) {
+        const cached = this.cache.get(publisher);
+        if (cached)
+            return cached;
+        const config = await this.fetchConfig(publisher);
+        this.cache.set(publisher, config);
+        return config;
+    }
+    async fetchConfig(publisher) {
+        const url = `https://${publisher}/.well-known/canon.json`;
+        let response;
+        try {
+            response = await fetch(url);
+        }
+        catch {
+            // Network error (DNS failure, unreachable, etc.) — fall back to defaults
+            return DEFAULT_CONFIG;
+        }
+        if (response.status === 404) {
+            return DEFAULT_CONFIG;
+        }
+        if (!response.ok) {
+            throw new Error(`Failed to fetch publisher config: ${url} (${response.status} ${response.statusText})`);
+        }
+        const json = await response.json();
+        if (typeof json.version !== 'number') {
+            throw new Error(`Invalid publisher config at ${url}: missing or invalid "version" field`);
+        }
+        const config = { version: json.version };
+        if (typeof json.index === 'string') {
+            config.index = json.index;
+        }
+        if (typeof json.package === 'string') {
+            config.package = json.package;
+        }
+        return config;
+    }
+    resolveIndexUrl(publisher, config) {
+        const template = config.index ?? DEFAULT_INDEX_TEMPLATE;
+        return resolveTemplate(template, { publisher });
+    }
+    resolvePackageUrl(publisher, packageName, version, config) {
+        const template = config.package ?? DEFAULT_PACKAGE_TEMPLATE;
+        return resolveTemplate(template, { publisher, package: packageName, version });
+    }
+}
+function resolveTemplate(template, vars) {
+    let result = template;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{${key}}`, value);
+    }
+    const unresolved = result.match(/\{[a-z]+\}/);
+    if (unresolved) {
+        throw new Error(`Unresolved variable ${unresolved[0]} in URL template: ${template}`);
+    }
+    return result;
+}

package/dist/repositories/PublisherIndex.d.ts

@@ -0,0 +1,20 @@
+import type { Import } from '@canon-protocol/types/document/models/types';
+import { PublisherConfigResolver } from './PublisherConfig.js';
+export declare class PublisherIndex {
+    private readonly indexCache;
+    private readonly configResolver;
+    constructor(configResolver?: PublisherConfigResolver);
+    resolveVersion(publisher: string, import_: Import): Promise<string | null>;
+    getHighestVersion(publisher: string, packageName: string): Promise<string | null>;
+    getPackageUrl(publisher: string, packageName: string, version: string): Promise<string>;
+    private getPackageVersions;
+    private fetchIndex;
+    static parseIndex(text: string): Map<string, string[]>;
+    private isVersionCompatible;
+    static parseVersion(str: string): {
+        major: number;
+        minor: number;
+        patch: number;
+    } | null;
+    private compareVersionStrings;
+}