testeranto 0.189.0 → 0.198.0

package/dist/types/design-editor/DesignEditor.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface DesignObject {
+    type: string;
+    [key: string]: any;
+}
+interface Design {
+    version: string;
+    background: string;
+    objects: DesignObject[];
+}
+export interface DesignEditorRef {
+    loadDesign: (design: Design) => void;
+    saveDesign: () => Design | null;
+}
+export declare const DesignEditor: React.ForwardRefExoticComponent<{
+    projectId: string;
+} & React.RefAttributes<DesignEditorRef>>;
+export {};

package/dist/types/design-editor/server.d.ts

@@ -0,0 +1 @@
+export declare function startDesignEditorServer(wssPort: number, httpPort?: number): void;

package/dist/types/{Node.d.ts → src/Node.d.ts}

@@ -1,7 +1,7 @@
-import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
 import { ITestSpecification, ITestImplementation, ITestAdapter, Ibdd_in_any, Ibdd_out_any, Ibdd_out } from "./CoreTypes.js";
-export declare class NodeTesteranto<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends Testeranto<I, O, M> {
+import Tiposkripto from "./lib/Tiposkripto.js";
+export declare class NodeTesteranto<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends Tiposkripto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
     receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults>;
 }

package/dist/types/src/PM/__tests__/nodeSidecar.testeranto.d.ts

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

package/dist/types/src/PM/__tests__/pureSidecar.testeranto.d.ts

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

package/dist/types/src/PM/__tests__/webSidecar.testeranto.d.ts

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

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

@@ -6,7 +6,7 @@ export declare abstract class PM {
     testResourceConfiguration: ITTestResourceConfiguration;
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
-    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
+    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): any;
     abstract $(selector: string, page: string): any;
     abstract click(selector: string): any;
     abstract closePage(p: any): any;

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

