testeranto 0.203.0 → 0.205.0

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

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

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

@@ -0,0 +1,52 @@
+import { ITTestResourceConfiguration } from "./lib";
+import { BaseSuite } from "./lib/BaseSuite";
+import { IPM } from "./lib/types";
+import { GivenSpecification, WhenSpecification, ThenSpecification, TestWhenImplementation, Modify, TestSuiteImplementation, TestGivenImplementation, TestThenImplementation, TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, SuiteSpecification } from "./Types";
+export type ITestAdapter<I extends Ibdd_in_any> = {
+    assertThis: (x: I["then"]) => any;
+    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["istore"]>;
+    butThen: (store: I["istore"], thenCB: I["then"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["iselection"]>;
+    afterAll: (store: I["istore"], pm: IPM) => any;
+    afterEach: (store: I["istore"], key: string, pm: IPM) => Promise<unknown>;
+    beforeAll: (input: I["iinput"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["isubject"]>;
+    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITTestResourceConfiguration, initialValues: any, pm: IPM) => Promise<I["istore"]>;
+};
+export type ITestSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = (Suite: SuiteSpecification<I, O>, Given: GivenSpecification<I, O>, When: WhenSpecification<I, O>, Then: ThenSpecification<I, O>) => BaseSuite<I, O>[];
+export type ITestImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any, modifier = {
+    whens: TestWhenImplementation<I, O>;
+}> = Modify<{
+    suites: TestSuiteImplementation<O>;
+    givens: TestGivenImplementation<I, O>;
+    whens: TestWhenImplementation<I, O>;
+    thens: TestThenImplementation<I, O>;
+}, modifier>;
+export type Ibdd_out<ISuites extends TestSuiteShape = TestSuiteShape, IGivens extends TestGivenShape = TestGivenShape, IWhens extends TestWhenShape = TestWhenShape, IThens extends TestThenShape = TestThenShape> = {
+    suites: ISuites;
+    givens: IGivens;
+    whens: IWhens;
+    thens: IThens;
+};
+export type Ibdd_out_any = Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape>;
+export type Ibdd_in<IInput, // Type of initial test input
+ISubject, // Type of object being tested
+IStore, // Type for storing test state between steps
+ISelection, // Type for selecting state for assertions
+IGiven, // Type for Given step functions
+IWhen, // Type for When step functions
+IThen> = {
+    /** Initial input required to start tests */
+    iinput: IInput;
+    /** The subject being tested (class, function, etc) */
+    isubject: ISubject;
+    /** Complete test state storage */
+    istore: IStore;
+    /** Selected portion of state for assertions */
+    iselection: ISelection;
+    /** Function type for Given steps */
+    given: IGiven;
+    /** Function type for When steps */
+    when: IWhen;
+    /** Function type for Then steps */
+    then: IThen;
+};
+export type Ibdd_in_any = Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>;

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

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

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { ITTestResourceRequest } from "./lib/index.js";
+import { ITestSpecification, ITestImplementation, ITestAdapter, Ibdd_in_any, Ibdd_out_any, Ibdd_out } from "./CoreTypes.js";
+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>;
+}
+declare const testeranto: <I extends Ibdd_in_any, O extends Ibdd_out, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
+export default testeranto;

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

@@ -0,0 +1,6 @@
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Node_Sidecar } from "./PM/nodeSidecar";
+export declare abstract class NodeSidecar extends Sidecar {
+    pm: PM_Node_Sidecar;
+    constructor(t: any);
+}

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/src/PM/golingvuBuild.d.ts

@@ -0,0 +1,11 @@
+import { IBuiltConfig } from "../Types";
+export declare class GolingvuBuild {
+    private config;
+    private testName;
+    private watcher;
+    constructor(config: IBuiltConfig, testName: string);
+    build(): Promise<string[]>;
+    rebuild(): Promise<void>;
+    stop(): void;
+    onBundleChange(callback: () => void): void;
+}

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

@@ -0,0 +1,35 @@
+import { Page } from "puppeteer-core";
+import { ScreenRecorderOptions } from "puppeteer-core/lib/esm/puppeteer";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+export declare abstract class PM {
+    server: any;
+    testResourceConfiguration: ITTestResourceConfiguration;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+    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;
+    abstract createWriteStream(filepath: string, testName: string): Promise<string>;
+    abstract customclose(): any;
+    abstract customScreenShot(opts: {
+        path: string;
+    }, page?: string): any;
+    abstract end(uid: number): Promise<boolean>;
+    abstract existsSync(fp: string): Promise<boolean>;
+    abstract focusOn(selector: string): any;
+    abstract getAttribute(selector: string, attribute: string, page: string): any;
+    abstract getInnerHtml(selector: string, page: string): any;
+    abstract goto(p: any, url: string): any;
+    abstract isDisabled(selector: string): Promise<boolean>;
+    abstract mkdirSync(a: string): any;
+    abstract newPage(): Promise<string>;
+    abstract page(): Promise<string | undefined>;
+    abstract pages(): Promise<string[]>;
+    abstract screencast(o: ScreenRecorderOptions, p: Page | string): any;
+    abstract screencastStop(s: string): any;
+    abstract typeInto(selector: string, value: string): any;
+    abstract waitForSelector(p: any, sel: string): any;
+    abstract write(uid: number, contents: string): Promise<boolean>;
+    abstract writeFileSync(f: string, c: string): Promise<boolean>;
+}

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

@@ -0,0 +1,38 @@
+import net from "net";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from ".";
+export declare class PM_Node extends PM {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    constructor(t: ITTestResourceConfiguration, ipcFile: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+    pages(): Promise<string[]>;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): Promise<unknown>;
+    goto(page: string, url: string): Promise<unknown>;
+    newPage(): Promise<string>;
+    $(selector: string, page: string): Promise<unknown>;
+    isDisabled(selector: string): Promise<boolean>;
+    getAttribute(selector: string, attribute: string, p: string): Promise<unknown>;
+    getInnerHtml(selector: string, p: string): Promise<unknown>;
+    focusOn(selector: string): Promise<unknown>;
+    typeInto(selector: string): Promise<unknown>;
+    page(): Promise<string | undefined>;
+    click(selector: string): Promise<unknown>;
+    screencast(opts: ScreencastOptions, page: string): Promise<unknown>;
+    screencastStop(p: string): Promise<unknown>;
+    customScreenShot(x: ScreenshotOptions, y?: string): Promise<unknown>;
+    existsSync(destFolder: string): Promise<boolean>;
+    mkdirSync(): Promise<unknown>;
+    write(uid: number, contents: string): Promise<boolean>;
+    writeFileSync(x: any): Promise<boolean>;
+    createWriteStream(filepath: string): Promise<string>;
+    end(uid: any): Promise<boolean>;
+    customclose(): Promise<unknown>;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void): (fPath: string, value: string | Buffer | PassThrough) => void;
+    startPuppeteer(options?: any): any;
+}

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

