/**
 * LevelGraph storage adapter
 *
 * Browser-compatible graph storage using LevelGraph (triple store)
 * built on LevelDB/IndexedDB.
 *
 * @packageDocumentation
 */
import type { SkillNode, SkillId, SkillNodeInput, SkillNodeUpdate, PrerequisiteEdge, EdgeId, PrerequisiteEdgeInput, GraphStorage, StorageConfig, ConnectionStatus, ImportResult, GraphExport, GraphStats, Subgraph, SkillQuery } from '../types/index.js';
/**
 * LevelGraph storage adapter.
 *
 * Stores skill graphs using RDF-style triples, compatible with
 * LevelDB (Node.js) and IndexedDB (browser).
 *
 * @example
 * ```typescript
 * import { LevelGraphStorage } from 'learngraph/storage';
 * import levelgraph from 'levelgraph';
 * import level from 'level';
 *
 * // Node.js usage
 * const storage = new LevelGraphStorage();
 * await storage.connect({
 *   backend: 'levelgraph',
 *   path: './my-graph-db',
 * });
 *
 * // Browser usage (with level-js)
 * await storage.connect({
 *   backend: 'levelgraph',
 *   dbName: 'my-graph-db',
 * });
 * ```
 */
export declare class LevelGraphStorage implements GraphStorage {
    private db;
    private _connected;
    private config;
    /**
     * Convert a SkillNode to triples
     */
    private skillToTriples;
    /**
     * Convert triples back to a SkillNode
     */
    private triplesToSkill;
    /**
     * Convert a PrerequisiteEdge to triples
     */
    private edgeToTriples;
    /**
     * Convert triples back to a PrerequisiteEdge
     */
    private triplesToEdge;
    private put;
    private del;
    private get;
    connect(config: StorageConfig): Promise<void>;
    disconnect(): Promise<void>;
    isConnected(): boolean;
    getStatus(): Promise<ConnectionStatus>;
    createSkill(input: SkillNodeInput): Promise<SkillNode>;
    getSkill(id: SkillId): Promise<SkillNode | null>;
    getSkills(ids: SkillId[]): Promise<SkillNode[]>;
    updateSkill(id: SkillId, updates: SkillNodeUpdate): Promise<SkillNode>;
    deleteSkill(id: SkillId): Promise<void>;
    findSkills(query: Partial<SkillQuery>): Promise<SkillNode[]>;
    countSkills(query?: Partial<SkillQuery>): Promise<number>;
    createPrerequisite(input: PrerequisiteEdgeInput): Promise<PrerequisiteEdge>;
    getPrerequisite(id: EdgeId): Promise<PrerequisiteEdge | null>;
    deletePrerequisite(id: EdgeId): Promise<void>;
    findPrerequisites(criteria: {
        sourceId?: SkillId;
        targetId?: SkillId;
        type?: string;
        minStrength?: number;
    }): Promise<PrerequisiteEdge[]>;
    getPrerequisitesOf(skillId: SkillId): Promise<SkillNode[]>;
    getDependentsOf(skillId: SkillId): Promise<SkillNode[]>;
    getSubgraph(rootId: SkillId, depth: number): Promise<Subgraph>;
    getRootSkills(): Promise<SkillNode[]>;
    getLeafSkills(): Promise<SkillNode[]>;
    getPath(fromId: SkillId, toId: SkillId): Promise<SkillNode[] | null>;
    importGraph(nodes: SkillNodeInput[], edges: PrerequisiteEdgeInput[], options?: {
        clearExisting?: boolean;
    }): Promise<ImportResult>;
    exportGraph(): Promise<GraphExport>;
    clearAll(): Promise<void>;
    getStats(): Promise<GraphStats>;
}
//# sourceMappingURL=levelgraph.d.ts.map