import { ParsingResult } from "../parsing";
import { EcoreMetamodelSupport, ECoreNode } from "./ecore";
import { Node } from "../model/model";
import ECore from "ecore/dist/ecore";
import { Position } from "../model/position";
import { Issue } from "../validation";
import { NodeAdapter, TraceNode } from "../trace/trace-node";
export declare function saveForStrumentaPlayground<R extends Node>(result: ParsingResult<R>, name: string, metamodelSupport: EcoreMetamodelSupport, callback: (data: any, error: any) => void): void;
export declare class ParserTrace {
    private node;
    constructor(node: NodeAdapter);
    get rootNode(): TraceNode;
    get issues(): Issue[];
    get name(): string | undefined;
}
export interface Language {
    name: string;
    uri: string;
    metamodel: any;
}
export declare class ParserTraceLoader {
    private readonly resourceSet;
    private readonly languages;
    constructor(...languages: Language[]);
    registerLanguage(lang: Language): ECore.EPackage[];
    loadParserTrace(trace: string | any, language?: string, uri?: string): ParserTrace;
}
declare abstract class AbstractTranspilationTrace {
    protected wrappedNode: NodeAdapter;
    protected sourceToTarget: Map<string, TargetNode[]>;
    issues: Issue[];
    protected constructor(wrappedNode: NodeAdapter);
    getDestinationNodes(sourceNode: SourceNode): TargetNode[];
    protected examineTargetNode(tn: ECore.EObject, parent?: TargetNode, customize?: (targetNode: TargetNode) => TargetNode): TargetNode;
}
export declare class TranspilationTrace extends AbstractTranspilationTrace {
    readonly rootSourceNode: SourceNode;
    readonly rootTargetNode: TargetNode;
    constructor(wrappedNode: ECoreNode);
    get name(): string | undefined;
}
export declare class WorkspaceTranspilationTrace extends AbstractTranspilationTrace {
    readonly originalFiles: SourceWorkspaceFile[];
    readonly generatedFiles: TargetWorkspaceFile[];
    readonly transpilationIssues: Issue[];
    readonly targetFileMap: Map<string, TargetWorkspaceFile>;
    constructor(wrapped: ECoreNode);
    get name(): string | undefined;
}
declare abstract class AbstractWorkspaceFile<N> {
    protected wrappedNode: NodeAdapter;
    protected trace: AbstractTranspilationTrace;
    protected constructor(wrappedNode: NodeAdapter, trace: AbstractTranspilationTrace);
    get path(): string;
    get code(): string;
    get issues(): Issue[];
    abstract get node(): N;
}
export declare class SourceWorkspaceFile extends AbstractWorkspaceFile<SourceNode> {
    constructor(wrapped: NodeAdapter, trace: AbstractTranspilationTrace);
    get node(): SourceNode;
}
export declare class TargetWorkspaceFile extends AbstractWorkspaceFile<TargetNode> {
    node: TargetNode;
    constructor(wrapped: NodeAdapter, trace: AbstractTranspilationTrace);
}
export declare class SourceNode extends TraceNode {
    protected trace: AbstractTranspilationTrace;
    readonly file?: SourceWorkspaceFile | undefined;
    parent?: SourceNode;
    protected _destinations?: TargetNode[];
    constructor(wrappedNode: NodeAdapter, trace: AbstractTranspilationTrace, file?: SourceWorkspaceFile | undefined);
    protected make(node: NodeAdapter): SourceNode;
    getDestinationNodes(): TargetNode[];
    getChildren(role?: string | symbol): SourceNode[];
}
export declare class TargetNode extends TraceNode {
    protected trace: AbstractTranspilationTrace;
    file?: TargetWorkspaceFile | undefined;
    parent?: TargetNode;
    constructor(wrapped: NodeAdapter, trace: AbstractTranspilationTrace, file?: TargetWorkspaceFile | undefined);
    protected make(node: NodeAdapter): TargetNode;
    getPosition(): Position | undefined;
    getDestination(): Position | undefined;
    getSourcePosition(): Position | undefined;
    getSourceNode(): SourceNode | undefined;
    protected makeSourceNode(eCoreNode: ECoreNode, file: SourceWorkspaceFile | undefined): SourceNode;
    getChildren(role?: string | symbol): TargetNode[];
}
export declare class TranspilationTraceLoader {
    private readonly resourceSet;
    private readonly languages;
    constructor(...languages: Language[]);
    registerLanguage(lang: Language): ECore.EPackage[];
    loadTranspilationTrace(trace: string | any, sourceLang?: string, targetLang?: string, uri?: string): TranspilationTrace;
    loadWorkspaceTranspilationTrace(trace: string | any, sourceLang?: string, targetLang?: string, uri?: string): WorkspaceTranspilationTrace;
}
export {};