@@ -1,6 +1,8 @@
 import { ChildProcess } from "node:child_process";
 import { Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
+import { WebSocketServer } from "ws";
+import http from "http";
 import { IRunnables, ITTestResourceConfiguration } from "../lib/index.js";
 import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 import { Sidecar } from "../lib/Sidecar.js";
@@ -29,6 +31,20 @@ export declare class PM_Main extends PM_WithEslintAndTsc {
     webSidecars: Record<number, Page>;
     sidecars: Record<number, any>;
     launchers: Record<string, () => void>;
+    wss: WebSocketServer;
+    clients: Set<any>;
+    httpServer: http.Server;
+    runningProcesses: Map<string, ChildProcess>;
+    allProcesses: Map<string, {
+        child?: ChildProcess;
+        status: "running" | "exited" | "error";
+        exitCode?: number;
+        error?: string;
+        command: string;
+        pid?: number;
+        timestamp: string;
+    }>;
+    processLogs: Map<string, string[]>;
     constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
     stopSideCar(uid: number): Promise<any>;
     launchSideCar(n: number, name: string): Promise<[number, ITTestResourceConfiguration]>;
@@ -52,6 +68,9 @@ export declare class PM_Main extends PM_WithEslintAndTsc {
     launchPureSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
     launchWeb: (src: string, dest: string) => Promise<void>;
     receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
+    requestHandler(req: http.IncomingMessage, res: http.ServerResponse): void;
+    findIndexHtml(): string | null;
+    broadcast(message: any): void;
     checkQueue(): void;
     checkForShutdown: () => void;
 }

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

@@ -5,12 +5,14 @@ import { PM } from ".";
 type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Pure extends PM {
     getInnerHtml(selector: string, page: string): Promise<string>;
-    stopSideCar(uid: number): Promise<boolean>;
+    stopSideCar(uid: number): Promise<any>;
     server: PuppetMasterServer;
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
+    protected trackCall(method: string, args: any): void;
     start(): Promise<void>;
     stop(): Promise<void>;
+    createWriteStream(filepath: string, testName: string): Promise<string>;
     launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     pages(): any;
     waitForSelector(p: string, s: string): any;
@@ -27,17 +29,15 @@ export declare class PM_Pure extends PM {
     click(selector: string): string | undefined;
     screencast(opts: ScreencastOptions, page: string): any;
     screencastStop(p: string): any;
-    customScreenShot(opts: ScreencastOptions, page: string): any;
+    customScreenShot(opts: {
+        path: string;
+    }, page?: string): any;
     existsSync(destFolder: string): Promise<boolean>;
     mkdirSync(): boolean;
     write(uid: number, contents: string): Promise<boolean>;
     writeFileSync(): Promise<boolean>;
-    createWriteStream(): {
-        write: () => boolean;
-        end: () => void;
-    };
     end(uid: number): any;
     customclose(): void;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): (fPath: string, value: string | Buffer | any) => void;
 }
 export {};

package/dist/types/{Pure.d.ts → src/Pure.d.ts}

@@ -1,7 +1,7 @@
 import { Ibdd_in_any, Ibdd_out, ITestImplementation, ITestAdapter, ITestSpecification } from "./CoreTypes.js";
-import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-export declare class PureTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Testeranto<I, O, M> {
+import Tiposkripto from "./lib/Tiposkripto.js";
+export declare class PureTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Tiposkripto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
     receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults>;
 }

package/dist/types/src/Pure.test.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<any>;
+export default _default;

package/dist/types/src/ReportServer.test.ts/index.d.ts

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

package/dist/types/{Types.d.ts → src/Types.d.ts}

@@ -1,9 +1,11 @@
 import { Plugin } from "esbuild";
 import { ITTestResourceConfiguration } from "./lib/index.js";
 import { PM } from "./PM/index.js";
-import { BaseWhen, BaseThen, BaseGiven, IGivens } from "./lib/abstractBase.js";
 import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
 import { BaseSuite } from "./lib/BaseSuite.js";
+import { IGivens, BaseGiven } from "./lib/BaseGiven.js";
+import { BaseThen } from "./lib/BaseThen.js";
+import { BaseWhen } from "./lib/BaseWhen.js";
 export type ISummary = Record<string, {
     runTimeErrors: number | "?" | undefined;
     typeErrors: number | "?" | undefined;

package/dist/types/{Web.d.ts → src/Web.d.ts}

@@ -1,7 +1,7 @@
 import { ITestSpecification, ITestImplementation, ITestAdapter, Ibdd_in_any, Ibdd_out } from "./CoreTypes";
-import Testeranto from "./lib/core.js";
+import Tiposkripto from "./lib/Tiposkripto";
 import { ITTestResourceRequest } from "./lib/index.js";
-export declare class WebTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Testeranto<I, O, M> {
+export declare class WebTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Tiposkripto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
     receiveTestResourceConfig(partialTestResource: any): Promise<import("./lib/index.js").IFinalResults>;
 }

package/dist/types/src/components/DesignEditorPage.d.ts

@@ -0,0 +1 @@
+export declare const DesignEditorPage: () => JSX.Element;

package/dist/types/{components → src/components}/pure/AppFrame.d.ts

@@ -4,6 +4,8 @@ type AppFrameProps = {
     className?: string;
     style?: React.CSSProperties;
     'data-testid'?: string;
+    title?: string;
+    rightContent?: React.ReactNode;
 };
-export declare const AppFrame: ({ children }: AppFrameProps) => JSX.Element;
+export declare const AppFrame: ({ children, title, rightContent }: AppFrameProps) => JSX.Element;
 export {};

package/dist/types/src/components/pure/AppFrame.test/index.d.ts

@@ -0,0 +1,3 @@
+import "../../../App.scss";
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

package/dist/types/src/components/pure/FeaturesReporterView.test/index.d.ts

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

package/dist/types/src/components/pure/ModalContent.test/index.d.ts

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

package/dist/types/{components → src/components}/pure/NavBar.d.ts

@@ -8,12 +8,16 @@ type NavItem = {
         variant: string;
         text: string;
     };
+    icon?: React.ReactNode;
 };
 type NavBarProps = {
     title: string;
     backLink?: string;
     navItems?: NavItem[];
     rightContent?: React.ReactNode;
+    showProcessManagerLink?: boolean;
+    onToggleCollapse?: () => void;
+    isCollapsed?: boolean;
 };
 export declare const NavBar: React.FC<NavBarProps>;
 export {};

package/dist/types/src/components/pure/ProcessManager.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface ProcessManagerProps {
+    show: boolean;
+    onHide: () => void;
+    ws: WebSocket | null;
+}
+export declare const ProcessManager: React.FC<ProcessManagerProps>;
+export {};

package/dist/types/src/components/pure/ProcessManagerView.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+export interface Process {
+    processId: string;
+    command: string;
+    pid?: number;
+    status?: "running" | "exited" | "error";
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    logs?: string[];
+}
+interface ProcessManagerViewProps {
+    processes: Process[];
+    onRefresh: () => void;
+    onBack: () => void;
+    loading: boolean;
+    onKillProcess?: (processId: string) => void;
+}
+export declare const ProcessManagerView: React.FC<ProcessManagerViewProps>;
+export {};

package/dist/types/src/components/pure/ProjectPageView.test/index.d.ts

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

package/dist/types/{components → src/components}/pure/ProjectsPageView.d.ts

@@ -25,5 +25,5 @@ type ProjectsPageViewProps = {
     error: string | null;
     navigate: (path: string) => void;
 };
-export declare const ProjectsPageView: ({ projects, summaries, configs, loading, error, navigate }: ProjectsPageViewProps) => JSX.Element;
+export declare const ProjectsPageView: ({ projects, summaries, configs, loading, error, navigate, }: ProjectsPageViewProps) => JSX.Element;
 export {};

package/dist/types/src/components/pure/SettingsButton.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const SettingsButton: React.FC;

package/dist/types/{components → src/components}/pure/TestPageView.test/implementation.d.ts

@@ -1,11 +1,12 @@
 import { ITestImplementation } from "../../../CoreTypes";
 import { IInput, ISelection, IStore, ISubject, O } from "./types";
+import { ITTestResourceConfiguration, IPM } from "../../../lib";
 export declare const implementation: ITestImplementation<{
     iinput: IInput;
     isubject: ISubject;
     istore: IStore;
     iselection: ISelection;
     given: (props: IInput) => ISelection;
-    when: (sel: ISelection) => ISelection;
-    then: (sel: ISelection) => Promise<ISelection>;
+    when: (sel: ISelection, tr: ITTestResourceConfiguration, utils: IPM) => Promise<(sel: ISelection) => ISelection>;
+    then: (sel: ISelection, tr: ITTestResourceConfiguration, utils: IPM) => Promise<(sel: ISelection) => ISelection>;
 }, O, {}>;

package/dist/types/src/components/pure/TestPageView.test/index.d.ts

@@ -0,0 +1,3 @@
+import "./../../../App.scss";
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

package/dist/types/src/components/stateful/FileTree.d.ts

@@ -0,0 +1,8 @@
+import { FileType } from './TextEditorPage';
+type FileTreeProps = {
+    files: FileType[];
+    onSelect: (path: string) => void;
+    activeFile: string | null;
+};
+export declare const FileTree: ({ files, onSelect, activeFile }: FileTreeProps) => JSX.Element;
+export {};

package/dist/types/src/components/stateful/ProcessManagerPage.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ProcessManagerPage: React.FC;

package/dist/types/src/components/stateful/SettingsPage.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const SettingsPage: React.FC;

package/dist/types/src/components/stateful/SingleProcessPage.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SingleProcessPage: React.FC;

package/dist/types/src/components/stateful/TextEditorPage.d.ts

@@ -0,0 +1 @@
+export declare const TextEditorPage: () => JSX.Element;

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> {
+    name: string;
+    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[];
+    addArtifact(path: string): void;
+    constructor(name: string, features: string[], whens: any[], thens: any[], givenCB: I["given"], initialValues: any);
+    beforeAll(store: I["istore"]): I["istore"];
+    toObj(): {
+        key: string;
+        name: string;
+        whens: any[];
+        thens: any[];
+        error: (string | Error | undefined)[] | null;
+        failed: boolean;
+        features: string[];
+        artifacts: string[];
+    };
+    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/{lib → src/lib}/BaseSuite.d.ts

@@ -1,7 +1,16 @@
 import { ITTestResourceConfiguration, ITestArtifactory } from ".";
 import { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
-import { IGivens } from "./abstractBase";
+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>;
@@ -19,12 +28,8 @@ export declare abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_ou
         givens: {
             key: string;
             name: string;
-            whens: {}[];
-            thens: {
-                name: string;
-                error: boolean;
-                artifacts: string[];
-            }[];
+            whens: any[];
+            thens: any[];
             error: (string | Error | undefined)[] | null;
             failed: boolean;
             features: string[];

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

@@ -1,5 +1,7 @@
-import { BaseGiven, BaseWhen, BaseThen } from "../abstractBase";
+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> {
@@ -8,11 +10,11 @@ export declare class MockGiven extends BaseGiven<I> {
     uberCatcher(e: Error): void;
 }
 export declare class MockWhen extends BaseWhen<I> {
-    andWhen(store: TestStore, whenCB: (store: TestStore) => Promise<TestStore>, testResource: any, pm: IPM): Promise<TestStore>;
-    addArtifact(name: string, content: string): this;
+    andWhen(store: TestStore, whenCB: (x: TestSelection) => (store: TestStore) => Promise<TestSelection>, testResource: any, pm: IPM): Promise<TestStore>;
+    addArtifact(path: string): void;
 }
 export declare class MockThen extends BaseThen<I> {
-    butThen(store: TestStore, thenCB: (selection: TestSelection) => Promise<TestSelection>, testResourceConfiguration: any, pm: any): Promise<TestSelection>;
+    butThen(store: TestStore, thenCB: (s: TestSelection) => Promise<BaseSuite<any, any>>, testResourceConfiguration: any, pm: IPM, ...args: any[]): 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,2 @@
+declare const _default: Promise<any>;
+export default _default;

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

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

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

@@ -0,0 +1,27 @@
+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[];
+    constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
+    addArtifact(path: string): void;
+    toObj(): {
+        name: string;
+        error: boolean;
+        artifacts: string[];
+    };
+    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,27 @@
+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[];
+    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;
+        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/Tiposkripto.d.ts

@@ -0,0 +1,35 @@
+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[];
+    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[];
+}
+export {};

package/dist/types/{lib/core.test/MockCore.d.ts → src/lib/Tiposkripto.test/MockTiposkripto.d.ts}

@@ -1,10 +1,10 @@
-import TesterantoCore from "../core";
+import Tiposkripto from "../Tiposkripto";
 import { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification, ITestAdapter } from "../../CoreTypes";
 import { ITTestResourceRequest, IFinalResults } from "..";
 /**
- * Concrete implementation of Testeranto for testing purposes
+ * Concrete implementation of Tiposkripto for testing purposes
  */
-export declare class MockCore<I extends Ibdd_in_any, O extends Ibdd_out_any, M = unknown> extends TesterantoCore<I, O, M> {
+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[];

package/dist/types/{lib/core.test/core.test.adapter.d.ts → src/lib/Tiposkripto.test/Tiposkripto.adapter.d.ts}

@@ -1,3 +1,3 @@
 import { ITestAdapter } from "../../CoreTypes";
-import { I } from "./core.test.types";
+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/{lib/core.test/core.test.implementation.d.ts → src/lib/Tiposkripto.test/Tiposkripto.implementation.d.ts}

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

package/dist/types/{lib/core.test/core.test.specification.d.ts → src/lib/Tiposkripto.test/Tiposkripto.specification.d.ts}

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

package/dist/types/{lib/classBuilder.test/classBuilder.test.types.d.ts → src/lib/Tiposkripto.test/Tiposkripto.types.d.ts}

@@ -1,11 +1,11 @@
-import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../CoreTypes";
-import { ClassBuilder } from "../classBuilder";
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification, ITestAdapter } from "../../CoreTypes";
 import { ITestJob, ITTestResourceRequest } from "..";
+import Tiposkripto from "../Tiposkripto";
 export type I = Ibdd_in<{}, // iinput
-ClassBuilder<any, any, any>, // isubject
-ClassBuilder<any, any, any>, // istore
-ClassBuilder<any, any, any>, // iselection
-() => ClassBuilder<any, any, any>, // given
+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<{
@@ -17,6 +17,7 @@ export type O = Ibdd_out<{
     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[]];
@@ -33,6 +34,7 @@ export type O = Ibdd_out<{
     givensOverridesConfigured: [];
     whensOverridesConfigured: [];
     thensOverridesConfigured: [];
+    interfaceConfigured: [];
     specsModified: [expectedCount: number];
     jobsModified: [expectedCount: number];
     errorThrown: [expectedMessage: string];
@@ -40,12 +42,12 @@ export type O = Ibdd_out<{
 }>;
 export type M = {
     givens: {
-        [K in keyof O["givens"]]: (...args: O["givens"][K]) => ClassBuilder<any, any, any>;
+        [K in keyof O["givens"]]: (...args: O["givens"][K]) => Tiposkripto<any, any, any>;
     };
     whens: {
-        [K in keyof O["whens"]]: (...args: O["whens"][K]) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+        [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: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+        [K in keyof O["thens"]]: (...args: O["thens"][K]) => (builder: Tiposkripto<any, any, any>) => Tiposkripto<any, any, any>;
     };
 };

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

@@ -1,5 +1,7 @@
-import { BaseGiven, BaseThen, BaseWhen } from "../abstractBase";
 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"]>;