testeranto 0.70.0 → 0.73.0

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

@@ -0,0 +1,19 @@
+import { Browser } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+export declare abstract class PM {
+    server: any;
+    browser: Browser;
+    testResourceConfiguration: ITTestResourceConfiguration;
+    abstract startPuppeteer(options: any, destfolder: string): Promise<Browser>;
+    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
+    abstract createWriteStream(filepath: string): any;
+    abstract writeFileSync(fp: string, contents: string): any;
+    abstract mkdirSync(): any;
+    abstract existsSync(fp: string): boolean;
+    abstract write(accessObject: {
+        uid: number;
+    }, contents: string): boolean;
+    abstract end(accessObject: {
+        uid: number;
+    }): boolean;
+}

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import fs from "fs";
+import { PassThrough } from "stream";
+import { ITLog } from "../lib";
+import { IBuiltConfig } from "../lib/types";
+import { PM } from "./index.js";
+export declare class PM_Main extends PM {
+    configs: IBuiltConfig;
+    ports: Record<number, boolean>;
+    queue: any[];
+    constructor(configs: IBuiltConfig);
+    startPuppeteer(options: any, destfolder: string): Promise<any>;
+    launchNode: (src: string, dest: string) => Promise<void>;
+    launchWeb: (t: string, dest: string) => 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;
+}

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+declare type PuppetMasterServer = Record<string, Promise<any>>;
+export declare function addPageBinding(type: string, name: string, prefix: string): void;
+export declare class PM_Node extends PM {
+    server: PuppetMasterServer;
+    testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(t: ITTestResourceConfiguration);
+    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): Promise<any>;
+}
+export {};

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+declare type PuppetMasterServer = Record<string, Promise<any>>;
+export declare class PM_Web extends PM {
+    server: PuppetMasterServer;
+    constructor(t: ITTestResourceConfiguration);
+    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, destFolder: string): Promise<any>;
+}
+export {};

package/dist/types/Reporter.d.ts

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

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

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

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

@@ -1,6 +1,6 @@
 import { IBaseTest } from "../Types";
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IUtils } from "./types";
+import { PM } from "../PM/index.js";
 export declare type IGivens<ITestShape extends IBaseTest> = Record<string, BaseGiven<ITestShape>>;
 export declare abstract class BaseSuite<ITestShape extends IBaseTest> {
     name: string;
@@ -28,9 +28,10 @@ export declare abstract class BaseSuite<ITestShape extends IBaseTest> {
         }[];
         fails: BaseGiven<ITestShape>[];
     };
