testeranto 0.203.0 → 0.205.0

package/dist/types/src/app/frontend/testPage/TestPageView_utils.d.ts

@@ -0,0 +1,23 @@
+type TestData = {
+    name: string;
+    givens: {
+        name: string;
+        whens: {
+            name: string;
+            error?: string;
+            features?: string[];
+            artifacts?: string[];
+        }[];
+        thens: {
+            name: string;
+            error?: string;
+            features?: string[];
+            artifacts?: string[];
+        }[];
+        features?: string[];
+        artifacts?: string[];
+    }[];
+};
+export declare const getLanguage: (path: string) => "python" | "json" | "typescript" | "javascript" | "markdown" | "plaintext";
+export declare const renderTestResults: (testData: TestData, buildErrors: any, projectName: any, testName: any, runtime: any) => JSX.Element;
+export {};

package/dist/types/src/app/frontend/useFs.d.ts

@@ -0,0 +1,2 @@
+export declare const FileServiceContext: import("react").Context<any>;
+export declare const useFs: () => any;

package/dist/types/src/app/frontend/useGitMode.d.ts

@@ -0,0 +1,7 @@
+export declare const useGitMode: () => {
+    mode: "dev" | "static" | "git";
+    setMode: import("react").Dispatch<import("react").SetStateAction<"dev" | "static" | "git">>;
+    isStatic: boolean;
+    isDev: boolean;
+    isGit: boolean;
+};

package/dist/types/src/app/frontend/useTerminalWebSocket.d.ts

@@ -0,0 +1,4 @@
+import { Process } from "./components/pure/ProcessManagerViewTypes";
+export declare const useTerminalWebSocket: (ws: WebSocket | null, selectedProcess: Process | null) => {
+    processLogs: string[];
+};

package/dist/types/src/app/frontend/useWebSocket.d.ts

@@ -0,0 +1,8 @@
+interface WebSocketContextType {
+    ws: WebSocket | null;
+    isConnected: boolean;
+    sendMessage: (message: any) => void;
+}
+export declare const WebSocketContext: import("react").Context<WebSocketContextType>;
+export declare const useWebSocket: () => WebSocketContextType;
+export {};

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

@@ -0,0 +1 @@
+export type IMode = "once" | "dev";

package/dist/types/src/builders/golang.d.ts

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

package/dist/types/src/builders/node.d.ts

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

package/dist/types/src/builders/python.d.ts

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

package/dist/types/src/builders/web.d.ts

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

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

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

package/dist/types/src/esbuildConfigs/consoleDetectorPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare const consoleDetectorPlugin: Plugin;

package/dist/types/src/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/featuresPlugin.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+import type { Plugin } from "esbuild";
+import { IRunTime } from "../lib";
+declare const _default: (platform: IRunTime, testName: string) => {
+    register: (entrypoint: string, sources: string[]) => void;
+    inputFilesPluginFactory: Plugin;
+};
+export default _default;

package/dist/types/src/esbuildConfigs/nativeImportDetectorPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare const nativeImportDetectorPlugin: Plugin;

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

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

package/dist/types/src/esbuildConfigs/pure.d.ts

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

package/dist/types/src/esbuildConfigs/rebuildPlugin.d.ts

@@ -0,0 +1,6 @@
+import { IRunTime } from "../lib";
+declare const _default: (r: IRunTime) => {
+    name: string;
+    setup: (build: any) => void;
+};
+export default _default;

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

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

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

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

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

