text-runner-engine 7.1.0

package/dist/activities/index.js

@@ -0,0 +1,14 @@
+import * as ast from "../ast/index.js";
+import * as files from "../filesystem/index.js";
+export { extractDynamic } from "./extract-dynamic.js";
+export { extractImagesAndLinks } from "./extract-images-and-links.js";
+/** scaffoldActivity creates a test Activity from the given data */
+export function scaffold(data = {}) {
+    return {
+        actionName: data.actionName || "foo",
+        document: new ast.NodeList(),
+        location: files.Location.scaffold(),
+        region: new ast.NodeList()
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/activities/normalize-action-name.d.ts

@@ -0,0 +1,3 @@
+import * as files from "../filesystem/index.js";
+export declare function normalizeActionName(actionName: string, location: files.Location): string;
+//# sourceMappingURL=normalize-action-name.d.ts.map

package/dist/activities/normalize-action-name.js

@@ -0,0 +1,13 @@
+import slugify from "@sindresorhus/slugify";
+import { UserError } from "../errors/user-error.js";
+export function normalizeActionName(actionName, location) {
+    const parts = actionName.split("/");
+    if (parts.length === 1) {
+        return slugify(actionName);
+    }
+    if (parts.length > 2) {
+        throw new UserError(`Illegal activity name: "${actionName}" contains ${parts.length} slashes`, "", location);
+    }
+    return parts[0] + "/" + slugify(parts[1]);
+}
+//# sourceMappingURL=normalize-action-name.js.map

package/dist/ast/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./node-list.js";
+export * from "./node.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/index.js

@@ -0,0 +1,3 @@
+export * from "./node-list.js";
+export * from "./node.js";
+//# sourceMappingURL=index.js.map

package/dist/ast/node-list.d.ts

@@ -0,0 +1,41 @@
+import { Node, NodeScaffoldDataReadonly } from "./node.js";
+export declare class NodeList extends Array<Node> {
+    /** Creates a new ast.NodeList containing an Node scaffoldedd from the given data */
+    static scaffold(data?: NodeScaffoldDataReadonly): NodeList;
+    /** Returns whether this ast.NodeList contains a node of the given type. */
+    hasNodeOfType(nodeType: string): boolean;
+    /**
+     * provides exactly one node matching any of the given types,
+     * multiple or zero matches cause an exception
+     */
+    nodeOfTypes(...nodeTypes: string[]): Node;
+    /**
+     * Assuming the given Node is an opening node,
+     * returns all nodes until it closes.
+     */
+    nodesFor(openingNode: Node): NodeList;
+    /** Returns the Nodes matching any of the given types. */
+    nodesOfTypes(...nodeTypes: string[]): NodeList;
+    /** Returns all node types encountered in this list. */
+    nodeTypes(): string[];
+    /** Adds a new Node with the given data to this list. */
+    pushNode(data: NodeScaffoldDataReadonly): void;
+    /** Returns the concatenated textual content of all nodes in this list. */
+    text(): string;
+    /** Returns the textual content for the given node. */
+    textInNode(astNode: Node): string;
+    /**
+     * Returns the text in the node of the given types.
+     * Expects that exactly one matching node exists,
+     * throws otherwise.
+     */
+    textInNodeOfType(...nodeTypes: string[]): string;
+    /**
+     * Returns the text in the node that has one of the given types.
+     * Expects that exactly one matching node exists, throws otherwise.
+     */
+    textInNodeOfTypes(...nodeTypes: string[]): string;
+    /** provides the text in the nodes of the given types */
+    textInNodesOfType(...nodeTypes: string[]): string[];
+}
+//# sourceMappingURL=node-list.d.ts.map

package/dist/ast/node-list.js

@@ -0,0 +1,128 @@
+import { UserError } from "../errors/user-error.js";
+import { Node } from "./node.js";
+export class NodeList extends Array {
+    /** Creates a new ast.NodeList containing an Node scaffoldedd from the given data */
+    static scaffold(data = {}) {
+        const result = new NodeList();
+        result.push(Node.scaffold(data));
+        return result;
+    }
+    /** Returns whether this ast.NodeList contains a node of the given type. */
+    hasNodeOfType(nodeType) {
+        const types = [nodeType];
+        types.push(nodeType + "_open");
+        return this.some(node => types.includes(node.type));
+    }
+    /**
+     * provides exactly one node matching any of the given types,
+     * multiple or zero matches cause an exception
+     */
+    nodeOfTypes(...nodeTypes) {
+        const nodes = this.nodesOfTypes(...nodeTypes);
+        if (nodes.length > 1) {
+            throw new UserError(`Found ${nodes.length} nodes of type '${nodeTypes.join("/")}'`, "The nodeOfTypes method expects to find only one matching node, but it found multiple.", nodes[0].location);
+        }
+        if (nodes.length === 0) {
+            const msg = `found no nodes of type '${nodeTypes.join("/")}'`;
+            let guidance = "The node types in this list are: ";
+            guidance += this.nodeTypes().join(", ");
+            throw new UserError(msg, guidance, this[0].location);
+        }
+        return nodes[0];
+    }
+    /**
+     * Assuming the given Node is an opening node,
+     * returns all nodes until it closes.
+     */
+    nodesFor(openingNode) {
+        if (openingNode == null) {
+            throw new UserError("no Node given", `Somebody called the Text-Runner API method "NodeList.getNodesFor()" without an argument.
+This method provides all AST nodes until the given AST node closes.
+This callstack should point you to the problem:
+
+${new Error().stack}`);
+        }
+        let index = this.indexOf(openingNode);
+        if (index === -1) {
+            throw new UserError(`node '${openingNode.type}' not found in list`, "This ast.NodeList does not contain the given node.", openingNode.location);
+        }
+        const result = new NodeList();
+        if (!openingNode.isOpeningNode()) {
+            result.push(openingNode);
+            return result;
+        }
+        const endType = openingNode.endType();
+        let node;
+        do {
+            node = this[index];
+            result.push(node);
+            index += 1;
+        } while (node.type !== endType && index < this.length);
+        return result;
+    }
+    /** Returns the Nodes matching any of the given types. */
+    nodesOfTypes(...nodeTypes) {
+        const result = new NodeList();
+        const expectedTypes = [];
+        for (const nodeType of nodeTypes) {
+            expectedTypes.push(nodeType);
+            expectedTypes.push(nodeType + "_open");
+        }
+        for (const node of this) {
+            if (expectedTypes.includes(node.type)) {
+                result.push(node);
+            }
+        }
+        return result;
+    }
+    /** Returns all node types encountered in this list. */
+    nodeTypes() {
+        return this.map(node => node.type);
+    }
+    /** Adds a new Node with the given data to this list. */
+    pushNode(data) {
+        this.push(Node.scaffold(data));
+    }
+    /** Returns the concatenated textual content of all nodes in this list. */
+    text() {
+        return this.map(node => node.content)
+            .filter(text => text)
+            .join(" ");
+    }
+    /** Returns the textual content for the given node. */
+    textInNode(astNode) {
+        return this.nodesFor(astNode).reduce((acc, node) => acc + node.content, "");
+    }
+    /**
+     * Returns the text in the node of the given types.
+     * Expects that exactly one matching node exists,
+     * throws otherwise.
+     */
+    textInNodeOfType(...nodeTypes) {
+        for (const nodeType of nodeTypes) {
+            if (!nodeType.endsWith("_open")) {
+                nodeTypes.push(nodeType + "_open");
+            }
+        }
+        return this.textInNode(this.nodeOfTypes(...nodeTypes));
+    }
+    /**
+     * Returns the text in the node that has one of the given types.
+     * Expects that exactly one matching node exists, throws otherwise.
+     */
+    textInNodeOfTypes(...nodeTypes) {
+        const node = this.nodeOfTypes(...nodeTypes);
+        const nodes = this.nodesFor(node);
+        return nodes.text();
+    }
+    /** provides the text in the nodes of the given types */
+    textInNodesOfType(...nodeTypes) {
+        for (const nodeType of nodeTypes) {
+            if (!nodeType.endsWith("_open")) {
+                nodeTypes.push(nodeType + "_open");
+            }
+        }
+        return this.nodesOfTypes(...nodeTypes).map(node => this.textInNode(node));
+    }
+}
+//# sourceMappingURL=node-list.js.map

package/dist/ast/node.d.ts

@@ -0,0 +1,49 @@
+import * as files from "../filesystem/index.js";
+export type NodeAttributes = Record<string, string>;
+export interface NodeScaffoldData {
+    attributes?: NodeAttributes;
+    content?: string;
+    file?: files.FullFilePath | string;
+    line?: number;
+    sourceDir?: string;
+    tag?: NodeTag;
+    type?: NodeType;
+}
+export type NodeScaffoldDataReadonly = Readonly<NodeScaffoldData>;
+/** the HTML tags */
+export type NodeTag = "" | "/a" | "/b" | "/code" | "/pre" | "a" | "b" | "br" | "code" | "hr" | "i" | "img" | "li" | "ol" | "p" | "pre" | "ul";
+/** the MarkdownIt node types */
+export type NodeType = "anchor_close" | "anchor_open" | "bold_close" | "bold_open" | "bullet_list_close" | "bullet_list_open" | "code_close" | "code_open" | "fence_close" | "fence_open" | "h1_close" | "h1_open" | "h2_close" | "h2_open" | "h3_close" | "h3_open" | "h4_close" | "h4_open" | "h5_close" | "h5_open" | "h6_close" | "h6_open" | "heading_close" | "heading_open" | "hr" | "htmltag" | "image" | "linebreak" | "link_close" | "link_open" | "paragraph_close" | "paragraph_open" | "text";
+/** a node in the standardized Markdown/HTML AST */
+export declare class Node {
+    /** the attributes of the node */
+    readonly attributes: NodeAttributes;
+    /** textual content of this AST node */
+    readonly content: string;
+    /** the file in which this AstNode occurs */
+    readonly location: files.Location;
+    /** HTML type of AST node */
+    readonly tag: NodeTag;
+    /** markdown type of AST node */
+    type: NodeType;
+    constructor(data: {
+        attributes: NodeAttributes;
+        content: string;
+        location: files.Location;
+        tag: NodeTag;
+        type: NodeType;
+    });
+    static scaffold(data?: NodeScaffoldData): Node;
+    /** Returns the type of the corresponding ending node. */
+    endType(): string;
+    /**
+     * Returns the content of the "href" attribute for link tags,
+     * null otherwise.
+     */
+    htmlLinkTarget(): null | string;
+    /** Returns whether this AstNode is a closing node. */
+    isClosingNode(): boolean;
+    /** Returns whether this AstNode is an opening node. */
+    isOpeningNode(): boolean;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/ast/node.js

@@ -0,0 +1,53 @@
+import * as files from "../filesystem/index.js";
+/** a node in the standardized Markdown/HTML AST */
+export class Node {
+    constructor(data) {
+        this.type = data.type;
+        this.tag = data.tag;
+        this.location = data.location;
+        this.content = data.content;
+        this.attributes = data.attributes;
+    }
+    static scaffold(data = {}) {
+        if (typeof data.file === "string") {
+            data.file = new files.FullFilePath(data.file);
+        }
+        return new Node({
+            attributes: data.attributes || {},
+            content: data.content || "",
+            location: new files.Location(new files.SourceDir(data.sourceDir || ""), data.file || new files.FullFilePath("file"), data.line || 1),
+            tag: data.tag != null ? data.tag : "hr",
+            type: data.type || "hr"
+        });
+    }
+    /** Returns the type of the corresponding ending node. */
+    endType() {
+        if (!this.isOpeningNode()) {
+            throw new Error("not an opening node");
+        }
+        return this.type.replace("open", "") + "close";
+    }
+    /**
+     * Returns the content of the "href" attribute for link tags,
+     * null otherwise.
+     */
+    htmlLinkTarget() {
+        if (this.content == null) {
+            return null;
+        }
+        if (this.type !== "htmltag") {
+            return null;
+        }
+        const matches = /<a[^>]*href="([^"]*)".*?>/.exec(this.content);
+        return matches ? matches[1] : null;
+    }
+    /** Returns whether this AstNode is a closing node. */
+    isClosingNode() {
+        return this.type.endsWith("_close");
+    }
+    /** Returns whether this AstNode is an opening node. */
+    isOpeningNode() {
+        return this.type.endsWith("_open");
+    }
+}
+//# sourceMappingURL=node.js.map

package/dist/commands/command.d.ts

@@ -0,0 +1,9 @@
+import * as events from "../events/index.js";
+/** Command describes a Text-Runner command */
+export interface Command {
+    emit(event: events.Name, payload: events.Args): void;
+    /** executes this command */
+    execute(): Promise<void>;
+    on(event: events.Name, handler: events.Handler): void;
+}
+//# sourceMappingURL=command.d.ts.map

package/dist/commands/command.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command.js.map

package/dist/commands/debug.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "events";
+import * as configuration from "../configuration/index.js";
+import * as events from "../events/index.js";
+import { Command } from "./command.js";
+export declare const DebugSubCommandValues: readonly ["activities", "ast", "images", "links", "linkTargets"];
+export type DebugSubcommand = (typeof DebugSubCommandValues)[number];
+export declare class Debug implements Command {
+    emitter: EventEmitter;
+    subcommand: DebugSubcommand | undefined;
+    userConfig: configuration.APIData;
+    constructor(userConfig: configuration.APIData, subcommand: DebugSubcommand | undefined);
+    emit(name: events.Name, payload: events.Args): void;
+    execute(): Promise<void>;
+    on(name: events.Name, handler: events.Handler): this;
+}
+//# sourceMappingURL=debug.d.ts.map

package/dist/commands/debug.js

@@ -0,0 +1,122 @@
+import { EventEmitter } from "events";
+import * as util from "util";
+import * as activities from "../activities/index.js";
+import * as ast from "../ast/index.js";
+import * as configuration from "../configuration/index.js";
+import { UserError } from "../errors/user-error.js";
+import * as files from "../filesystem/index.js";
+import * as helpers from "../helpers/index.js";
+import * as linkTargets from "../link-targets/index.js";
+import * as parsers from "../parsers/index.js";
+export const DebugSubCommandValues = ["activities", "ast", "images", "links", "linkTargets"];
+export class Debug {
+    constructor(userConfig, subcommand) {
+        this.userConfig = userConfig;
+        this.subcommand = subcommand;
+        this.emitter = new EventEmitter();
+    }
+    emit(name, payload) {
+        this.emitter.emit(name, payload);
+    }
+    async execute() {
+        const config = await configuration.addDefaults(this.userConfig);
+        const filenames = await files.getFileNames(config);
+        if (filenames.length !== 1) {
+            const guidance = `Please tell me which file to debug
+
+Example: text-runner debug --${this.subcommand} foo.md`;
+            throw new UserError("no files specified", guidance);
+        }
+        const guidance = `possible subcommands are:
+--activities: active regions
+--ast: AST nodes
+--images: embedded images
+--links: embedded links
+--link-targets: document anchors to link to
+
+Example: text-runner debug --images foo.md`;
+        const ASTs = await parsers.markdown.parse(filenames, config.sourceDir);
+        switch (this.subcommand) {
+            case "activities":
+                return debugActivities(ASTs, config);
+            case "ast":
+                return debugASTNodes(ASTs);
+            case "images":
+                return debugImages(ASTs);
+            case "links":
+                return debugLinks(ASTs);
+            case "linkTargets":
+                return debugLinkTargets(ASTs);
+            case undefined:
+                throw new UserError("missing debug sub-command", guidance);
+            default:
+                throw new UserError(`unknown debug sub-command: ${this.subcommand}`, guidance);
+        }
+    }
+    on(name, handler) {
+        this.emitter.on(name, handler);
+        return this;
+    }
+}
+function debugActivities(ASTs, config) {
+    console.log("\nACTIVITIES:");
+    const dynamicActivities = activities.extractDynamic(ASTs, config.regionMarker || "type");
+    if (dynamicActivities.length === 0) {
+        console.log("(none)");
+    }
+    else {
+        for (const act of dynamicActivities) {
+            console.log(`${act.location.file.platformified()}:${act.location.line}  ${act.actionName}`);
+        }
+    }
+}
+function debugASTNodes(ASTs) {
+    console.log("AST NODES:");
+    for (const AST of ASTs) {
+        for (const node of AST) {
+            console.log(`${node.location.file.platformified()}:${node.location.line}  ${node.type} ${showAttr(node)}`);
+        }
+    }
+}
+function debugImages(ASTs) {
+    console.log("\nIMAGES:");
+    const images = activities.extractImagesAndLinks(ASTs).filter(al => al.actionName === "check-image");
+    if (images.length === 0) {
+        console.log("(none)");
+        return;
+    }
+    for (const image of images) {
+        image.document = new ast.NodeList();
+        console.log(helpers.trimAllLineEnds(util.inspect(image, false, Infinity)));
+    }
+}
+function debugLinks(ASTs) {
+    console.log("\nLINKS:");
+    const links = activities.extractImagesAndLinks(ASTs).filter(al => al.actionName === "check-link");
+    if (links.length === 0) {
+        console.log("(none)");
+        return;
+    }
+    for (const image of links) {
+        image.document = new ast.NodeList();
+        console.log(helpers.trimAllLineEnds(util.inspect(image, false, Infinity)));
+    }
+}
+function debugLinkTargets(ASTs) {
+    console.log("\nLINK TARGETS:");
+    const targets = linkTargets.find(ASTs);
+    for (const key of Object.keys(targets.targets)) {
+        console.log(key, targets.targets[key]);
+    }
+}
+function showAttr(node) {
+    if (node.type === "text") {
+        return `("${node.content.trim()}")`;
+    }
+    const keys = Object.keys(node.attributes);
+    if (keys.length === 0) {
+        return "";
+    }
+    return `(${node.attributes.type})`;
+}
+//# sourceMappingURL=debug.js.map

package/dist/commands/dynamic.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from "events";
+import * as configuration from "../configuration/index.js";
+import * as events from "../events/index.js";
+import { Command } from "./command.js";
+export declare class Dynamic implements Command {
+    emitter: EventEmitter;
+    userConfig: configuration.APIData;
+    constructor(userConfig: configuration.APIData);
+    emit(name: events.Name, payload: events.Args): void;
+    execute(): Promise<void>;
+    on(name: events.Name, handler: events.Handler): this;
+}
+//# sourceMappingURL=dynamic.d.ts.map

package/dist/commands/dynamic.js

@@ -0,0 +1,57 @@
+import { EventEmitter } from "events";
+import * as actions from "../actions/index.js";
+import * as activities from "../activities/index.js";
+import * as configuration from "../configuration/index.js";
+import * as files from "../filesystem/index.js";
+import * as linkTargets from "../link-targets/index.js";
+import * as parsers from "../parsers/index.js";
+import * as run from "../run/index.js";
+import * as workspace from "../workspace/index.js";
+export class Dynamic {
+    constructor(userConfig) {
+        this.userConfig = userConfig;
+        this.emitter = new EventEmitter();
+    }
+    emit(name, payload) {
+        this.emitter.emit(name, payload);
+    }
+    async execute() {
+        const originalDir = process.cwd();
+        try {
+            // step 1: determine full configuration
+            const config = await configuration.addDefaults(this.userConfig);
+            // step 2: create working dir
+            await workspace.create(config);
+            // step 3: find files
+            const filenames = await files.getFileNames(config);
+            if (filenames.length === 0) {
+                this.emit("result", { message: "no Markdown files found", status: "warning" });
+                return;
+            }
+            // step 4: read and parse files
+            const ASTs = await parsers.markdown.parse(filenames, config.sourceDir);
+            // step 5: find link targets
+            const targets = linkTargets.find(ASTs);
+            // step 6: extract activities
+            const dynamicActivities = activities.extractDynamic(ASTs, config.regionMarker);
+            if (dynamicActivities.length === 0) {
+                this.emit("result", { message: "no activities found", status: "warning" });
+                return;
+            }
+            // step 7: find actions
+            const actionFinder = await actions.Finder.loadDynamic(config.sourceDir);
+            // step 8: execute the ActivityList
+            this.emit("start", { stepCount: dynamicActivities.length });
+            process.chdir(config.workspace.platformified());
+            await run.sequential(dynamicActivities, actionFinder, config, targets, this);
+        }
+        finally {
+            process.chdir(originalDir);
+        }
+    }
+    on(name, handler) {
+        this.emitter.on(name, handler);
+        return this;
+    }
+}
+//# sourceMappingURL=dynamic.js.map

package/dist/commands/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./command.js";
+export * from "./debug.js";
+export * from "./dynamic.js";
+export * from "./run.js";
+export * from "./static.js";
+export * from "./unused.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -0,0 +1,7 @@
+export * from "./command.js";
+export * from "./debug.js";
+export * from "./dynamic.js";
+export * from "./run.js";
+export * from "./static.js";
+export * from "./unused.js";
+//# sourceMappingURL=index.js.map

package/dist/commands/run.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from "events";
+import * as configuration from "../configuration/index.js";
+import * as events from "../events/index.js";
+import * as command from "./index.js";
+/** executes "text-runner run", prints everything, returns the number of errors encountered */
+export declare class Run implements command.Command {
+    emitter: EventEmitter;
+    userConfig: configuration.APIData;
+    constructor(userConfig: configuration.APIData);
+    emit(name: events.Name, payload: events.Args): void;
+    execute(): Promise<void>;
+    on(name: events.Name, handler: events.Handler): this;
+}
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.js

@@ -0,0 +1,66 @@
+import { EventEmitter } from "events";
+import * as actions from "../actions/index.js";
+import * as activities from "../activities/index.js";
+import * as configuration from "../configuration/index.js";
+import * as files from "../filesystem/index.js";
+import * as linkTargets from "../link-targets/index.js";
+import * as parser from "../parsers/index.js";
+import * as run from "../run/index.js";
+import * as workspace from "../workspace/index.js";
+/** executes "text-runner run", prints everything, returns the number of errors encountered */
+export class Run {
+    constructor(userConfig) {
+        this.userConfig = userConfig;
+        this.emitter = new EventEmitter();
+    }
+    emit(name, payload) {
+        this.emitter.emit(name, payload);
+    }
+    async execute() {
+        const originalDir = process.cwd();
+        try {
+            // step 1: determine full configuration
+            const config = await configuration.addDefaults(this.userConfig);
+            // step 2: create workspace
+            await workspace.create(config);
+            // step 3: find files
+            const filenames = await files.getFileNames(config);
+            if (filenames.length === 0) {
+                this.emit("result", { message: "no Markdown files found", status: "warning" });
+                return;
+            }
+            // step 4: read and parse files
+            const ASTs = await parser.markdown.parse(filenames, config.sourceDir);
+            // step 5: find link targets
+            const targets = linkTargets.find(ASTs);
+            // step 6: find actions
+            const actionFinder = await actions.Finder.load(config.sourceDir);
+            // step 7: extract activities
+            const dynamicActivities = activities.extractDynamic(ASTs, config.regionMarker);
+            const links = activities.extractImagesAndLinks(ASTs);
+            if (dynamicActivities.length + links.length === 0) {
+                this.emit("result", { message: "no activities found", status: "warning" });
+                return;
+            }
+            // step 8: execute the ActivityList
+            const startArgs = { stepCount: dynamicActivities.length + links.length };
+            this.emit("start", startArgs);
+            process.chdir(config.workspace.platformified());
+            // kick off the parallel jobs to run in the background
+            const parJobs = run.parallel(links, actionFinder, targets, config, this);
+            // execute the serial jobs
+            await run.sequential(dynamicActivities, actionFinder, config, targets, this);
+            await Promise.all(parJobs);
+            // step 9: cleanup
+            process.chdir(config.sourceDir.platformified());
+        }
+        finally {
+            process.chdir(originalDir);
+        }
+    }
+    on(name, handler) {
+        this.emitter.on(name, handler);
+        return this;
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/commands/static.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from "events";
+import * as configuration from "../configuration/index.js";
+import * as events from "../events/index.js";
+import { Command } from "./command.js";
+export declare class Static implements Command {
+    emitter: EventEmitter;
+    userConfig: configuration.APIData;
+    constructor(userConfig: configuration.APIData);
+    emit(name: events.Name, payload: events.Args): void;
+    execute(): Promise<void>;
+    on(name: events.Name, handler: events.Handler): this;
+}
+//# sourceMappingURL=static.d.ts.map