motoko/lib/versions/interpreter.d.ts

Compile and run Motoko smart contracts in Node.js or the browser.

declare const _default: {
    version: any;
    compiler: any;
    file(path: string): {
        path: string;
        clone(): any;
        read(): string;
        write(content: string): void;
        rename(newPath: string): void;
        delete(): void;
        list(): string[];
        check(): import("..").Diagnostic[];
        run(): {
            stdout: string;
            stderr: string;
            result: import("..").Result;
        };
        candid(): string;
        wasm(mode: import("..").WasmMode): any;
        parseCandid(): object;
        parseMotoko(enableRecovery?: boolean): import("../ast").Node;
        parseMotokoWithDeps(enableRecovery?: boolean): {
            ast: import("../ast").Node;
            immediateImports: string[];
        };
        parseMotokoTyped(): {
            ast: import("../ast").Node;
            type: import("../ast").Node;
        };
        parseMotokoTypedWithScopeCache(scopeCache: Map<string, unknown>, enableRecovery?: boolean): [{
            ast: import("../ast").Node;
            type: import("../ast").Node;
            immediateImports: string[];
        }, Map<string, unknown>];
    };
    read(path: string): string;
    write(path: string, content?: string): void;
    rename(path: string, newPath: string): void;
    delete(path: string): void;
    list(directory: string): string[];
    fetchPackage(name: string, info: string | import("../package").PackageInfo): Promise<import("../package").Package>;
    installPackages(packages: Record<string, string | import("../package").PackageInfo>): Promise<void>;
    loadPackage(pkg: import("../package").Package): void;
    usePackage(name: string, directory: string): void;
    clearPackages(): void;
    validatePackage(pkg: import("../package").Package): void;
    setAliases(directory: string, aliases: Record<string, string>): void;
    setPublicMetadata(values: string[]): void;
    setRunStepLimit(limit: number): void;
    setTypecheckerCombineSrcs(combineSrcs: boolean): void;
    check(path: string): import("..").Diagnostic[];
    run(path: string, libPaths?: string[]): {
        stdout: string;
        stderr: string;
        result: import("..").Result;
    };
    candid(path: string): string;
    wasm(path: string, mode: import("..").WasmMode): any;
    parseCandid(content: string): object;
    parseMotoko(content: string, enableRecovery?: boolean): import("../ast").Node;
    parseMotokoWithDeps(path: string, content: string, enableRecovery?: boolean): {
        ast: import("../ast").Node;
        immediateImports: string[];
    };
    parseMotokoTyped: {
        (paths: string): {
            ast: import("../ast").Node;
            type: import("../ast").Node;
        };
        (paths: string[]): {
            ast: import("../ast").Node;
            type: import("../ast").Node;
        }[];
    };
    parseMotokoTypedWithScopeCache: {
        (paths: string, scopeCache: Map<string, unknown>, enableRecovery?: boolean): [{
            ast: import("../ast").Node;
            type: import("../ast").Node;
            immediateImports: string[];
        }, Map<string, unknown>];
        (paths: string[], scopeCache: Map<string, unknown>, enableRecovery?: boolean): [{
            ast: import("../ast").Node;
            type: import("../ast").Node;
            immediateImports: string[];
        }[], Map<string, unknown>];
    };
    resolveMain(directory?: string): string;
    resolveLib(directory?: string): string;
};
export default _default;
//# sourceMappingURL=interpreter.d.ts.map