@@ -0,0 +1,44 @@
+import type { Ibdd_in_any } from "../CoreTypes";
+import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
+import { IPM } from "./types.js";
+/**
+ * Represents a collection of Given conditions keyed by their names.
+ * Givens are typically organized as named collections because:
+ * - They set up different initial states for tests
+ * - Tests often need to reference specific Given conditions by name
+ * - This allows for better organization and reuse of setup logic
+ * - The BDD pattern often involves multiple named Given scenarios
+ */
+export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
+export declare abstract class BaseGiven<I extends Ibdd_in_any> {
+    features: string[];
+    whens: any[];
+    thens: any[];
+    error: Error;
+    fail: any;
+    store: I["istore"];
+    recommendedFsPath: string;
+    givenCB: I["given"];
+    initialValues: any;
+    key: string;
+    failed: boolean;
+    artifacts: string[];
+    status: boolean | undefined;
+    addArtifact(path: string): void;
+    constructor(features: string[], whens: any[], thens: any[], givenCB: I["given"], initialValues: any);
+    beforeAll(store: I["istore"]): I["istore"];
+    toObj(): {
+        key: string;
+        whens: any[];
+        thens: any[];
+        error: (string | Error | undefined)[] | null;
+        failed: boolean;
+        features: string[];
+        artifacts: string[];
+        status: boolean | undefined;
+    };
+    abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: IPM): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: IPM): Promise<I["istore"]>;
+    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: IPM, suiteNdx: number): Promise<I["istore"]>;
+}

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

@@ -0,0 +1,47 @@
+import { ITTestResourceConfiguration, ITestArtifactory } from ".";
+import { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+import { IGivens } from "./BaseGiven";
+import { IPM } from "./types";
+/**
+ * Represents a collection of test suites keyed by their names.
+ * Suites are organized as named collections because:
+ * - Tests are typically grouped into logical suites (e.g., by feature, component)
+ * - Suites may have different configurations or setup requirements
+ * - Named suites allow for selective test execution and better reporting
+ * - This supports the hierarchical structure of test organization
+ */
+export type ISuites<I extends Ibdd_in_any, O extends Ibdd_out_any> = Record<string, BaseSuite<I, O>>;
+export declare abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
+    name: string;
+    givens: IGivens<I>;
+    store: I["istore"];
+    testResourceConfiguration: ITTestResourceConfiguration;
+    index: number;
+    failed: boolean;
+    fails: number;
+    artifacts: string[];
+    addArtifact(path: string): void;
+    constructor(name: string, index: number, givens?: IGivens<I>);
+    features(): any[];
+    toObj(): {
+        name: string;
+        givens: {
+            key: string;
+            whens: any[];
+            thens: any[];
+            error: (string | Error | undefined)[] | null;
+            failed: boolean;
+            features: string[];
+            artifacts: string[];
+            status: boolean | undefined;
+        }[];
+        fails: number;
+        failed: boolean;
+        features: any[];
+        artifacts: string[];
+    };
+    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: IPM): Promise<I["isubject"]>;
+    assertThat(t: Awaited<I["then"]> | undefined): boolean;
+    afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM): I["istore"];
+    run(input: I["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: IPM): Promise<BaseSuite<I, O>>;
+}

package/dist/types/src/lib/BaseSuite.test/mock.d.ts

@@ -0,0 +1,21 @@
+import { BaseGiven } from "../BaseGiven";
+import { BaseSuite } from "../BaseSuite";
+import { BaseThen } from "../BaseThen";
+import { BaseWhen } from "../BaseWhen";
+import { IPM } from "../types";
+import { I, TestStore, TestSelection, O } from "./test";
+export declare class MockGiven extends BaseGiven<I> {
+    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[]);
+    givenThat(): Promise<TestStore>;
+    uberCatcher(e: Error): void;
+}
+export declare class MockWhen extends BaseWhen<I> {
+    andWhen(store: TestStore, whenCB: (s: TestSelection) => Promise<BaseSuite<any, any>>, testResource: any, pm: IPM): Promise<TestStore>;
+    addArtifact(path: string): void;
+}
+export declare class MockThen extends BaseThen<I> {
+    butThen(store: TestStore, thenCB: (s: TestSelection) => Promise<BaseSuite<any, any>>, testResourceConfiguration: any, pm: IPM): Promise<TestSelection>;
+}
+export declare class MockSuite extends BaseSuite<I, O> {
+    constructor(name: string, index: number);
+}

package/dist/types/src/lib/BaseSuite.test/node.test.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

package/dist/types/src/lib/BaseSuite.test/pure.test.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./test";
+declare const _default: Promise<import("../../Pure").PureTesteranto<I, O, {}>>;
+export default _default;

package/dist/types/src/lib/BaseSuite.test/test.d.ts