@@ -0,0 +1,13 @@
+import net from "net";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM_sidecar } from "./sidecar";
+import { PassThrough } from "stream";
+export declare class PM_Node_Sidecar extends PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    constructor(t: ITTestResourceConfiguration);
+    start(stopper: () => any): Promise<void>;
+    stop(): Promise<void>;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void): (fPath: string, value: string | Buffer | PassThrough) => void;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+}

package/dist/types/src/PM/pitonoBuild.d.ts

@@ -0,0 +1,11 @@
+import { IBuiltConfig } from "../Types";
+export declare class PitonoBuild {
+    private config;
+    private testName;
+    private watcher;
+    constructor(config: IBuiltConfig, testName: string);
+    build(): Promise<string[]>;
+    rebuild(): Promise<void>;
+    stop(): void;
+    onBundleChange(callback: () => void): void;
+}

package/dist/types/src/PM/pitonoRunner.d.ts

@@ -0,0 +1,7 @@
+import { ITestconfig } from '../lib';
+export declare class PitonoRunner {
+    private config;
+    private testName;
+    constructor(config: ITestconfig, testName: string);
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { ScreencastOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from ".";
+type PuppetMasterServer = Record<string, Promise<any>>;
+export declare class PM_Pure extends PM {
+    getInnerHtml(selector: string, page: string): Promise<string>;
+    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>;
+    pages(): any;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): string;
+    goto(cdpPage: CdpPage, url: string): any;
+    newPage(): any;
+    $(selector: string): boolean;
+    isDisabled(selector: string): Promise<boolean>;
+    getAttribute(selector: string, attribute: string): any;
+    getValue(selector: string): any;
+    focusOn(selector: string): any;
+    typeInto(selector: string, value: string): any;
+    page(): any;
+    click(selector: string): string | undefined;
+    screencast(opts: ScreencastOptions, page: string): any;
+    screencastStop(p: 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>;
+    end(uid: number): any;
+    customclose(): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): (fPath: string, value: string | Buffer | any) => void;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../lib";
+import { PM_sidecar } from "./sidecar";
+export declare class PM_Pure_Sidecar extends PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    constructor(t: ITTestResourceConfiguration);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+}

package/dist/types/src/PM/sidecar.d.ts

@@ -0,0 +1,8 @@
+import { ITTestResourceConfiguration } from "../lib";
+import { ITLog } from "../lib";
+export declare abstract class PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    abstract start(stopper: () => any): Promise<void>;
+    abstract stop(): Promise<void>;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void): (fPath: string, value: unknown) => void;
+}

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

