testeranto 0.94.0 → 0.110.0

package/dist/types/{src/PM → PM}/node.d.ts

@@ -1,23 +1,28 @@
-/// <reference types="node" />
-/// <reference types="node" />
+import { ScreencastOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM } from "./index.js";
-declare type PuppetMasterServer = Record<string, Promise<any>>;
+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;
-    screencast(opts: object): void;
-    isDisabled(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;
-    customScreenShot(opts: object): any;
+    screencast(opts: ScreencastOptions, page: CdpPage): any;
+    screencastStop(p: string): any;
+    customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage): any;
     existsSync(destFolder: string): boolean;
     mkdirSync(): any;
     write(writeObject: {

package/dist/types/{src/PM → PM}/web.d.ts

@@ -1,16 +1,20 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM } from "./index.js";
-import { ScreenshotOptions } from "puppeteer-core";
-declare type PuppetMasterServer = Record<string, Promise<any>>;
+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;
-    screencast(opts: object): void;
-    isDisabled(selector: string): boolean;
+    isDisabled(selector: string): Promise<boolean>;
     getAttribute(selector: string, attribute: string): any;
     getValue(selector: string): any;
     focusOn(selector: string): any;
@@ -19,7 +23,7 @@ export declare class PM_Web extends PM {
     click(selector: string): any;
     customScreenShot(opts: ScreenshotOptions): any;
     existsSync(destFolder: string): boolean;
-    mkdirSync(): any;
+    mkdirSync(x: any): any;
     write(writeObject: {
         uid: number;
     }, contents: string): any;

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/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/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/{src/esbuildConfigs → esbuildConfigs}/index.d.ts

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

package/dist/types/{src/esbuildConfigs → esbuildConfigs}/inputFilesPlugin.d.ts

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

package/dist/types/{src/esbuildConfigs → esbuildConfigs}/node.d.ts

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

package/dist/types/{src/esbuildConfigs → esbuildConfigs}/web.d.ts

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

package/dist/types/lib/abstractBase.d.ts

@@ -0,0 +1,110 @@
+import { PM } from "../PM/index.js";
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { Ibdd_in, Ibdd_out } from "../Types.js";
+export type IGivens<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Record<string, BaseGiven<I>>;
+export declare abstract class BaseSuite<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>>> {
+    name: string;
+    givens: IGivens<I>;
+    checks: BaseCheck<I, O>[];
+    store: I["istore"];
+    fails: BaseGiven<I>[];
+    testResourceConfiguration: ITTestResourceConfiguration;
+    index: number;
+    constructor(name: string, index: number, givens?: IGivens<I>, checks?: BaseCheck<I, O>[]);
+    features(): string[];
+    toObj(): {
+        name: string;
+        givens: {
+            key: string;
+            name: string;
+            whens: {
+                name: string;
+                error: boolean;
+            }[];
+            thens: {
+                name: string;
+                error: boolean;
+            }[];
+            error: (string | Error | undefined)[] | null;
+            features: string[];
+        }[];
+        fails: BaseGiven<I>[];
+        features: string[];
+    };
+    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: PM): Promise<I["isubject"]>;
+    assertThat(t: I["then"]): unknown;
+    afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: PM): I["istore"];
+    run(input: I["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: PM): Promise<BaseSuite<I, O>>;
+}
+export declare abstract class BaseGiven<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+    name: string;
+    features: string[];
+    whens: BaseWhen<I>[];
+    thens: BaseThen<I>[];
+    error: Error;
+    fail: any;
+    store: I["istore"];
+    recommendedFsPath: string;
+    givenCB: I["given"];
+    initialValues: any;
+    key: string;
+    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"], initialValues: any);
+    beforeAll(store: I["istore"], initializer: any, artifactory: any, testResource: any, initialValues: any, pm: any): I["istore"];
+    toObj(): {
+        key: string;
+        name: string;
+        whens: {
+            name: string;
+            error: boolean;
+        }[];
+        thens: {
+            name: string;
+            error: boolean;
+        }[];
+        error: (string | Error | undefined)[] | null;
+        features: string[];
+    };
+    abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: PM): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: PM): Promise<unknown>;
+    abstract uberCatcher(e: any): any;
+    give(subject: I["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: PM, suiteNdx: number): Promise<I["istore"]>;
+}
+export declare abstract class BaseWhen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+    name: string;
+    whenCB: (x: I["iselection"]) => I["then"];
+    error: boolean;
+    constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
+    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: PM): Promise<any>;
+    toObj(): {
+        name: string;
+        error: boolean;
+    };
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<any>;
+}
+export declare abstract class BaseThen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+    name: string;
+    thenCB: (storeState: I["iselection"]) => I["then"];
+    error: boolean;
+    constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]);
+    toObj(): {
+        name: string;
+        error: boolean;
+    };
+    abstract butThen(store: I["istore"], thenCB: any, testResourceConfiguration: ITTestResourceConfiguration, pm: PM): Promise<I["iselection"]>;
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<I["then"] | undefined>;
+}
+export declare abstract class BaseCheck<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>>> {
+    name: string;
+    features: string[];
+    checkCB: (whens: any, thens: any) => any;
+    whens: {
+        [K in keyof O["whens"]]: (p: any, tc: any) => BaseWhen<I>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (p: any, tc: any) => BaseThen<I>;
+    };
+    constructor(name: string, features: string[], checkCB: (whens: any, thens: any) => any, whens: any, thens: any);
+    abstract checkThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, pm: PM): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, cb: any, pm: PM): Promise<unknown>;
+    check(subject: I["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, pm: PM): Promise<void>;
+}

package/dist/types/lib/basebuilder.d.ts

@@ -0,0 +1,27 @@
+import { ITTestResourceRequest, ITestJob } from ".";
+import { Ibdd_in, Ibdd_out, ITestSpecification } from "../Types.js";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
+import { PM } from "../PM/index.js";
+export declare abstract class BaseBuilder<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>>, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+    readonly input: I["iinput"];
+    specs: any;
+    assertThis: (t: I["then"]) => {};
+    testResourceRequirement: ITTestResourceRequest;
+    artifacts: Promise<unknown>[];
+    testJobs: ITestJob[];
+    testSpecification: ITestSpecification<I, O>;
+    suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>;
+    givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>;
+    whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>;
+    thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>;
+    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I, O>>;
+    puppetMaster: PM;
+    constructor(input: I["iinput"], suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>, givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>, whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>, thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>, checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I, O>>, testResourceRequirement: ITTestResourceRequest, testSpecification: any);
+    Specs(): any;
+    Suites(): Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>;
+    Given(): Record<keyof GivenExtensions, (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], gcb: any) => BaseGiven<I>>;
+    When(): Record<keyof WhenExtensions, (arg0: I["istore"], ...arg1: any) => BaseWhen<I>>;
+    Then(): Record<keyof ThenExtensions, (selection: I["iselection"], expectation: any) => BaseThen<I>>;
+    Check(): Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, whens: any, thens: any, x: any) => BaseCheck<I, O>>;
+}

package/dist/types/lib/classBuilder.d.ts

@@ -0,0 +1,7 @@
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../Types.js";
+import { BaseBuilder } from "./basebuilder.js";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { ITTestResourceRequest } from "./index.js";
+export declare abstract class ClassBuilder<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 BaseBuilder<I, O, any, any, any, any, any> {
+    constructor(testImplementation: ITestImplementation<I, O>, testSpecification: ITestSpecification<I, O>, input: I["iinput"], suiteKlasser: ISuiteKlasser<I, O>, givenKlasser: IGivenKlasser<I>, whenKlasser: IWhenKlasser<I>, thenKlasser: IThenKlasser<I>, checkKlasser: ICheckKlasser<I, O>, testResourceRequirement: ITTestResourceRequest);
+}

package/dist/types/lib/core.d.ts

@@ -0,0 +1,7 @@
+import { ITestSpecification, ITestImplementation, ITestInterface, Ibdd_in, Ibdd_out } from "../Types.js";
+import { IFinalResults, ITTestResourceRequest } from "./index.js";
+import { ClassBuilder } from "./classBuilder.js";
+export default abstract class Testeranto<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 ClassBuilder<I, O> {
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<I>>, uberCatcher: (cb: any) => void);
+    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
+}