@@ -0,0 +1,37 @@
+import { Ibdd_in, Ibdd_out, ITestSpecification, ITestImplementation, ITestAdapter } from "../../CoreTypes";
+import { BaseSuite } from "../BaseSuite";
+export type TestStore = {
+    name?: string;
+    index?: number;
+    testStore: boolean;
+    testSelection?: boolean;
+    error?: Error | undefined;
+};
+export type TestSelection = {
+    testSelection: boolean;
+    testStore?: boolean;
+    error?: boolean;
+};
+export type I = Ibdd_in<typeof BaseSuite, BaseSuite<any, any>, // isubject
+TestStore, // istore
+TestSelection, // iselection
+() => Promise<TestStore>, // given
+(x: TestSelection) => (store: TestStore) => Promise<TestSelection>, // when
+(s: TestSelection) => Promise<BaseSuite<any, any>>>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+}, {
+    TestWhen: [];
+    RunSuite: [];
+}, {
+    TestThen: [];
+    FeaturesIncludes: [feature: string];
+    StoreValid: [];
+    SuiteNameMatches: [string];
+    SuiteIndexMatches: [number];
+}>;
+export declare const specification: ITestSpecification<I, O>;
+export declare const implementation: ITestImplementation<I, O>;
+export declare const testAdapter: ITestAdapter<I>;

package/dist/types/src/lib/BaseSuite.test/web.test.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./test";
+declare const _default: Promise<import("../../Web").WebTesteranto<I, O, {}>>;
+export default _default;

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

@@ -0,0 +1,29 @@
+import type { Ibdd_in_any } from "../CoreTypes";
+import { ITLog, ITTestResourceConfiguration } from ".";
+import { IPM } from "./types.js";
+export declare abstract class BaseThen<I extends Ibdd_in_any> {
+    name: string;
+    thenCB: (storeState: I["iselection"], pm: IPM) => Promise<I["then"]>;
+    error: boolean;
+    artifacts: string[];
+    status: boolean | undefined;
+    constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
+    addArtifact(path: string): void;
+    toObj(): {
+        name: string;
+        error: boolean;
+        artifacts: string[];
+        status: boolean | undefined;
+    };
+    abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITTestResourceConfiguration, pm: IPM): Promise<I["iselection"]>;
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<I["then"] | undefined>;
+}
+/**
+ * Represents a collection of Then assertions keyed by their names.
+ * Thens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - Assertions might need to be reused or composed dynamically
+ * - Custom assertion libraries could benefit from named assertion collections
+ * - Advanced validation patterns require named Then conditions
+ */
+export type IThens<I extends Ibdd_in_any> = Record<string, BaseThen<I>>;

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

@@ -0,0 +1,29 @@
+import type { Ibdd_in_any } from "../CoreTypes";
+import { ITLog } from ".";
+import { IPM } from "./types.js";
+export declare abstract class BaseWhen<I extends Ibdd_in_any> {
+    name: string;
+    whenCB: (x: I["iselection"]) => I["then"];
+    error: Error;
+    artifacts: string[];
+    status: boolean | undefined;
+    addArtifact(path: string): void;
+    constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
+    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: IPM): Promise<any>;
+    toObj(): {
+        name: string;
+        status: boolean | undefined;
+        error: string | null;
+        artifacts: string[];
+    };
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<any>;
+}
+/**
+ * Represents a collection of When actions keyed by their names.
+ * Whens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - When actions might need to be reused across multiple Given conditions
+ * - Dynamic composition of test steps is required
+ * - Advanced test patterns need to reference When actions by name
+ */
+export type IWhens<I extends Ibdd_in_any> = Record<string, BaseWhen<I>>;

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

@@ -0,0 +1,5 @@
+import { ITTestResourceConfiguration } from ".";
+export declare abstract class Sidecar {
+    abstract start(t: ITTestResourceConfiguration): any;
+    abstract stop(): any;
+}

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

