testeranto 0.111.0 → 0.112.1

package/dist/types/PM/main.d.ts

@@ -0,0 +1,66 @@
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+import fs from "fs";
+import { Browser } from "puppeteer-core";
+import { PassThrough } from "stream";
+import { IBuiltConfig, ITestTypes, ITLog } from "../lib/index.js";
+import { ISummary } from "../utils";
+import { PM } from "./index.js";
+export declare class PM_Main extends PM {
+    browser: Browser;
+    shutdownMode: boolean;
+    configs: IBuiltConfig;
+    ports: Record<number, boolean>;
+    queue: any[];
+    mode: "DEV" | "PROD";
+    bigBoard: ISummary;
+    webMetafileWatcher: fs.FSWatcher;
+    nodeMetafileWatcher: fs.FSWatcher;
+    constructor(configs: IBuiltConfig);
+    stop: () => void;
+    customclose(): void;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): any;
+    newPage(): CdpPage;
+    goto(p: any, url: string): any;
+    $(selector: string): boolean;
+    screencast(opts: object): void;
+    customScreenShot(opts: object, cdpPage?: CdpPage): void;
+    end(accessObject: {
+        uid: number;
+    }): boolean;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(fp: string): Promise<string | false | undefined>;
+    writeFileSync(fp: string, contents: string): void;
+    createWriteStream(filepath: string): fs.WriteStream;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    write(accessObject: {
+        uid: number;
+    }, contents: string): boolean;
+    page(): string | undefined;
+    click(selector: string): string | undefined;
+    focusOn(selector: string): void;
+    typeInto(value: string): void;
+    getValue(value: string): void;
+    getAttribute(selector: string, attribute: string): void;
+    isDisabled(selector: string): Promise<boolean>;
+    screencastStop(s: string): void;
+    metafileOutputs(platform: "web" | "node"): Promise<void>;
+    start(): Promise<any>;
+    tscCheck: ({ entrypoint, addableFiles, platform, }: {
+        platform: "web" | "node";
+        entrypoint: string;
+        addableFiles: string[];
+    }) => Promise<void>;
+    eslintCheck: (entrypoint: string, platform: "web" | "node", addableFiles: string[]) => Promise<void>;
+    makePrompt: (entryPoint: string, addableFiles: string[], platform: "web" | "node") => Promise<void>;
+    checkForShutdown: () => void;
+    testIsNowRunning: (src: string) => void;
+    testIsNowDone: (src: string) => void;
+    launchNode: (src: string, dest: string) => Promise<void>;
+    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<Page>;
+    launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
+    launchWeb: (t: string, dest: string) => void;
+    receiveFeatures: (features: string[], destFolder: string, srcTest: string) => void;
+    receiveExitCode: (srcTest: string, failures: number) => void;
+    writeBigBoard: () => void;
+}

package/dist/types/PM/node.d.ts

@@ -0,0 +1,40 @@
+import { ScreencastOptions } from "puppeteer-core";
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
+type PuppetMasterServer = Record<string, Promise<any>>;
+export declare class PM_Node extends PM {
+    server: PuppetMasterServer;
+    testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(t: ITTestResourceConfiguration);
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): string;
+    goto(cdpPage: CdpPage, url: string): any;
+    newPage(): CdpPage;
+    $(selector: string): boolean;
+    isDisabled(selector: string): Promise<boolean>;
+    getAttribute(selector: string, attribute: string): void;
+    getValue(selector: string): void;
+    focusOn(selector: string): void;
+    typeInto(value: string): void;
+    page(): any;
+    click(selector: string): string | undefined;
+    screencast(opts: ScreencastOptions, page: CdpPage): any;
+    screencastStop(p: string): any;
+    customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage): any;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(): any;
+    write(writeObject: {
+        uid: number;
+    }, contents: string): any;
+    writeFileSync(filepath: string, contents: string): any;
+    createWriteStream(filepath: string): any;
+    end(writeObject: {
+        uid: number;
+    }): any;
+    customclose(): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    startPuppeteer(options?: any): any;
+}
+export {};

package/dist/types/PM/web.d.ts

