testeranto 0.100.0 → 0.110.0

package/dist/types/dist/module/src/Init.d.ts

@@ -1,2 +0,0 @@
-declare function _default(partialConfig: any): Promise<void>;
-export default _default;

package/dist/types/src/Node.d.ts

@@ -1,13 +0,0 @@
-import Testeranto from "./lib/core.js";
-import { ITTestResourceRequest } from "./lib/index.js";
-import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types.js";
-import { ITestInterface } from "./lib/types.js";
-export declare class NodeTesteranto<TestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<TestShape> {
-    constructor(input: TestShape["iinput"], testSpecification: ITestSpecification<TestShape>, testImplementation: ITestImplementation<TestShape>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<TestShape>>);
-    receiveTestResourceConfig(partialTestResource: string): Promise<{
-        features: string[];
-        failed: number;
-    }>;
-}
-declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: any, testInterface: INodeTestInterface<ITestShape>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
-export default _default;

package/dist/types/src/SubPackages/puppeteer.d.ts

@@ -1,6 +0,0 @@
-import { IBaseTest, IPartialNodeInterface, ITestImplementation, ITestSpecification } from "../Types";
-declare type IInput = string;
-export declare type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec>;
-export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
-declare const _default: <ITestShape extends any>(testInput: IInput, testSpecifications: ISpec<ITestShape>, testImplementations: any, testInterface?: Partial<import("../Types").INodeTestInterface<ITestShape>> | undefined) => Promise<import("../lib/core.js").default<ITestShape>>;
-export default _default;

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

@@ -1,7 +0,0 @@
-import React from "react";
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
-declare type IInput = typeof React.Component;
-export declare type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<ISpec, object>;
-export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
-declare const _default: <ITestShape extends any, IState>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
-export default _default;

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

@@ -1,7 +0,0 @@
-import React from "react";
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
-declare type IInput = typeof React.Component;
-export declare type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<ISpec, object>;
-export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
-export default _default;

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

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

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

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

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