-    setup(s: ITestShape["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, utils: IUtils): Promise<ITestShape["isubject"]>;
+    setup(s: ITestShape["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: PM): Promise<ITestShape["isubject"]>;
     assertThat(t: ITestShape["then"]): unknown;
-    run(input: ITestShape["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, utils: IUtils): Promise<BaseSuite<ITestShape>>;
+    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> {
     name: string;
@@ -38,13 +39,13 @@ export declare abstract class BaseGiven<ITestShape extends IBaseTest> {
     whens: BaseWhen<ITestShape>[];
     thens: BaseThen<ITestShape>[];
     error: Error;
+    fail: any;
     store: ITestShape["istore"];
     recommendedFsPath: string;
     givenCB: ITestShape["given"];
     initialValues: any;
     constructor(name: string, features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], givenCB: ITestShape["given"], initialValues: any);
     beforeAll(store: ITestShape["istore"], artifactory: ITestArtifactory): ITestShape["istore"];
-    afterAll(store: ITestShape["istore"], artifactory: ITestArtifactory, utils: IUtils): ITestShape["istore"];
     toObj(): {
         name: string;
         whens: {
@@ -58,21 +59,21 @@ export declare abstract class BaseGiven<ITestShape extends IBaseTest> {
         error: (string | Error | undefined)[] | null;
         features: string[];
     };
-    abstract givenThat(subject: ITestShape["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: ITestShape["given"]): Promise<ITestShape["istore"]>;
-    afterEach(store: ITestShape["istore"], key: string, artifactory: ITestArtifactory, utils: IUtils): Promise<unknown>;
-    give(subject: ITestShape["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, utils: IUtils): Promise<ITestShape["istore"]>;
+    abstract givenThat(subject: ITestShape["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: ITestShape["given"], pm: PM): Promise<ITestShape["istore"]>;
+    afterEach(store: ITestShape["istore"], key: string, artifactory: ITestArtifactory, pm: PM): Promise<unknown>;
+    give(subject: ITestShape["isubject"], key: string, testResourceConfiguration: any, 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): any;
+    abstract andWhen(store: ITestShape["istore"], whenCB: (x: ITestShape["iselection"]) => ITestShape["then"], testResource: any, pm: PM): any;
     toObj(): {
         name: string;
         error: boolean;
     };
-    test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, utils: IUtils): Promise<any>;
+    test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, key: string): Promise<any>;
 }
 export declare abstract class BaseThen<ITestShape extends IBaseTest> {
     name: string;
@@ -84,7 +85,7 @@ export declare abstract class BaseThen<ITestShape extends IBaseTest> {
         error: boolean;
     };
     abstract butThen(store: ITestShape["istore"], thenCB: any, testResourceConfiguration?: any): Promise<ITestShape["iselection"]>;
-    test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, utils: IUtils): Promise<ITestShape["then"] | undefined>;
+    test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM): Promise<ITestShape["then"] | undefined>;
 }
 export declare abstract class BaseCheck<ITestShape extends IBaseTest> {
     name: string;
@@ -98,6 +99,6 @@ export declare abstract class BaseCheck<ITestShape extends IBaseTest> {
     };
     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, utils: IUtils): Promise<unknown>;
-    check(subject: ITestShape["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, utils: IUtils): Promise<void>;
+    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/lib/basebuilder.d.ts

@@ -1,7 +1,8 @@
-import { ITTestResourceRequest, ITestJob, ILogWriter } from ".";
+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, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
     readonly input: ITestShape["iinput"];
     specs: any;
@@ -15,7 +16,8 @@ export declare abstract class BaseBuilder<ITestShape extends IBaseTest, SuiteExt
     whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>;
     thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>;
     checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>;
-    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>>, logWriter: ILogWriter, testResourceRequirement: ITTestResourceRequest, testSpecification: any);
+    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>>;

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

@@ -1,7 +1,7 @@
 import { IBaseTest, ITestImplementation, ITestSpecification } from "../Types.js";
 import { BaseBuilder } from "./basebuilder.js";
-import { ILogWriter, ITTestResourceRequest } from ".";
 import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { ITTestResourceRequest } from "./index.js";
 export declare abstract class ClassBuilder<ITestShape extends IBaseTest> 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, logWriter: ILogWriter);
+    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/lib/core.d.ts

@@ -1,8 +1,8 @@
 import { IBaseTest, ITestSpecification, ITestImplementation } from "../Types.js";
-import { ITestInterface, IUtils } from "./types.js";
-import { ILogWriter, ITTestResourceConfiguration, ITTestResourceRequest, ITestJob } from "./index.js";
+import { ITestInterface } from "./types.js";
+import { ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
 export default abstract class Testeranto<ITestShape extends IBaseTest> extends ClassBuilder<ITestShape> {
-    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, logWriter: ILogWriter, testInterface: Partial<ITestInterface<ITestShape>>);
-    abstract receiveTestResourceConfig(t: ITestJob, partialTestResource: ITTestResourceConfiguration, utils: IUtils): any;
+    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<ITestShape>>);
+    abstract receiveTestResourceConfig(partialTestResource: string): any;
 }

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

@@ -1,13 +1,14 @@
+import { PM } from "../PM/index.js";
 import { IBaseTest } from "../Types.js";
 import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
-import { INodeUtils, ITestInterface, IWebUtils } from "./types.js";
+import { ITestInterface } from "./types.js";
 export declare const BaseTestInterface: ITestInterface<IBaseTest>;
 export declare const DefaultTestInterface: (p: Partial<ITestInterface<any>>) => ITestInterface<any>;
 export declare type ITTestResourceConfiguration = {
     name: string;
     fs: string;
     ports: number[];
-    scheduled: boolean;
+    browserWSEndpoint: string;
 };
 export declare type ITTestResourceRequirement = {
     name: string;
@@ -21,7 +22,7 @@ export declare type ITLog = (...string: any[]) => void;
 export declare type ILogWriter = {
     createWriteStream: (line: string) => any | any;
     writeFileSync: (fp: string, contents: string) => any;
-    mkdirSync: (fp: 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;
@@ -32,12 +33,12 @@ declare type ITest = {
     checks: BaseCheck<IBaseTest>[];
     testResourceConfiguration: ITTestResourceConfiguration;
 };
-export declare type ITestJob<T = INodeUtils | IWebUtils> = {
+export declare type ITestJob<T = PM> = {
     toObj(): object;
     test: ITest;
     runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IBaseTest>>;
     testResourceRequirement: ITTestResourceRequirement;
-    receiveTestResourceConfig: (testResource: any, utils: T) => Promise<{
+    receiveTestResourceConfig: (pm: PM) => Promise<{
         failed: number;
         artifacts: Promise<unknown>[];
         logPromise: Promise<unknown>;

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

@@ -1,10 +1,11 @@
-/// <reference types="electron" />
 import { IBaseTest } from "../Types";
-import puppeteer from "puppeteer-core";
 import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 import { ITTestResourceConfiguration, ITestArtificer } from ".";
+import { PM } from "../PM/index";
 export declare type IRunTime = `node` | `web`;
-export declare type ITestTypes = [string, IRunTime, ITestTypes[]];
+export declare type ITestTypes = [string, IRunTime, {
+    ports: number;
+}, ITestTypes[]];
 export declare type IJsonConfig = {
     outdir: string;
     tests: ITestTypes[];
@@ -27,41 +28,32 @@ export declare type IBaseConfig = {
 export declare type IBuiltConfig = {
     buildDir: string;
 } & IBaseConfig;
-export declare type INodeUtils = {
-    browser: puppeteer.Browser;
-    ipc: Electron.ParentPort;
-};
-export declare type IWebUtils = {
-    browser: puppeteer.Browser;
-    ipc: Electron.IpcRenderer;
-};
-export declare type IUtils = INodeUtils | IWebUtils;
 export declare type IWebTestInterface<ITestShape extends IBaseTest> = {
     assertThis: (x: ITestShape["then"]) => void;
     andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration) => Promise<ITestShape["istore"]>;
     butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
-    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, browser: IWebUtils) => any;
-    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: IWebUtils) => Promise<unknown>;
-    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: IWebUtils) => Promise<ITestShape["isubject"]>;
-    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
+    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<ITestShape extends IBaseTest> = {
     assertThis: (x: ITestShape["then"]) => void;
     andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration) => Promise<ITestShape["istore"]>;
     butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
-    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, utils: INodeUtils) => any;
-    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: INodeUtils) => Promise<unknown>;
-    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: INodeUtils) => Promise<ITestShape["isubject"]>;
+    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, pm: PM) => any;
+    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, pm: PM) => Promise<unknown>;
+    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, pm: PM) => Promise<ITestShape["isubject"]>;
     beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
 };
 export declare type ITestInterface<ITestShape extends IBaseTest> = {
     assertThis: (x: ITestShape["then"]) => void;
-    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration) => Promise<ITestShape["istore"]>;
+    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration, pm: PM) => Promise<ITestShape["istore"]>;
     butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
-    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, utils: IUtils) => any;
-    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: IUtils) => Promise<unknown>;
-    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: IUtils) => Promise<ITestShape["isubject"]>;
-    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
+    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, pm: PM) => any;
+    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, pm: PM) => Promise<unknown>;
+    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, pm: PM) => Promise<ITestShape["isubject"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<ITestShape["istore"]>;
 };
 export declare type ISuiteKlasser<ITestShape extends IBaseTest> = (name: string, index: number, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
 export declare type IGivenKlasser<ITestShape extends IBaseTest> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<ITestShape>;

package/dist/types/preload.d.ts

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