@@ -0,0 +1,38 @@
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
+type PuppetMasterServer = Record<string, Promise<any>>;
+export declare class PM_Web extends PM {
+    server: PuppetMasterServer;
+    constructor(t: ITTestResourceConfiguration);
+    waitForSelector(p: string, s: string): any;
+    screencast(opts: ScreencastOptions): any;
+    screencastStop(recorder: string): any;
+    closePage(p: any): string;
+    goto(p: any, url: string): any;
+    newPage(): CdpPage;
+    $(selector: string): boolean;
+    isDisabled(selector: string): Promise<boolean>;
+    getAttribute(selector: string, attribute: string): any;
+    getValue(selector: string): any;
+    focusOn(selector: string): any;
+    typeInto(value: string): any;
+    page(): string | undefined;
+    click(selector: string): any;
+    customScreenShot(opts: ScreenshotOptions): any;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(x: any): any;
+    write(writeObject: {
+        uid: number;
+    }, contents: string): any;
+    writeFileSync(filepath: string, contents: string): any;
+    createWriteStream(filepath: string): any;
+    end(writeObject: {
+        uid: number;
+    }): any;
+    customclose(): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+}
+export {};

package/dist/types/ReportServer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/SubPackages/react/component/node.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+type IInput = typeof React.Component;
+export type IImpl<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestImplementation<I, O>;
+export type ISpec<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ISpec<I, O>, testInput: IInput) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react/component/web.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+type IInput = typeof React.Component;
+export type IImpl<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestImplementation<I, O>;
+export type ISpec<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ISpec<I, O>, testInput: IInput) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react/jsx/index.d.ts

@@ -0,0 +1,12 @@
+import { CElement } from "react";
+import { Ibdd_in, Ibdd_out, IPartialInterface, ITestImplementation, ITestSpecification } from "../../../Types";
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = () => JSX.Element;
+export type ISelection = CElement<any, any>;
+export type IStore = CElement<any, any>;
+export type ISubject = CElement<any, any>;
+export type ITestImpl<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestImplementation<I, O>;
+export type ITestSpec<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+export declare const testInterface: IPartialInterface<any>;

package/dist/types/SubPackages/react/jsx/node.d.ts

@@ -0,0 +1,4 @@
+import { Ibdd_in, Ibdd_out, IPartialInterface } from "../../../Types";
+import { ITestImpl, ITestSpec, IInput } from "./index.js";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImpl<I, O>, testSpecifications: ITestSpec<I, O>, testInput: IInput, testInterface?: IPartialInterface<I>) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react/jsx/web.d.ts

@@ -0,0 +1,4 @@
+import { Ibdd_in, Ibdd_out, IPartialWebInterface } from "../../../Types";
+import { ITestImpl, ITestSpec, IInput } from "./index.js";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImpl<I, O>, testSpecifications: ITestSpec<I, O>, testInput: IInput, testInterface: IPartialWebInterface<I>) => Promise<import("../../../lib/core").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-dom/component/node.d.ts

@@ -0,0 +1,11 @@
+import React, { ReactNode } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from "stream";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+type IInput = typeof React.Component;
+export type ISelection = ReactNode;
+export type IStore = ReactNode;
+export type ISubject = ReactNode;
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+declare const _default: <I extends Ibdd_in<IInput, ISubject, IStore, ISelection, unknown, (s: IStore) => IStore, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ITestSpecification<I, O>, testInput: IInput) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-dom/component/web.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import ReactDom from "react-dom/client";
+import { Ibdd_in, Ibdd_out, IPartialWebInterface, ITestImplementation, ITestSpecification } from "../../../Types";
+type IInput = typeof React.Component;
+type ISelection = {
+    htmlElement: HTMLElement;
+    reactElement: any;
+    domRoot: ReactDom.Root;
+};
+export type IStore = {
+    htmlElement: HTMLElement;
+    reactElement: any;
+    domRoot: ReactDom.Root;
+};
+type ISubject = {
+    htmlElement: HTMLElement;
+    domRoot: ReactDom.Root;
+};
+declare const _default: <I extends Ibdd_in<IInput, ISubject, ISelection, IStore, (s: IStore) => IStore, (s: IStore) => IStore, (s: IStore) => IStore>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testInput: IInput, testSpecifications: ITestSpecification<I, O>, testImplementations: ITestImplementation<I, O>, testInterface?: IPartialWebInterface<any>) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-dom/jsx/index.d.ts

