testeranto 0.134.0 → 0.140.0

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

@@ -29,7 +29,7 @@ export declare abstract class PM {
     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, t: string): Promise<boolean>;
+    abstract writeFileSync(f: string, c: string): Promise<boolean>;
     abstract launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     abstract stopSideCar(n: number): Promise<any>;
 }

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

@@ -1,10 +1,10 @@
 import net from "net";
-import { ITTestResourceConfiguration } from "../lib";
+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;
-    mockListener?: jest.Mock;
     constructor(t: ITTestResourceConfiguration);
     start(stopper: () => any): Promise<void>;
     stop(): Promise<void>;

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

@@ -1,9 +1,9 @@
+import { Ibdd_in_any, Ibdd_out, ITestImplementation, ITestInterface, ITestSpecification } from "./CoreTypes.js";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-import type { INodeTestInterface, IT, ITestImplementation, ITestInterface, ITestSpecification, OT } from "./Types.js";
-export declare class PureTesteranto<I extends IT, O extends OT, M> extends Testeranto<I, O, M> {
+export declare class PureTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Testeranto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<I>>);
     receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults>;
 }
-declare const _default: <I extends IT, O extends OT, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<INodeTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
+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>, testInterface: Partial<INodeTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
 export default _default;

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

@@ -1,9 +1,18 @@
 import { Plugin } from "esbuild";
 import { ITTestResourceConfiguration } from "./lib/index.js";
 import { PM } from "./PM/index.js";