@@ -0,0 +1,37 @@
+import { NonEmptyObject } from "type-fest";
+import type { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification, ITestAdapter } from "../CoreTypes";
+import { ITestJob, IFinalResults, ITTestResourceRequest } from "./index.js";
+import { BaseGiven } from "./BaseGiven";
+import { BaseWhen } from "./BaseWhen.js";
+import { BaseThen } from "./BaseThen.js";
+import { IPM } from "./types.js";
+type IExtenstions = Record<string, unknown>;
+export default abstract class Tiposkripto<I extends Ibdd_in_any = Ibdd_in_any, O extends Ibdd_out_any = Ibdd_out_any, M = unknown> {
+    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
+    specs: any;
+    assertThis: (t: I["then"]) => any;
+    testResourceRequirement: ITTestResourceRequest;
+    artifacts: Promise<unknown>[];
+    testJobs: ITestJob[];
+    private totalTests;
+    testSpecification: ITestSpecification<I, O>;
+    suitesOverrides: Record<keyof IExtenstions, any>;
+    givenOverides: Record<keyof IExtenstions, any>;
+    whenOverides: Record<keyof IExtenstions, any>;
+    thenOverides: Record<keyof IExtenstions, any>;
+    puppetMaster: IPM;
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
+        suites: Record<string, NonEmptyObject<object>>;
+        givens: Record<string, any>;
+        whens: Record<string, any>;
+        thens: Record<string, any>;
+    }, testResourceRequirement?: ITTestResourceRequest, testAdapter?: Partial<ITestAdapter<I>>, uberCatcher?: (cb: () => void) => void);
+    Specs(): any;
+    Suites(): Record<string, any>;
+    Given(): Record<keyof IExtenstions, (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], gcb: I["given"]) => BaseGiven<I>>;
+    When(): Record<keyof IExtenstions, (arg0: I["istore"], ...arg1: any) => BaseWhen<I>>;
+    Then(): Record<keyof IExtenstions, (selection: I["iselection"], expectation: any) => BaseThen<I>>;
+    getTestJobs(): ITestJob[];
+    private calculateTotalTests;
+}
+export {};

package/dist/types/src/lib/Tiposkripto.test/MockTiposkripto.d.ts

@@ -0,0 +1,18 @@
+import Tiposkripto from "../Tiposkripto";
+import { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification, ITestAdapter } from "../../CoreTypes";
+import { ITTestResourceRequest, IFinalResults } from "..";
+/**
+ * Concrete implementation of Tiposkripto for testing purposes
+ */
+export declare class MockTiposkripto<I extends Ibdd_in_any, O extends Ibdd_out_any, M = unknown> extends Tiposkripto<I, O, M> {
+    specs: any[];
+    testJobs: any[];
+    artifacts: any[];
+    testResourceRequirement: ITTestResourceRequest;
+    testAdapter: Partial<ITestAdapter<I>>;
+    features: string[];
+    private testImplementation;
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest | undefined, testAdapter: Partial<ITestAdapter<I>>, uberCatcher?: (cb: () => void) => void);
+    private extractFeaturesFromSpecification;
+    receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
+}

package/dist/types/src/lib/Tiposkripto.test/Tiposkripto.adapter.d.ts

@@ -0,0 +1,3 @@
+import { ITestAdapter } from "../../CoreTypes";
+import { I } from "./Tiposkripto.types";
+export declare const testAdapter: ITestAdapter<I>;

package/dist/types/src/lib/Tiposkripto.test/Tiposkripto.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

package/dist/types/src/lib/Tiposkripto.test/Tiposkripto.implementation.d.ts

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, O, M } from "./Tiposkripto.types";
+export declare const implementation: ITestImplementation<I, O, M>;

package/dist/types/src/lib/Tiposkripto.test/Tiposkripto.specification.d.ts

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./Tiposkripto.types";
+export declare const specification: ITestSpecification<I, O>;

package/dist/types/src/lib/Tiposkripto.test/Tiposkripto.types.d.ts