@@ -0,0 +1,6 @@
+export type IInput = (props?: any) => JSX.Element;
+export type IState = unknown;
+export type ISelection = HTMLElement;
+export type IStore = HTMLElement;
+export type IWhenShape = any;
+export type IThenShape = any;

package/dist/types/SubPackages/react-dom/jsx/node.d.ts

@@ -0,0 +1,7 @@
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from "stream";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+import { IInput, ISelection, IStore } from "./index.js";
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+declare const _default: <I extends Ibdd_in<IInput, unknown, ISelection, IStore, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ITestSpecification<I, O>, testInput: I["iinput"]) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-dom/jsx/web.d.ts

@@ -0,0 +1,5 @@
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+import type { IInput, ISelection, IStore, IThenShape, IWhenShape } from "./index";
+export type ISubject = HTMLElement;
+declare const _default: <I extends Ibdd_in<IInput, ISubject, ISelection, IStore, unknown, IWhenShape, IThenShape>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ITestSpecification<I, O>, testInput: IInput) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/MemoExoticComponent/node.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import renderer from "react-test-renderer";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+type IInput = React.MemoExoticComponent<() => JSX.Element>;
+declare const _default: <I extends Ibdd_in<IInput, renderer.ReactTestRenderer, renderer.ReactTestRenderer, renderer.ReactTestRenderer, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ITestSpecification<I, O>, testInput: IInput) => Promise<import("../../../lib/core").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/component/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import renderer from "react-test-renderer";
+import type { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+export type ISuper<T> = T extends infer U ? U : object;
+export type IInput<P, S> = typeof React.Component<P, S>;
+export type InitialState = unknown;
+export type IWhenShape = any;
+export type IThenShape = any;
+export type ISelection = renderer.ReactTestRenderer;
+export type IStore = renderer.ReactTestRenderer;
+export type ISubject = renderer.ReactTestRenderer;
+export type IImpl<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestImplementation<I, O>;
+export type ISpec<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;

package/dist/types/SubPackages/react-test-renderer/component/interface.d.ts

@@ -0,0 +1,9 @@
+import renderer from "react-test-renderer";
+import { ISelection, IStore } from ".";
+export declare const testInterface: {
+    beforeEach: (CComponent: any, propsAndChildren: () => any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: any) => Promise<renderer.ReactTestRenderer>;
+    butThen: (s: IStore, thenCB: any, tr: any) => Promise<ISelection>;
+    afterEach: (store: IStore, ndx: any, artificer: any) => Promise<{}>;
+    afterAll: (store: IStore, artificer: any) => void;
+};

package/dist/types/SubPackages/react-test-renderer/component/node.d.ts

@@ -0,0 +1,4 @@
+import { Ibdd_in, Ibdd_out } from "../../../Types.js";
+import { IImpl, ISpec, IInput } from "./index.js";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>, IProps, IState>(testImplementations: IImpl<I, O>, testSpecifications: ISpec<I, O>, testInput: IInput<IProps, IState>) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/component/web.d.ts

@@ -0,0 +1,4 @@
+import { Ibdd_in, Ibdd_out } from "../../../Types.js";
+import { IImpl, ISpec, IInput } from "./index.js";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: IImpl<I, O>, testSpecifications: ISpec<I, O>, testInput: IInput<any, any>) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/fc/node.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { ITestSpecification, ITestImplementation, Ibdd_in, Ibdd_out } from "../../../Types";
+export type IInput = React.FC;
+export type IWhenShape = unknown;
+export type IThenShape = unknown;
+export type ISpec<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ISpec<I, O>, testInput: IInput) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/fc/web.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import renderer from "react-test-renderer";
+import { ITestSpecification, ITestImplementation, Ibdd_in, Ibdd_out } from "../../../Types";
+export type IInput = React.FC;
+export type IWhenShape = unknown;
+export type IThenShape = unknown;
+export type ISpec<I extends Ibdd_in<unknown, unknown, renderer.ReactTestRenderer, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+declare const _default: <I extends Ibdd_in<unknown, unknown, renderer.ReactTestRenderer, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImplementation<I, O>, testSpecifications: ISpec<I, O>, testInput: IInput) => Promise<import("../../../lib/core").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx/index.d.ts