@@ -0,0 +1,118 @@
+export type ProcessStatus = "running" | "exited" | "error" | "completed";
+export type ProcessType = "process" | "promise";
+export type ProcessCategory = "aider" | "bdd-test" | "build-time" | "other";
+export type ProcessPlatform = "node" | "web" | "pure" | "pitono" | "golang";
+export interface ProcessInfo {
+    child?: any;
+    promise?: Promise<any>;
+    status: ProcessStatus;
+    exitCode?: number;
+    error?: string;
+    command: string;
+    pid?: number;
+    timestamp: string;
+    type: ProcessType;
+    category: ProcessCategory;
+    testName?: string;
+    platform?: ProcessPlatform;
+}
+export interface ProcessData {
+    processId: string;
+    command: string;
+    pid?: number;
+    status: ProcessStatus;
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    category: ProcessCategory;
+    testName?: string;
+    platform?: ProcessPlatform;
+    logs: string[];
+}
+export interface ProcessManager {
+    allProcesses: Map<string, ProcessInfo>;
+    processLogs: Map<string, string[]>;
+    addPromiseProcess: (processId: string, promise: Promise<any>, command: string, category?: ProcessCategory, testName?: string, platform?: ProcessPlatform, onResolve?: (result: any) => void, onReject?: (error: any) => void) => string;
+    broadcast: (message: any) => void;
+    getProcessesByCategory: (category: ProcessCategory) => any[];
+    getBDDTestProcesses: () => any[];
+    getBuildTimeProcesses: () => any[];
+    getAiderProcesses: () => any[];
+    getProcessesByTestName: (testName: string) => any[];
+    getProcessesByPlatform: (platform: ProcessPlatform) => any[];
+}
+export interface WebSocketMessage {
+    type: string;
+    [key: string]: any;
+}
+export interface ExecuteCommandMessage extends WebSocketMessage {
+    type: "executeCommand";
+    command: string;
+}
+export interface GetRunningProcessesMessage extends WebSocketMessage {
+    type: "getRunningProcesses";
+}
+export interface GetProcessMessage extends WebSocketMessage {
+    type: "getProcess";
+    processId: string;
+}
+export interface StdinMessage extends WebSocketMessage {
+    type: "stdin";
+    processId: string;
+    data: string;
+}
+export interface KillProcessMessage extends WebSocketMessage {
+    type: "killProcess";
+    processId: string;
+}
+export interface ProcessStartedEvent {
+    type: "processStarted";
+    processId: string;
+    command: string;
+    timestamp: string;
+    logs: string[];
+}
+export interface ProcessStdoutEvent {
+    type: "processStdout";
+    processId: string;
+    data: string;
+    timestamp: string;
+}
+export interface ProcessStderrEvent {
+    type: "processStderr";
+    processId: string;
+    data: string;
+    timestamp: string;
+}
+export interface ProcessExitedEvent {
+    type: "processExited";
+    processId: string;
+    exitCode: number;
+    timestamp: string;
+    logs?: string[];
+}
+export interface ProcessErrorEvent {
+    type: "processError";
+    processId: string;
+    error: string;
+    timestamp: string;
+    logs?: string[];
+}
+export interface RunningProcessesEvent {
+    type: "runningProcesses";
+    processes: ProcessData[];
+}
+export interface ProcessDataEvent {
+    type: "processData";
+    processId: string;
+    command: string;
+    pid?: number;
+    status: ProcessStatus;
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    category: ProcessCategory;
+    testName?: string;
+    platform?: ProcessPlatform;
+    logs: string[];
+}

package/dist/types/src/PM/utils.d.ts

@@ -0,0 +1,35 @@
+import fs from "fs";
+import { IRunTime } from "../Types";
+export type IOutputs = Record<string, {
+    entryPoint: string;
+    inputs: Record<string, string>;
+}>;
+export type LogStreams = {
+    closeAll: () => void;
+    writeExitCode: (code: number, error?: Error) => void;
+    stdout?: fs.WriteStream;
+    stderr?: fs.WriteStream;
+    info?: fs.WriteStream;
+    warn?: fs.WriteStream;
+    error?: fs.WriteStream;
+    debug?: fs.WriteStream;
+    exit: fs.WriteStream;
+};
+export declare function runtimeLogs(runtime: IRunTime, reportDest: string): Record<string, fs.WriteStream>;
+export declare function createLogStreams(reportDest: string, runtime: IRunTime): LogStreams;
+export declare function fileHash(filePath: any, algorithm?: string): Promise<string>;
+export declare const statusMessagePretty: (failures: number, test: string, runtime: IRunTime) => void;
+export declare function writeFileAndCreateDir(filePath: any, data: any): Promise<void>;
+export declare const filesHash: (files: string[], algorithm?: string) => Promise<string>;
+export declare function isValidUrl(string: any): boolean;
+export declare function pollForFile(path: any, timeout?: number): Promise<void>;
+export declare const puppeteerConfigs: {
+    slowMo: number;
+    waitForInitialPage: boolean;
+    executablePath: string;
+    headless: boolean;
+    defaultViewport: null;
+    dumpio: boolean;
+    devtools: boolean;
+    args: string[];
+};

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