@@ -0,0 +1,58 @@
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification, ITestAdapter } from "../../CoreTypes";
+import { ITestJob, ITTestResourceRequest } from "..";
+import Tiposkripto from "../Tiposkripto";
+export type I = Ibdd_in<{}, // iinput
+Tiposkripto<any, any, any>, // isubject
+Tiposkripto<any, any, any>, // istore
+Tiposkripto<any, any, any>, // iselection
+() => Tiposkripto<any, any, any>, // given
+(store: any) => any, // when
+(store: any) => any>;
+export type O = Ibdd_out<{
+    Default: [string];
+    ExtendedSuite: [description: string];
+}, {
+    Default: [];
+    WithCustomInput: [input: any];
+    WithResourceRequirements: [requirements: ITTestResourceRequest];
+    WithCustomImplementation: [impl: ITestImplementation<any, any>];
+    WithCustomSpecification: [spec: ITestSpecification<any, any>];
+    WithCustomAdapter: [adapter: Partial<ITestAdapter<any>>];
+}, {
+    addArtifact: [artifact: Promise<any>];
+    setTestJobs: [jobs: ITestJob[]];
+    modifySpecs: [modifier: (specs: any[]) => any[]];
+    modifyJobs: [modifier: (jobs: ITestJob[]) => ITestJob[]];
+    triggerError: [message: string];
+    receiveTestResourceConfig: [config: string];
+}, {
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+    artifactsTracked: [];
+    resourceRequirementsSet: [];
+    suitesOverridesConfigured: [];
+    givensOverridesConfigured: [];
+    whensOverridesConfigured: [];
+    thensOverridesConfigured: [];
+    interfaceConfigured: [];
+    specsModified: [expectedCount: number];
+    jobsModified: [expectedCount: number];
+    errorThrown: [expectedMessage: string];
+    testRunSuccessful: [];
+    runTimeTestsCounted: [];
+    runTimeTestsSetToNegativeOne: [];
+    runTimeTestsCountIs: [expectedCount: number];
+    runTimeTestsIsNegativeOne: [];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...args: O["givens"][K]) => Tiposkripto<any, any, any>;
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...args: O["whens"][K]) => (builder: Tiposkripto<any, any, any>) => Tiposkripto<any, any, any>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...args: O["thens"][K]) => (builder: Tiposkripto<any, any, any>) => Tiposkripto<any, any, any>;
+    };
+};

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

@@ -0,0 +1,9 @@
+import { Ibdd_in_any } from "../../CoreTypes";
+import { BaseGiven } from "../BaseGiven";
+import { BaseThen } from "../BaseThen";
+import { BaseWhen } from "../BaseWhen";
+export declare class MockGiven<I extends Ibdd_in_any> extends BaseGiven<I> {
+    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"], initialValues: any);
+    givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: any, givenCB: I["given"], initialValues: any, pm: any): Promise<I["istore"]>;
+    uberCatcher(e: Error): void;
+}

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

@@ -0,0 +1,6 @@
+import { Ibdd_in_any } from "../../CoreTypes";
+import { BaseThen } from "../BaseThen";
+export declare class MockThen<I extends Ibdd_in_any> extends BaseThen<I> {
+    constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
+    butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: any, pm: any): Promise<I["iselection"]>;
+}

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

@@ -0,0 +1,6 @@
+import { Ibdd_in_any } from "../../CoreTypes";
+import { BaseWhen } from "../BaseWhen";
+export declare class MockWhen<I extends Ibdd_in_any> extends BaseWhen<I> {
+    constructor(name: string, whenCB: (x: I["iselection"]) => I["then"]);
+    andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: any): Promise<I["istore"]>;
+}

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

@@ -0,0 +1,3 @@
+import { ITestAdapter } from "../../CoreTypes";
+import { I } from "./types";
+export declare const testAdapter: ITestAdapter<I>;

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

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, O } from "./types";
+export declare const implementation: ITestImplementation<I, O>;

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

@@ -0,0 +1,2 @@
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,39 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+export type I = Ibdd_in<{}, // iinput
+{}, // isubject
+{
+    testStore: {
+        value: string;
+    };
+    error?: Error;
+}, // istore
+{
+    testSelection: {
+        selected: boolean;
+    };
+}, // iselection
+() => () => {
+    testStore: {
+        value: string;
+    };
+}, // given
+(store: any) => (store: any) => any, // when
+(store: any) => (store: any) => any>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, // Suites
+{
+    Default: [];
+    WithError: [];
+}, // Givens
+{
+    modifyStore: [string];
+    throwError: [];
+}, // Whens
+{
+    verifyStore: [string];
+    verifyError: [string];
+}, // Thens
+{
+    Default: [];
+}>;