@@ -0,0 +1,16 @@
+import renderer from "react-test-renderer";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = (props?: any) => JSX.Element;
+export type ISelection = renderer.ReactTestRenderer;
+export type IStore = renderer.ReactTestRenderer;
+export type ISubject = renderer.ReactTestRenderer;
+export type ITestImpl<I extends Ibdd_in<unknown, unknown, renderer.ReactTestRenderer, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestImplementation<I, O>;
+export type ITestSpec<I extends Ibdd_in<unknown, unknown, renderer.ReactTestRenderer, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+export declare const testInterface: {
+    butThen: (s: IStore, thenCB: any) => Promise<ISelection>;
+    beforeEach: (CComponent: any, props: any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: (any: any) => any) => Promise<renderer.ReactTestRenderer>;
+};

package/dist/types/SubPackages/react-test-renderer/jsx/node.d.ts

@@ -0,0 +1,9 @@
+import { Ibdd_in, Ibdd_out } from "../../../Types.js";
+import type { ITestImpl, ITestSpec } from "../jsx-promised";
+import { IInput } from "./index.js";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImpl<I, O>, testSpecifications: ITestSpec<I, O>, testInput: IInput, testInterface2?: {
+    butThen: (s: import("./index.js").IStore, thenCB: any) => Promise<import("./index.js").ISelection>;
+    beforeEach: (CComponent: any, props: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+    andWhen: (renderer: import("react-test-renderer").ReactTestRenderer, whenCB: (any: any) => any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+}) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx/web.d.ts

@@ -0,0 +1,9 @@
+import { Ibdd_in, Ibdd_out } from "../../../Types.js";
+import { ITestImpl, ITestSpec } from "../jsx-promised";
+import { IInput } from "./index.js";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImpl<I, O>, testSpecifications: ITestSpec<I, O>, testInput: IInput, testInterface2?: {
+    butThen: (s: import("./index.js").IStore, thenCB: any) => Promise<import("./index.js").ISelection>;
+    beforeEach: (CComponent: any, props: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+    andWhen: (renderer: import("react-test-renderer").ReactTestRenderer, whenCB: (any: any) => any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+}) => Promise<import("../../../lib/core.js").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx-promised/index.d.ts

@@ -0,0 +1,15 @@
+import renderer from "react-test-renderer";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../../Types";
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = Promise<JSX.Element>;
+export type ISelection = renderer.ReactTestRenderer;
+export type IStore = renderer.ReactTestRenderer;
+export type ISubject = renderer.ReactTestRenderer;
+export type ITestImpl<I extends Ibdd_in<renderer.ReactTestRenderer, renderer.ReactTestRenderer, renderer.ReactTestRenderer, renderer.ReactTestRenderer, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestImplementation<I, O>;
+export type ITestSpec<I extends Ibdd_in<renderer.ReactTestRenderer, renderer.ReactTestRenderer, renderer.ReactTestRenderer, renderer.ReactTestRenderer, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = ITestSpecification<I, O>;
+export declare const testInterface: {
+    beforeEach: (CComponent: any) => Promise<unknown>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: () => (any: any) => any) => Promise<renderer.ReactTestRenderer>;
+};

package/dist/types/SubPackages/react-test-renderer/jsx-promised/node.d.ts

@@ -0,0 +1,5 @@
+import { Ibdd_in, Ibdd_out } from "../../../Types";
+import { ITestImpl, ITestSpec } from "../../react/jsx";
+import { IInput } from ".";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImpl<I, O>, testSpecifications: ITestSpec<I, O>, testInput: IInput) => Promise<import("../../../lib/core").default<I, O>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx-promised/web.d.ts

@@ -0,0 +1,5 @@
+import { Ibdd_in, Ibdd_out } from "../../../Types";
+import { ITestImpl, ITestSpec } from "../../react/jsx";
+import { IInput } from "./index";
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: ITestImpl<I, O>, testSpecifications: ITestSpec<I, O>, testInput: IInput) => Promise<import("../../../lib/core").default<I, O>>;
+export default _default;

package/dist/types/Types.d.ts