@@ -0,0 +1,41 @@
+import { PassThrough } from "stream";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { Page } from "puppeteer-core";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from ".";
+declare module "puppeteer-core" {
+    interface Frame {
+        _id: string;
+    }
+}
+export declare class PM_Web extends PM {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(t: ITTestResourceConfiguration);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getInnerHtml(selector: string, page: string): void;
+    pages(): Promise<string[]>;
+    waitForSelector(p: string, s: string): any;
+    screencast(opts: ScreencastOptions, page: Page): Promise<string>;
+    screencastStop(recorder: string): any;
+    closePage(p: any): string;
+    goto(p: any, url: string): any;
+    newPage(): any;
+    $(selector: string): boolean;
+    isDisabled(selector: string): Promise<boolean>;
+    getAttribute(selector: string, attribute: string): any;
+    getValue(selector: number): any;
+    focusOn(selector: string): any;
+    typeInto(value: string): any;
+    page(x?: any): Promise<string | undefined>;
+    click(selector: string): any;
+    customScreenShot(x: ScreenshotOptions, y: any): any;
+    existsSync(destFolder: string): Promise<boolean>;
+    mkdirSync(x: any): any;
+    write(uid: number, contents: string): Promise<boolean>;
+    writeFileSync(x: any): any;
+    createWriteStream(filepath: string): any;
+    end(uid: number): Promise<boolean>;
+    customclose(): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+}

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

@@ -0,0 +1,11 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../lib";
+import { PM_sidecar } from "./sidecar";
+export declare class PM_Web_Sidecar extends PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    constructor(t: ITTestResourceConfiguration);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+}

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

@@ -0,0 +1,14 @@
+import { Ibdd_in_any, Ibdd_out, ITestImplementation, ITestAdapter, ITestSpecification } from "./CoreTypes.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+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 | {
+        failed: boolean;
+        fails: number;
+        artifacts: never[];
+        features: never[];
+    }>;
+}
+declare const _default: <I extends Ibdd_in_any, O extends Ibdd_out, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<PureTesteranto<I, O, M>>;
+export default _default;

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

@@ -0,0 +1,61 @@
+import { Ibdd_in, Ibdd_out } from "./CoreTypes";
+import { IPM } from "./lib/types";
+type I = Ibdd_in<null, // No initial input needed
+IPM, // Test subject is IPM
+{
+    pm: IPM;
+    artifacts?: any[];
+    testJobs?: any[];
+    specs?: any[];
+    largePayload?: boolean;
+}, // Store contains PM instance
+{
+    artifacts: never[];
+    specs: never[];
+    pm: IPM;
+}, // Selection is same as store
+() => {
+    pm: IPM;
+    config: {};
+    proxies: any;
+}, // Given returns initial state
+(store: {
+    pm: IPM;
+    [key: string]: any;
+}) => {
+    pm: IPM;
+    [key: string]: any;
+}, // When modifies store
+(store: {
+    pm: IPM;
+    [key: string]: any;
+}) => {
+    pm: IPM;
+    [key: string]: any;
+}>;
+type O = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+}, {
+    applyProxy: [string];
+    verifyCall: [string, any];
+    addArtifact: [Promise<string>];
+    setTestJobs: [any[]];
+    modifySpecs: [(specs: any) => any[]];
+}, {
+    verifyProxy: [string];
+    verifyNoProxy: [];
+    verifyResourceConfig: [];
+    verifyError: [string];
+    verifyLargePayload: [];
+    verifyTypeSafety: [];
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+    artifactsTracked: [];
+    testRunSuccessful: [];
+    specsModified: [number];
+}>;
+declare const _default: Promise<import("./Pure").PureTesteranto<I, O, {}>>;
+export default _default;

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

@@ -0,0 +1,8 @@
+import { ITTestResourceConfiguration } from "./lib";
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Pure_Sidecar } from "./PM/pureSidecar";
+export declare class PureSideCar extends Sidecar {
+    pm: PM_Pure_Sidecar;
+    start(t: ITTestResourceConfiguration): void;
+    stop(): void;
+}