@@ -1,4 +0,0 @@
-import { IPartialWebInterface } from "../../../Types";
-import { ITestSpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../Types").IWebTestInterface<ITestShape>>) => Promise<import("../../../lib/core").default<ITestShape>>;
-export default _default;

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

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

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

@@ -1,11 +0,0 @@
-import React from "react";
-import ReactDom from "react-dom/client";
-import { IPartialWebInterface, ITestImplementation, ITestSpecification } from "../../../Types";
-declare type IInput = typeof React.Component;
-export declare type IStore = {
-    htmlElement: HTMLElement;
-    reactElement: any;
-    domRoot: ReactDom.Root;
-};
-declare const _default: <ITestShape extends any, IWhen, IGiven>(testInput: IInput, testSpecifications: ITestSpecification<ITestShape>, testImplementations: ITestImplementation<ITestShape, any>, testInterface?: IPartialWebInterface<any>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
-export default _default;

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

@@ -1,7 +0,0 @@
-/// <reference types="react" />
-export declare type IInput = (props?: any) => JSX.Element;
-export declare type IState = unknown;
-export declare type ISelection = HTMLElement;
-export declare type IStore = HTMLElement;
-export declare type IWhenShape = any;
-export declare type IThenShape = any;

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

@@ -1,6 +0,0 @@
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream';
-import { ITestImplementation, ITestSpecification } from "../../../Types";
-export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, any>, testSpecifications: ITestSpecification<ITestShape>, testInput: ITestShape["iinput"]) => Promise<import("../../../lib/core.js").default<ITestShape>>;
-export default _default;

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

@@ -1,5 +0,0 @@
-import { ITestSpecification } from "../../../Types";
-import type { IInput } from "./index";
-export declare type ISubject = HTMLElement;
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
-export default _default;

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

@@ -1,5 +0,0 @@
-import React from "react";
-import { ITestSpecification } from "../../../Types";
-declare type IInput = React.MemoExoticComponent<() => JSX.Element>;
-declare const _default: <ITestShape extends any, PropShape>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
-export default _default;

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

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

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

@@ -1,8 +0,0 @@
-/// <reference types="react" />
-import { ISpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: {
-    new (props: IProps | Readonly<IProps>): import("react").Component<IProps, IState, any>;
-    new (props: IProps, context: any): import("react").Component<IProps, IState, any>;
-    contextType?: import("react").Context<any> | undefined;
-}) => Promise<import("../../../lib/core.js").default<ITestShape>>;
-export default _default;

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

@@ -1,3 +0,0 @@
-import { ISpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput<any, any>) => Promise<import("../../../lib/core").default<ITestShape>>;
-export default _default;

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

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

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

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

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

@@ -1,17 +0,0 @@
-/// <reference types="react" />
-import renderer from "react-test-renderer";
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
-export declare type IWhenShape = any;
-export declare type IThenShape = any;
-export declare type InitialState = unknown;
-export declare type IInput = (props?: any) => JSX.Element;
-export declare type ISelection = renderer.ReactTestRenderer;
-export declare type IStore = renderer.ReactTestRenderer;
-export declare type ISubject = renderer.ReactTestRenderer;
-export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape, object>;
-export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
-export declare const testInterface: {
-    butThen: (s: IStore, thenCB: any, tr: 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/src/SubPackages/react-test-renderer/jsx/node.d.ts

@@ -1,9 +0,0 @@
-import { IBaseTest } from "../../../Types";
-import type { ITestSpec } from "../jsx-promised";
-import { IInput } from "./index.js";
-declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
-    butThen: (s: import("react-test-renderer").ReactTestRenderer, thenCB: any, tr: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
-    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<ITestShape>>;
-export default _default;

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

@@ -1,8 +0,0 @@
-import { ITestSpec } from "../jsx-promised";
-import { IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
-    butThen: (s: import("react-test-renderer").ReactTestRenderer, thenCB: any, tr: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
-    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").default<ITestShape>>;
-export default _default;

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

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

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

@@ -1,4 +0,0 @@
-import { IInput } from ".";
-import { ITestSpec } from "../../react/jsx";
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
-export default _default;

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

@@ -1,4 +0,0 @@
-import { ITestSpec } from "../../react/jsx";
-import { IInput } from "./index";
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
-export default _default;

package/dist/types/src/Types.d.ts

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

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

package/dist/types/src/defaultConfig.d.ts

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-import { IBaseTest, 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<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends BaseBuilder<ITestShape, any, any, any, any, any> {
-    constructor(testImplementation: ITestImplementation<ITestShape, any>, testSpecification: ITestSpecification<ITestShape>, input: ITestShape["iinput"], suiteKlasser: ISuiteKlasser<ITestShape>, givenKlasser: IGivenKlasser<ITestShape>, whenKlasser: IWhenKlasser<ITestShape>, thenKlasser: IThenKlasser<ITestShape>, checkKlasser: ICheckKlasser<ITestShape>, testResourceRequirement: ITTestResourceRequest);
-}

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

@@ -1,8 +0,0 @@
-import { IBaseTest, ITestSpecification, ITestImplementation } from "../Types.js";
-import { IFinalResults, ITestInterface } from "./types.js";
-import { ITTestResourceRequest } from "./index.js";
-import { ClassBuilder } from "./classBuilder.js";
-export default abstract class Testeranto<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends ClassBuilder<ITestShape> {
-    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<ITestShape>>, uberCatcher: (cb: any) => void);
-    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
-}

package/dist/types/src/lib/index.d.ts

@@ -1,60 +0,0 @@
-import { PM } from "../PM/index.js";
-import { IBaseTest } from "../Types.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
-import { ITestInterface } from "./types.js";
-export declare const BaseTestInterface: ITestInterface<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
-export declare const DefaultTestInterface: (p: ITestInterface<any>) => ITestInterface<any>;
-export declare type ITTestResourceConfiguration = {
-    name: string;
-    fs: string;
-    ports: number[];
-    browserWSEndpoint: string;
-};
-export declare type ITTestResourceRequirement = {
-    name: string;
-    ports: number;
-    fs: string;
-};
-export declare type ITTestResourceRequest = {
-    ports: number;
-};
-export declare type ITLog = (...string: any[]) => void;
-export declare type ILogWriter = {
-    createWriteStream: (line: string) => any | any;
-    writeFileSync: (fp: string, contents: string) => any;
-    mkdirSync: () => any;
-    testArtiFactoryfileWriter: (tLog: ITLog, n: (Promise: any) => void) => (fPath: string, value: unknown) => void;
-};
-export declare type ITestArtificer = (key: string, data: any) => void;
-declare type ITest = {
-    toObj(): object;
-    name: string;
-    givens: IGivens<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
-    checks: BaseCheck<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>[];
-    testResourceConfiguration: ITTestResourceConfiguration;
-};
-export declare type ITestJob<T = PM> = {
-    toObj(): object;
-    test: ITest;
-    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>>;
-    testResourceRequirement: ITTestResourceRequirement;
-    receiveTestResourceConfig: (pm: PM) => Promise<{
-        failed: number;
-        artifacts: Promise<unknown>[];
-        logPromise: Promise<unknown>;
-        features: string[];
-    }>;
-};
-export declare type ITestResults = Promise<{
-    test: ITest;
-}>[];
-export declare const defaultTestResourceRequirement: ITTestResourceRequest;
-export declare type ITestArtifactory = (key: string, value: unknown) => unknown;
-export declare type ITestCheckCallback<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = {
-    [K in keyof ITestShape["checks"]]: (name: string, features: string[], callbackA: (whens: {
-        [K in keyof ITestShape["whens"]]: (...unknown: any[]) => BaseWhen<ITestShape>;
-    }, thens: {
-        [K in keyof ITestShape["thens"]]: (...unknown: any[]) => BaseThen<ITestShape>;
-    }) => Promise<any>, ...xtrasA: ITestShape["checks"][K]) => BaseCheck<ITestShape>;
-};
-export {};