@@ -0,0 +1,61 @@
+import { ITTestResourceConfiguration } from "./lib/index.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+import { PM } from "./PM/index.js";
+import { ITestCheckCallback } from "./lib/types.js";
+export type ITestInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = {
+    assertThis: (x: I["then"]) => void;
+    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITTestResourceConfiguration, pm: PM) => Promise<I["istore"]>;
+    butThen: (store: I["istore"], thenCB: I["then"], testResource: ITTestResourceConfiguration, pm: PM) => Promise<I["iselection"]>;
+    afterAll: (store: I["istore"], pm: PM) => any;
+    afterEach: (store: I["istore"], key: string, pm: PM) => Promise<unknown>;
+    beforeAll: (input: I["iinput"], testResource: ITTestResourceConfiguration, pm: PM) => Promise<I["isubject"]>;
+    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<I["istore"]>;
+};
+export type IWebTestInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = ITestInterface<I>;
+export type INodeTestInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = ITestInterface<I>;
+export type IPartialInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Partial<ITestInterface<I>>;
+export type IPartialNodeInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Partial<INodeTestInterface<I>>;
+export type IPartialWebInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Partial<IWebTestInterface<I>>;
+export type ITestSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (Suite: {
+    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I, O>[]) => BaseSuite<I, O>;
+}, Given: {
+    [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
+}, When: {
+    [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
+}, Then: {
+    [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
+}, Check: ITestCheckCallback<I, O>) => any[];
+export type ITestImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = {
+    suites: {
+        [K in keyof O["suites"]]: string;
+    };
+    givens: {
+        [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
+    };
+    checks: {
+        [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+    };
+};
+export type Modify<T, R> = Omit<T, keyof R> & R;
+export type Ibdd_out<ISuites extends Record<string, any>, IGivens extends Record<string, any>, IWhens extends Record<string, any>, IThens extends Record<string, any>, IChecks extends Record<string, any>> = {
+    suites: ISuites;
+    givens: IGivens;
+    whens: IWhens;
+    thens: IThens;
+    checks: IChecks;
+};
+export type Ibdd_in<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen> = {
+    iinput: IInput;
+    isubject: ISubject;
+    istore: IStore;
+    iselection: ISelection;
+    given: IGiven;
+    when: IWhen;
+    then: IThen;
+};

package/dist/types/Web.d.ts

@@ -0,0 +1,9 @@
+import type { Ibdd_in, Ibdd_out, ITestImplementation, ITestInterface, ITestSpecification, IWebTestInterface } from "./Types";
+import Testeranto from "./lib/core.js";
+import { IFinalResults, ITTestResourceRequest } from "./lib/index.js";
+export declare class WebTesteranto<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<I, O> {
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<I>>);
+    receiveTestResourceConfig(partialTestResource: any): Promise<IFinalResults>;
+}
+declare const _default: <I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O>, testInterface: Partial<IWebTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O>>;
+export default _default;

package/dist/types/build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/defaultConfig.d.ts

@@ -0,0 +1,3 @@
+import { IBaseConfig } from "./lib";
+declare const config: IBaseConfig;
+export default config;

package/dist/types/esbuildConfigs/eslint-formatter-testeranto.d.ts

@@ -0,0 +1,2 @@
+import { LintResult } from "eslint/lib/linter";
+export default function (results: LintResult[]): string;

package/dist/types/esbuildConfigs/featuresPlugin.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    name: string;
+    setup(build: any): void;
+};
+export default _default;

package/dist/types/esbuildConfigs/index.d.ts

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../lib";
+declare const _default: (config: IBaseConfig) => BuildOptions;
+export default _default;

package/dist/types/esbuildConfigs/inputFilesPlugin.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "esbuild";
+declare const _default: (platform: "web" | "node", entryPoints: Set<string> | string[]) => {
+    register: (entrypoint: string, sources: string[]) => void;
+    inputFilesPluginFactory: Plugin;
+};
+export default _default;

package/dist/types/esbuildConfigs/node.d.ts

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../lib/index.js";
+declare const _default: (config: IBaseConfig, entryPoints: Set<string> | string[]) => BuildOptions;
+export default _default;

package/dist/types/esbuildConfigs/web.d.ts

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../lib/index.js";
+declare const _default: (config: IBaseConfig, entryPoints: Set<string> | string[]) => BuildOptions;
+export default _default;

package/dist/types/init-docs.d.ts

@@ -0,0 +1 @@
+export {};