-import { IT, OT } from "../dist/types/src/Types.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
-import { ITestCheckCallback } from "./lib/types.js";
+import { BaseWhen, BaseThen, BaseGiven, BaseCheck, BaseSuite, IGivens } from "./lib/abstractBase.js";
+import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+export type ISummary = Record<string, {
+    runTimeError: string;
+    typeErrors: number;
+    staticErrors: number;
+    prompt: string;
+    failingFeatures: object;
+}>;
+export type SuiteSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
+};
 export type TestSummary = {
     testName: string;
     errors?: {
@@ -49,82 +58,36 @@ export type ProjectConfig = {
     minify?: boolean;
     debug?: boolean;
 };
-export type SuiteSpecification<I extends IT, O extends OT> = {
-    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
-};
-export type GivenSpecification<I extends IT, O extends OT> = {
+export type GivenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
 };
-export type WhenSpecification<I extends IT, O extends OT> = {
+export type WhenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
 };
-export type ThenSpecification<I extends IT, O extends OT> = {
+export type ThenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
 };
-export type ITestSpecification<I extends IT, O extends OT> = (Suite: SuiteSpecification<I, O>, Given: GivenSpecification<I, O>, When: WhenSpecification<I, O>, Then: ThenSpecification<I, O>, Check: ITestCheckCallback<I, O>) => any[];
-export type TestSuiteImplementation<O extends OT> = {
+export type TestSuiteImplementation<O extends Ibdd_out_any> = {
     [K in keyof O["suites"]]: string;
 };
-export type TestGivenImplementation<I extends IT, O extends OT> = {
+export type TestGivenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
 };
-export type TestWhenImplementation<I extends IT, O extends OT> = {
+export type TestWhenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], tr: ITTestResourceConfiguration, utils: PM) => Promise<I["when"]>;
 };
-export type TestThenImplementation<I extends IT, O extends OT> = {
+export type TestThenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
 };
-export type TestCheckImplementation<I extends IT, O extends OT> = {
+export type TestCheckImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
 };
-export type ITestImplementation<I extends IT, O extends OT, modifier = {
-    whens: TestWhenImplementation<I, O>;
-}> = Modify<{
-    suites: TestSuiteImplementation<O>;
-    givens: TestGivenImplementation<I, O>;
-    whens: TestWhenImplementation<I, O>;
-    thens: TestThenImplementation<I, O>;
-    checks: TestCheckImplementation<I, O>;
-}, modifier>;
 export type Modify<T, R> = Omit<T, keyof R> & R;
 export type TestSuiteShape = Record<string, any>;
 export type TestGivenShape = Record<string, any>;
 export type TestWhenShape = Record<string, any>;
 export type TestThenShape = Record<string, any>;
 export type TestCheckShape = Record<string, any>;
-export type Ibdd_out<ISuites extends TestSuiteShape = TestSuiteShape, IGivens extends TestGivenShape = TestGivenShape, IWhens extends TestWhenShape = TestWhenShape, IThens extends TestThenShape = TestThenShape, IChecks extends TestCheckShape = TestCheckShape> = {
-    suites: ISuites;
-    givens: IGivens;
-    whens: IWhens;
-    thens: IThens;
-    checks: IChecks;
-};
-/**
- * Defines the input shape for BDD test definitions.
- * This is the core type that structures all test operations.
- */
-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 IPluginFactory = (register?: (entrypoint: string, sources: string[]) => any, entrypoints?: string[]) => Plugin;
 export type IRunTime = `node` | `web` | "pure" | `spawn`;
 export type ITestTypes = [string, IRunTime, {
@@ -134,10 +97,6 @@ export type ITestconfig = {
     clearScreen: boolean;
     debugger: boolean;
     externals: string[];
-    externalTests: Record<string, {
-        watch: string[];
-        exec: string;
-    }>;
     featureIngestor: (s: string) => Promise<string>;
     importPlugins: IPluginFactory[];
     minify: boolean;
@@ -152,4 +111,5 @@ export type IBuiltConfig = {
 } & ITestconfig;
 export type IProject = {
     projects: Record<string, ITestconfig>;
+    reportDomain: string;
 };

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

@@ -1,9 +1,9 @@
-import type { IT, ITestImplementation, ITestInterface, ITestSpecification, IWebTestInterface, OT } from "./Types";
+import { ITestSpecification, ITestImplementation, ITestInterface, Ibdd_in_any, Ibdd_out } from "./CoreTypes";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-export declare class WebTesteranto<I extends IT, O extends OT, M> extends Testeranto<I, O, M> {
+export declare class WebTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Testeranto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<I>>);
     receiveTestResourceConfig(partialTestResource: any): Promise<import("./lib/index.js").IFinalResults>;
 }
-declare const _default: <I extends IT, O extends OT, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<IWebTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
+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>, testInterface: Partial<IWebTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
 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/lib/abstractBase.d.ts

@@ -1,8 +1,8 @@
-import type { IT, OT } from "../Types.js";
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
 import { IPM } from "./types.js";
-export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
-export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
+import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
+export declare abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
     name: string;
     givens: IGivens<I>;
     checks: BaseCheck<I>[];
@@ -18,10 +18,7 @@ export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
         givens: {
             key: string;
             name: string;
-            whens: {
-                name: string;
-                error: string;
-            }[];
+            whens: {}[];
             thens: {
                 name: string;
                 error: boolean;
@@ -40,7 +37,7 @@ export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
     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>>;
 }
-export declare abstract class BaseGiven<I extends IT = IT> {
+export declare abstract class BaseGiven<I extends Ibdd_in_any> {
     name: string;
     features: string[];
     whens: BaseWhen<I>[];
@@ -58,10 +55,7 @@ export declare abstract class BaseGiven<I extends IT = IT> {
     toObj(): {
         key: string;
         name: string;
-        whens: {
-            name: string;
-            error: string;
-        }[];
+        whens: {}[];
         thens: {
             name: string;
             error: boolean;
@@ -75,7 +69,7 @@ export declare abstract class BaseGiven<I extends IT = IT> {
     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"]>;
 }
-export declare abstract class BaseWhen<I extends IT> {
+export declare abstract class BaseWhen<I extends Ibdd_in_any> {
     name: string;
     whenCB: (x: I["iselection"]) => I["then"];
     error: Error;
@@ -87,7 +81,7 @@ export declare abstract class BaseWhen<I extends IT> {
     };
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<any>;
 }
-export declare abstract class BaseThen<I extends IT> {
+export declare abstract class BaseThen<I extends Ibdd_in_any> {
     name: string;
     thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
     error: boolean;
@@ -100,7 +94,7 @@ export declare abstract class BaseThen<I extends IT> {
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<I["then"] | undefined>;
     check(): void;
 }
-export declare abstract class BaseCheck<I extends IT = IT> {
+export declare abstract class BaseCheck<I extends Ibdd_in_any> {
     key: string;
     name: string;
     features: string[];

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

@@ -1,8 +1,8 @@
-import { IT, ITestSpecification, OT } from "../Types.js";
-import { ITTestResourceRequest, ITestJob } from ".";
+import type { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../CoreTypes";
+import { ITestJob, ITTestResourceRequest } from ".";
 import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser, IPM } from "./types.js";
 import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
-export declare abstract class BaseBuilder<I extends IT, O extends OT, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+export declare abstract class BaseBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
     specs: any;
     assertThis: (t: I["then"]) => {};
     testResourceRequirement: ITTestResourceRequest;

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

@@ -1,9 +1,9 @@
-import { IT, ITestImplementation, ITestSpecification, OT } from "../Types.js";
+import type { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification } from "../CoreTypes";
 import { BaseBuilder } from "./basebuilder.js";
 import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
 import { ITTestResourceRequest } from "./index.js";
 type IExtenstions = Record<string, unknown>;
-export declare abstract class ClassBuilder<I extends IT = IT, O extends OT = OT, M = unknown> extends BaseBuilder<I, O, IExtenstions, IExtenstions, IExtenstions, IExtenstions, IExtenstions> {
+export declare abstract class ClassBuilder<I extends Ibdd_in_any = Ibdd_in_any, O extends Ibdd_out_any = Ibdd_out_any, M = unknown> extends BaseBuilder<I, O, IExtenstions, IExtenstions, IExtenstions, IExtenstions, IExtenstions> {
     constructor(testImplementation: ITestImplementation<I, O, M> & {
         suites: Record<string, any>;
         givens: Record<string, any>;

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

@@ -1,7 +1,7 @@
-import { ITestSpecification, ITestImplementation, ITestInterface, IT, OT } from "../Types.js";
 import { IFinalResults, ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
-export default abstract class Testeranto<I extends IT, O extends OT, M> extends ClassBuilder<I, O, M> {
+import type { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestInterface, ITestSpecification } from "../CoreTypes";
+export default abstract class Testeranto<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends ClassBuilder<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
         suites: Record<string, any>;
         givens: Record<string, any>;

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

@@ -1,10 +1,11 @@
 import { PM_Pure } from "../PM/pure.js";
 import { PM_Node } from "../PM/node.js";
 import { PM_Web } from "../PM/web.js";
-import { Ibdd_in, ITestInterface, ITestconfig, IBuiltConfig, IRunTime, ITestTypes, IT, OT } from "../Types.js";
+import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
-export declare const BaseTestInterface: <T extends IT>() => ITestInterface<T>;
-export declare const DefaultTestInterface: <T extends IT>(p: Partial<ITestInterface<T>>) => ITestInterface<T>;
+import type { ITestInterface, Ibdd_in_any, Ibdd_out_any } from "../CoreTypes.js";
+export declare const BaseTestInterface: <T extends Ibdd_in_any>() => ITestInterface<T>;
+export declare const DefaultTestInterface: <T extends Ibdd_in_any>(p: Partial<ITestInterface<T>>) => ITestInterface<T>;
 export type ITTestResourceConfiguration = {
     name: string;
     fs: string;
@@ -33,14 +34,14 @@ export type ITestArtificer = (key: string, data: any) => void;
 type ITest = {
     toObj(): object;
     name: string;
-    givens: IGivens<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>>;
-    checks: BaseCheck<IT>[];
+    givens: IGivens<Ibdd_in_any>;
+    checks: BaseCheck<Ibdd_in_any>[];
     testResourceConfiguration: ITTestResourceConfiguration;
 };
 export type ITestJob = {
     toObj(): object;
     test: ITest;
-    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IT, OT>>;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<Ibdd_in_any, Ibdd_out_any>>;
     testResourceRequirement: ITTestResourceRequirement;
     receiveTestResourceConfig: (pm: PM_Node | PM_Web | PM_Pure) => IFinalResults;
 };

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

@@ -1,10 +1,10 @@
+import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
 import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
-import type { IT, OT } from "../Types";
 import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 export type IPM = PM_Node | PM_Web | PM_Pure;
-export type TestPhase = 'beforeAll' | 'beforeEach' | 'test' | 'afterEach' | 'afterAll';
+export type TestPhase = "beforeAll" | "beforeEach" | "test" | "afterEach" | "afterAll";
 export type TestError = {
     phase: TestPhase;
     error: Error;
@@ -14,11 +14,11 @@ export type TestError = {
     additionalInfo?: Record<string, unknown>;
     isRetryable?: boolean;
 };
-export type ITestCheckCallback<I extends IT, O extends OT> = {
+export type ITestCheckCallback<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["checks"]]: (name: string, features: string[], checkCallback: (store: I["istore"], pm: IPM) => Promise<O["checks"][K]>, ...xtrasA: O["checks"][K]) => BaseCheck<I>;
 };
-export type ISuiteKlasser<I extends IT, O extends OT> = (name: string, index: number, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
-export type IGivenKlasser<I extends IT> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;
-export type IWhenKlasser<I extends IT> = (s: any, o: any) => BaseWhen<I>;
-export type IThenKlasser<I extends IT> = (s: any, o: any) => BaseThen<I>;
-export type ICheckKlasser<I extends IT> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<I>;
+export type ISuiteKlasser<I extends Ibdd_in_any, O extends Ibdd_out_any> = (name: string, index: number, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
+export type IGivenKlasser<I extends Ibdd_in_any> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;
+export type IWhenKlasser<I extends Ibdd_in_any> = (s: any, o: any) => BaseWhen<I>;
+export type IThenKlasser<I extends Ibdd_in_any> = (s: any, o: any) => BaseThen<I>;
+export type ICheckKlasser<I extends Ibdd_in_any> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<I>;

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

@@ -1,4 +1,4 @@
-import { Ibdd_out, Ibdd_in } from "../Types";
+import { Ibdd_in, Ibdd_out, Ibdd_in_any } from "../CoreTypes";
 import type { Express } from "express";
 type I = Ibdd_in<(port: number) => Express, (port: number) => Express, any, any, any, any, any>;
 type O = Ibdd_out<{
@@ -15,7 +15,7 @@ type O = Ibdd_out<{
 }, {
     AnEmptyState: any;
 }>;
-declare const _default: Promise<import("../lib/core").default<IT, O, {
+declare const _default: Promise<import("../lib/core").default<Ibdd_in_any, O, {
     whens: import("../Types").TestWhenImplementation<I, O>;
 }>>;
 export default _default;

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

@@ -0,0 +1,3 @@
+export declare const testReportPage: (packageName: string, domain: string) => string;
+export declare const testsReportPage: (packageName: string, domain: string, projects: any) => string;
+export declare const idkPage: (testName: string, domain: string) => string;