text-runner-engine 7.1.0

package/README.md

@@ -0,0 +1,36 @@
+<!-- logo is from: https://icons8.com/icon/40886/test -->
+<img src="../documentation/logo2.png" align="right" valign="bottom">
+
+# Text-Runner
+
+> Test runner for text
+
+Text-Runner makes rich text executable. An example is the documentation you are
+reading right now. Text-Runner executes certain parts of it to verify that it
+correctly describes how Text-Runner works. Text-Runner allows you to
+
+- test your natural-language documentation
+- make your end-to-end tests completely human-readable prose
+- write computer programs in natural language
+
+There are no limitations on the type of text that TextRunner can execute. It can
+read and understand (if you tell it how) any form of plain text in any human
+language as well as complex data in tables, bullet point lists, or embedded
+images. This can be useful for things like
+
+- **agile documentation:** your documentation always matches the behavior of the
+  product it describes
+- **[semantic versioning](http://semver.org):** know whether a product change
+  affects documented behavior
+- **[readme-driven development](http://tom.preston-werner.com/2010/08/23/readme-driven-development.html):**
+  documentation becomes your product prototype and drives the implementation
+
+More information about:
+
+- [how it works](../documentation/how-it-works.md)
+- [installation](../documentation/installation.md)
+- [built-in actions](../documentation/built-in-actions.md)
+- [user-defined actions](../documentation/user-defined-actions.md)
+- [external actions](../documentation/external-actions.md)
+- [questions and answers](../documentation/qna.md)
+- [related tools](../documentation/related-tools.md)

package/dist/actions/actions.d.ts

@@ -0,0 +1,11 @@
+import { Action, FunctionRepo } from "./index.js";
+export declare class Actions {
+    list: FunctionRepo;
+    constructor();
+    get(name: string): Action | undefined;
+    /** provides the names of all registered actions */
+    names(): string[];
+    register(fileBasedName: string, action: any): void;
+    size(): number;
+}
+//# sourceMappingURL=actions.d.ts.map

package/dist/actions/actions.js

@@ -0,0 +1,36 @@
+import slugify from "@sindresorhus/slugify";
+export class Actions {
+    constructor() {
+        this.list = {};
+    }
+    get(name) {
+        return this.list[name];
+    }
+    /** provides the names of all registered actions */
+    names() {
+        return Object.keys(this.list).sort();
+    }
+    register(fileBasedName, action) {
+        if (typeof action === "function") {
+            this.list[fileBasedName] = action;
+        }
+        else if (typeof action.default === "function") {
+            this.list[fileBasedName] = action.default;
+        }
+        else if (typeof action === "object") {
+            for (const key of Object.keys(action)) {
+                if (typeof key !== "string") {
+                    throw new Error(`Key "${key}" has unexpected type "${typeof key}", expected string`);
+                }
+                this.list[slugify(key)] = action[key];
+            }
+        }
+        else {
+            throw new Error(`Cannot use object of type "${typeof action}" as an exported action: ${action}`);
+        }
+    }
+    size() {
+        return Object.keys(this.list).length;
+    }
+}
+//# sourceMappingURL=actions.js.map

package/dist/actions/built-in/check-image.d.ts

@@ -0,0 +1,4 @@
+import * as actions from "../index.js";
+/** The "checkImage" action checks for broken images. */
+export declare function checkImage(action: actions.Args): Promise<number | void>;
+//# sourceMappingURL=check-image.d.ts.map

package/dist/actions/built-in/check-image.js

@@ -0,0 +1,59 @@
+import { promises as fs } from "fs";
+import got, { HTTPError, TimeoutError } from "got";
+import * as files from "../../filesystem/index.js";
+/** The "checkImage" action checks for broken images. */
+export async function checkImage(action) {
+    const node = action.region[0];
+    const imagePath = node.attributes.src;
+    if (!imagePath) {
+        throw new Error("image tag without source");
+    }
+    action.name(`image ${imagePath}`);
+    if (isRemoteImage(imagePath)) {
+        const result = await checkRemoteImage(imagePath, action);
+        return result;
+    }
+    else {
+        // local image here
+        const imageFullFile = new files.FullFilePath(imagePath.startsWith("/") ? imagePath : node.location.file.directory().joinStr(imagePath));
+        const result = await checkLocalImage(imageFullFile, action.configuration);
+        return result;
+    }
+}
+async function checkLocalImage(image, c) {
+    try {
+        await fs.stat(c.sourceDir.joinFullFile(image).platformified());
+    }
+    catch (err) {
+        throw new Error(`image ${image.unixified()} does not exist`);
+    }
+}
+async function checkRemoteImage(url, action) {
+    if (!action.configuration.online) {
+        return action.SKIPPING;
+    }
+    try {
+        await got(url, { timeout: { request: 2000 } });
+    }
+    catch (err) {
+        if (err instanceof HTTPError && err.response.statusCode === 404) {
+            action.log(`image ${url} does not exist`);
+        }
+        else if (err instanceof TimeoutError) {
+            action.log(`image ${url} timed out`);
+        }
+        else {
+            throw err;
+        }
+    }
+    return;
+}
+function isRemoteImage(imagePath) {
+    if (imagePath != null) {
+        return imagePath.startsWith("//") || imagePath.startsWith("http://") || imagePath.startsWith("https://");
+    }
+    else {
+        return false;
+    }
+}
+//# sourceMappingURL=check-image.js.map

package/dist/actions/built-in/check-link.d.ts

@@ -0,0 +1,4 @@
+import { Args } from "../index.js";
+/** The "checkLink" action checks for broken hyperlinks. */
+export declare function checkLink(action: Args): Promise<Args["SKIPPING"] | void>;
+//# sourceMappingURL=check-link.d.ts.map

package/dist/actions/built-in/check-link.js

@@ -0,0 +1,127 @@
+import { promises as fs } from "fs";
+import got, { HTTPError, TimeoutError } from "got";
+import { errorMessage } from "../../errors/error.js";
+import { UserError } from "../../errors/user-error.js";
+import * as files from "../../filesystem/index.js";
+import * as helpers from "../../helpers/index.js";
+/** The "checkLink" action checks for broken hyperlinks. */
+export async function checkLink(action) {
+    const target = action.region.nodeOfTypes("link_open").attributes.href;
+    if (target == null || target === "") {
+        throw new Error("link without target");
+    }
+    for (const ignoreLinkTarget of action.configuration.ignoreLinkTargets) {
+        if (ignoreLinkTarget.test(target)) {
+            return action.SKIPPING;
+        }
+    }
+    action.name(`link to ${target}`);
+    if (helpers.isMailtoLink(target)) {
+        return action.SKIPPING;
+    }
+    if (helpers.isLinkToAnchorInSameFile(target)) {
+        const result = checkLinkToAnchorInSameFile(action.location.file, target, action);
+        return result;
+    }
+    if (helpers.isLinkToAnchorInOtherFile(target)) {
+        const result = checkLinkToAnchorInOtherFile(action.location, target, action);
+        return result;
+    }
+    if (helpers.isExternalLink(target)) {
+        const result = await checkExternalLink(target, action);
+        return result;
+    }
+    await checkLinkToFilesystem(target, action);
+    return;
+}
+async function checkExternalLink(target, action) {
+    if (!action.configuration.online) {
+        return action.SKIPPING;
+    }
+    action.name(`link to external website ${target}`);
+    try {
+        await got(target, { timeout: { request: 2000 } });
+    }
+    catch (e) {
+        if (e instanceof HTTPError && e.response.statusCode === 404) {
+            throw new Error(`external website doesn't exist: ${target}`);
+        }
+        else if (e instanceof TimeoutError) {
+            action.log("timed out");
+        }
+        else {
+            action.log(`error while checking link to ${target}: ${errorMessage(e)}`);
+        }
+    }
+    return;
+}
+function checkLinkToAnchorInOtherFile(containingLocation, target, action) {
+    const link = new files.UnknownLink(target);
+    const absoluteLink = link.absolutify(containingLocation, action.configuration.publications);
+    const anchorName = absoluteLink.anchor();
+    const fullPath = absoluteLink.localize(action.configuration.publications, action.configuration.defaultFile);
+    try {
+        var fullFile = fullPath.toFullFilePath();
+    }
+    catch (e) {
+        throw new Error(`link to non-existing file ${fullPath.unixified()}`);
+    }
+    if (!action.linkTargets.hasFile(fullFile)) {
+        throw new Error(`link to anchor #${anchorName} in non-existing file ${helpers.removeLeadingSlash(fullFile.unixified())}`);
+    }
+    if (!action.linkTargets.hasAnchor(fullFile, anchorName)) {
+        throw new UserError(`link to non-existing anchor ${"#" + anchorName} in ${fullFile.unixified()}`, `File ${fullFile.unixified()} contains these anchors: ${action.linkTargets
+            .getAnchors(fullFile)
+            .map(anchor => `#${anchor}`)
+            .join(", ")}`);
+    }
+    if (action.linkTargets.anchorType(fullFile, anchorName) === "heading") {
+        action.name(`link to heading ${fullFile.unixified() + "#" + anchorName}`);
+    }
+    else {
+        action.name(`link to ${fullFile.unixified()}#${anchorName}`);
+    }
+}
+function checkLinkToAnchorInSameFile(file, target, action) {
+    const anchorName = target.substr(1);
+    if (!action.linkTargets.hasAnchor(file, anchorName)) {
+        throw new UserError(`link to non-existing local anchor ${target}`, `These local anchors exist: ${action.linkTargets
+            .getAnchors(file)
+            .map(anchor => `#${anchor}`)
+            .join(", ")}`, action.location);
+    }
+    if (action.linkTargets.anchorType(file, anchorName) === "heading") {
+        action.name(`link to local heading ${target}`);
+    }
+    else {
+        action.name(`link to #${anchorName}`);
+    }
+}
+async function checkLinkToFilesystem(target, action) {
+    const unknownLink = new files.UnknownLink(decodeURI(target));
+    const absoluteLink = unknownLink.absolutify(action.location, action.configuration.publications);
+    const linkedFile = absoluteLink.localize(action.configuration.publications, action.configuration.defaultFile);
+    const fullPath = action.configuration.sourceDir.joinStr(linkedFile.unixified());
+    // We only check for directories if no defaultFile is set.
+    // Otherwise links to folders point to the default file.
+    if (!action.configuration.defaultFile) {
+        try {
+            const stats = await fs.stat(fullPath);
+            if (stats.isDirectory()) {
+                action.name(`link to local directory ${linkedFile.unixified()}`);
+                return;
+            }
+        }
+        catch (e) {
+            // we can ignore errors here since we keep checking the file below
+        }
+    }
+    action.name(`link to local file ${linkedFile.unixified()}`);
+    try {
+        await fs.stat(fullPath);
+    }
+    catch (err) {
+        throw new Error(`link to non-existing local file ${linkedFile.unixified()}`);
+    }
+}
+//# sourceMappingURL=check-link.js.map

package/dist/actions/built-in/test.d.ts

@@ -0,0 +1,3 @@
+import { Args } from "../index.js";
+export declare function test(action: Args): void;
+//# sourceMappingURL=test.d.ts.map

package/dist/actions/built-in/test.js

@@ -0,0 +1,4 @@
+export function test(action) {
+    action.log(action.region.text());
+}
+//# sourceMappingURL=test.js.map

package/dist/actions/export.d.ts

@@ -0,0 +1,18 @@
+import * as actions from "./index.js";
+export type Action = CbAction | PromiseAction | SyncAction;
+export type CbAction = (action: actions.Args, done: DoneFunction) => void;
+/** continuous-passing-style callback function */
+export type DoneFunction = (err?: Error) => void;
+/** expected file structure of "index.js" files exporting Text-Runner actions */
+export interface IndexFile {
+    textrunActions: TextrunActions;
+}
+/** elements of "package.json" files used here */
+export interface PackageJson {
+    exports: string;
+}
+export type PromiseAction = (action: actions.Args) => Promise<void>;
+export type SyncAction = (action: actions.Args) => void;
+/** data format of exported actions by npm modules */
+export type TextrunActions = Record<string, Action>;
+//# sourceMappingURL=export.d.ts.map

package/dist/actions/export.js

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

package/dist/actions/external-action-manager.d.ts

@@ -0,0 +1,10 @@
+import { Activity } from "../activities/index.js";
+import { Action, FunctionRepo } from "./index.js";
+/** ExternalActionManager provides external actions from their own NPM modules */
+export declare class ExternalActionManager {
+    actions: FunctionRepo;
+    constructor();
+    /** provides the external action with the given name */
+    get(activity: Activity): Promise<Action | null>;
+}
+//# sourceMappingURL=external-action-manager.d.ts.map

package/dist/actions/external-action-manager.js

@@ -0,0 +1,44 @@
+import * as actions from "../actions/index.js";
+import { UserError } from "../errors/user-error.js";
+/** ExternalActionManager provides external actions from their own NPM modules */
+export class ExternalActionManager {
+    constructor() {
+        this.actions = {};
+    }
+    /** provides the external action with the given name */
+    async get(activity) {
+        const parts = activity.actionName.split("/");
+        if (parts.length === 1) {
+            // not an external action here --> ignore
+            return null;
+        }
+        if (parts.length > 2) {
+            throw new UserError(`Too many slashes in action name "${activity.actionName}"`, "Activities are only allowed to have one slash in them: to separate the npm module name from the action name", activity.location);
+        }
+        const moduleName = "textrun-" + parts[0];
+        const wantAction = actions.name(parts[1]);
+        try {
+            var module = await import(moduleName);
+        }
+        catch (e) {
+            if (!(e instanceof Error)) {
+                throw e;
+            }
+            throw new UserError(`cannot load npm package "${moduleName}"`, e.message, activity.location);
+        }
+        const moduleActions = module.textrunActions;
+        if (!moduleActions) {
+            throw new UserError(`npm package "${moduleName}" does not contain any Text-Runner actions`, "", activity.location);
+        }
+        const names = [];
+        for (const [rawName, action] of Object.entries(moduleActions)) {
+            const name = actions.name(rawName);
+            if (name === wantAction) {
+                return action;
+            }
+            names.push(name);
+        }
+        throw new UserError(`npm package "${moduleName}" does not contain action "${wantAction}"`, `Found actions: ${names.join(", ")}`, activity.location);
+    }
+}
+//# sourceMappingURL=external-action-manager.js.map

package/dist/actions/finder.d.ts

@@ -0,0 +1,29 @@
+import * as activities from "../activities/index.js";
+import * as files from "../filesystem/index.js";
+import { Actions } from "./actions.js";
+import { ExternalActionManager } from "./external-action-manager.js";
+import { Action } from "./index.js";
+/** ActionFinder provides runnable action instances for activities. */
+export declare class Finder {
+    private readonly builtinActions;
+    private readonly customActions;
+    private readonly externalActions;
+    constructor(builtIn: Actions, custom: Actions, external: ExternalActionManager);
+    /** loads all actions */
+    static load(sourceDir: files.SourceDir): Promise<Finder>;
+    /** loads only the actions for dynamic tests */
+    static loadDynamic(sourceDir: files.SourceDir): Promise<Finder>;
+    /** loads only the actions for static tests */
+    static loadStatic(): Promise<Finder>;
+    /** actionFor provides the action function for the given Activity. */
+    actionFor(activity: activities.Activity): Promise<Action>;
+    /** customActionNames returns the names of all built-in actions. */
+    customActionNames(): string[];
+    /** errorUnknownAction signals that the given activity has no known action. */
+    private errorUnknownAction;
+}
+export declare function builtinActionFilePaths(): Promise<string[]>;
+export declare function customActionFilePaths(dir: string): Promise<string[]>;
+export declare function loadBuiltinActions(): Promise<Actions>;
+export declare function loadCustomActions(dir: string): Promise<Actions>;
+//# sourceMappingURL=finder.d.ts.map

package/dist/actions/finder.js

@@ -0,0 +1,99 @@
+import { promises as fs } from "fs";
+import path from "path";
+import * as url from "url";
+import * as actions from "../actions/index.js";
+import { UserError } from "../errors/user-error.js";
+import { Actions } from "./actions.js";
+import { ExternalActionManager } from "./external-action-manager.js";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+/** ActionFinder provides runnable action instances for activities. */
+export class Finder {
+    constructor(builtIn, custom, external) {
+        this.builtinActions = builtIn;
+        this.customActions = custom;
+        this.externalActions = external;
+    }
+    /** loads all actions */
+    static async load(sourceDir) {
+        return new Finder(await loadBuiltinActions(), await loadCustomActions(sourceDir.joinStr("text-runner")), new ExternalActionManager());
+    }
+    /** loads only the actions for dynamic tests */
+    static async loadDynamic(sourceDir) {
+        return new Finder(new Actions(), await loadCustomActions(sourceDir.joinStr("text-runner")), new ExternalActionManager());
+    }
+    /** loads only the actions for static tests */
+    static async loadStatic() {
+        return new Finder(await loadBuiltinActions(), new Actions(), new ExternalActionManager());
+    }
+    /** actionFor provides the action function for the given Activity. */
+    async actionFor(activity) {
+        return (this.builtinActions.get(activity.actionName)
+            || this.customActions.get(activity.actionName)
+            || (await this.externalActions.get(activity))
+            || this.errorUnknownAction(activity));
+    }
+    /** customActionNames returns the names of all built-in actions. */
+    customActionNames() {
+        return this.customActions.names();
+    }
+    /** errorUnknownAction signals that the given activity has no known action. */
+    errorUnknownAction(activity) {
+        const errorText = `unknown action: ${activity.actionName}`;
+        let guidance = "";
+        if (this.customActions.size() > 0) {
+            guidance += "User-defined actions:\n";
+            for (const actionName of this.customActions.names()) {
+                guidance += `* ${actionName}\n`;
+            }
+        }
+        else {
+            guidance += "No custom actions defined.\n";
+        }
+        guidance += `\nTo create a new "${activity.actionName}" action,\n`;
+        guidance += `run "text-runner scaffold ${activity.actionName}"\n`;
+        throw new UserError(errorText, guidance, activity.location);
+    }
+}
+export async function builtinActionFilePaths() {
+    const result = [];
+    const builtinDir = path.join(__dirname, "built-in");
+    for (const file of await fs.readdir(builtinDir)) {
+        if (file.endsWith(".js") || (file.endsWith(".ts") && !file.endsWith(".d.ts"))) {
+            result.push(path.join(builtinDir, file));
+        }
+    }
+    return result;
+}
+export async function customActionFilePaths(dir) {
+    try {
+        var files = await fs.readdir(dir);
+    }
+    catch (e) {
+        // it's okay if there is no dir with custom actions
+        return [];
+    }
+    const result = [];
+    for (const file of files) {
+        if (file.endsWith(".js") || file.endsWith(".ts")) {
+            result.push(path.join(dir, file));
+        }
+    }
+    return result;
+}
+export async function loadBuiltinActions() {
+    const result = new Actions();
+    for (const filename of await builtinActionFilePaths()) {
+        const fileURL = url.pathToFileURL(filename);
+        result.register(actions.name(filename), await import(fileURL.href));
+    }
+    return result;
+}
+export async function loadCustomActions(dir) {
+    const result = new Actions();
+    for (const filename of await customActionFilePaths(dir)) {
+        const fileURL = url.pathToFileURL(filename);
+        result.register(actions.name(filename), await import(fileURL.href));
+    }
+    return result;
+}
+//# sourceMappingURL=finder.js.map

package/dist/actions/index.d.ts

@@ -0,0 +1,37 @@
+import * as ast from "../ast/index.js";
+import * as config from "../configuration/index.js";
+import * as files from "../filesystem/index.js";
+import * as linkTargets from "../link-targets/index.js";
+import * as run from "../run/index.js";
+export { Finder } from "./finder.js";
+export * from "./name.js";
+/** A user-defined or built-in function that tests an active block */
+export type Action = (params: Args) => Result;
+export interface Args {
+    /** TextRunner configuration data derived from the config file and CLI switches */
+    readonly configuration: config.Data;
+    /** the AST nodes of the active region which the current action tests */
+    readonly document: ast.NodeList;
+    /** all link targets in the current documentation  */
+    readonly linkTargets: linkTargets.List;
+    /** name of the file in which the currently tested active region is */
+    readonly location: files.Location;
+    /** allows printing test output to the user, behaves like console.log */
+    readonly log: run.LogFn;
+    /**
+     * Name allows to provide a more specific name for the current action.
+     *
+     * As an example, the generic step name `write file` could be refined to
+     * `write file "foo.yml"` once the name of the file to be written
+     * has been extracted from the document AST.
+     */
+    readonly name: run.RefineNameFn;
+    /** the AST nodes of the active region which the current action tests */
+    readonly region: ast.NodeList;
+    /** return the action with this value to signal that it is being skipped */
+    readonly SKIPPING: 254;
+}
+export type FunctionRepo = Record<string, Action>;
+/** the result of an action function */
+export type Result = 254 | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/index.js

@@ -0,0 +1,3 @@
+export { Finder } from "./finder.js";
+export * from "./name.js";
+//# sourceMappingURL=index.js.map

package/dist/actions/name.d.ts

@@ -0,0 +1,2 @@
+export declare function name(filepath: string): string;
+//# sourceMappingURL=name.d.ts.map

package/dist/actions/name.js

@@ -0,0 +1,6 @@
+import slugify from "@sindresorhus/slugify";
+import * as path from "path";
+export function name(filepath) {
+    return slugify(path.basename(filepath, path.extname(filepath)));
+}
+//# sourceMappingURL=name.js.map

package/dist/activities/extract-dynamic.d.ts

@@ -0,0 +1,5 @@
+import * as ast from "../ast/index.js";
+import { List } from "./index.js";
+/** returns all activities found in the given ast.NodeLists */
+export declare function extractDynamic(docs: ast.NodeList[], regionMarker: string): List;
+//# sourceMappingURL=extract-dynamic.d.ts.map

package/dist/activities/extract-dynamic.js

@@ -0,0 +1,29 @@
+import { normalizeActionName } from "./normalize-action-name.js";
+/** returns all activities found in the given ast.NodeLists */
+export function extractDynamic(docs, regionMarker) {
+    const result = [];
+    for (const doc of docs) {
+        result.push(...extractFromAST(doc, regionMarker));
+    }
+    return result;
+}
+/** returns the activities contained in the given NodeList */
+function extractFromAST(doc, regionMarker) {
+    const result = [];
+    for (const node of doc) {
+        if (isActiveBlockTag(node, regionMarker)) {
+            result.push({
+                actionName: normalizeActionName(node.attributes[regionMarker], node.location),
+                document: doc,
+                location: node.location,
+                region: doc.nodesFor(node)
+            });
+        }
+    }
+    return result;
+}
+/** returns whether the given AstNode marks an active region in the document */
+function isActiveBlockTag(node, activeAttributeName) {
+    return !!node.attributes[activeAttributeName];
+}
+//# sourceMappingURL=extract-dynamic.js.map

package/dist/activities/extract-images-and-links.d.ts

@@ -0,0 +1,5 @@
+import * as ast from "../ast/index.js";
+import { List } from "./index.js";
+/** extracts activities that check images and links from the given ActivityLists */
+export declare function extractImagesAndLinks(ASTs: ast.NodeList[]): List;
+//# sourceMappingURL=extract-images-and-links.d.ts.map

package/dist/activities/extract-images-and-links.js

@@ -0,0 +1,32 @@
+import * as ast from "../ast/index.js";
+/** extracts activities that check images and links from the given ActivityLists */
+export function extractImagesAndLinks(ASTs) {
+    const result = [];
+    for (const AST of ASTs) {
+        for (const node of AST) {
+            switch (node.type) {
+                case "image": {
+                    const nodes = new ast.NodeList();
+                    nodes.push(node);
+                    result.push({
+                        actionName: "check-image",
+                        document: AST,
+                        location: node.location,
+                        region: nodes
+                    });
+                    break;
+                }
+                case "link_open":
+                    result.push({
+                        actionName: "check-link",
+                        document: AST,
+                        location: node.location,
+                        region: AST.nodesFor(node)
+                    });
+                    break;
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=extract-images-and-links.js.map

package/dist/activities/index.d.ts

@@ -0,0 +1,20 @@
+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";
+/**
+ * Activity is an action instance.
+ * A particular action that we are going to perform
+ * on a particular region of a particular document.
+ */
+export interface Activity {
+    readonly actionName: string;
+    document: ast.NodeList;
+    readonly location: files.Location;
+    readonly region: ast.NodeList;
+}
+/** a list of activities */
+export type List = Activity[];
+/** scaffoldActivity creates a test Activity from the given data */
+export declare function scaffold(data?: Partial<Activity>): Activity;
+//# sourceMappingURL=index.d.ts.map