testeranto.tiposkripto 0.2.0 → 0.2.2

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

@@ -0,0 +1,11 @@
+import { BaseSetup } from "./BaseSetup.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseArrange extends BaseSetup for AAA pattern.
+ */
+export declare class BaseArrange<I extends TestTypeParams_any> extends BaseSetup<I> {
+    constructor(features: string[], acts: any[], asserts: any[], arrangeCB: I["given"], initialValues: any);
+    arrange(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
+}
+export type IArranges<I extends TestTypeParams_any> = Record<string, BaseArrange<I>>;

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

@@ -0,0 +1,13 @@
+import { BaseCheck } from "./BaseCheck.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseAssert extends BaseCheck to support AAA pattern.
+ * It reuses all Check functionality but with AAA naming.
+ */
+export declare class BaseAssert<I extends TestTypeParams_any> extends BaseCheck<I> {
+    constructor(name: string, assertCB: (val: I["iselection"]) => Promise<I["then"]>);
+    verifyAssert(store: I["istore"], assertCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITestResourceConfiguration): Promise<I["iselection"]>;
+    verify(store: I["istore"], testResourceConfiguration: any, filepath: string): Promise<I["then"] | undefined>;
+}
+export type IAsserts<I extends TestTypeParams_any> = Record<string, BaseAssert<I>>;

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

@@ -0,0 +1,25 @@
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseCheck is the unified base class for all verification phases.
+ * It covers BDD's Then, AAA's Assert, and TDT's Validate.
+ * @deprecated Use BaseThen, BaseAssert, or BaseValidate for specific patterns
+ */
+export declare abstract class BaseCheck<I extends TestTypeParams_any> {
+    name: string;
+    checkCB: (storeState: I["iselection"]) => Promise<I["then"]>;
+    error: boolean;
+    artifacts: string[];
+    status: boolean | undefined;
+    constructor(name: string, checkCB: (val: I["iselection"]) => Promise<I["then"]>);
+    addArtifact(path: string): void;
+    toObj(): {
+        name: string;
+        error: boolean;
+        artifacts: string[];
+        status: boolean | undefined;
+    };
+    abstract verifyCheck(store: I["istore"], checkCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITestResourceConfiguration): Promise<I["iselection"]>;
+    test(store: I["istore"], testResourceConfiguration: any, filepath: string): Promise<I["then"] | undefined>;
+}
+export type IChecks<I extends TestTypeParams_any> = Record<string, BaseCheck<I>>;

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

@@ -0,0 +1,15 @@
+import { BaseAction } from "./BaseAction.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
+/**
+ * BaseFeed extends BaseAction to support TDT (Table Driven Testing) pattern.
+ * It processes each row from the table.
+ */
+export declare class BaseFeed<I extends TestTypeParams_any> extends BaseAction<I> {
+    rowIndex: number;
+    rowData: any;
+    constructor(name: string, feedCB: (xyz: I["iselection"]) => I["then"]);
+    setRowData(index: number, data: any): void;
+    feed(store: I["istore"], feedCB: (x: I["iselection"]) => I["then"], testResource: any): Promise<any>;
+    processRow(store: I["istore"], testResourceConfiguration: any, rowIndex: number, rowData: any): Promise<any>;
+}
+export type IFeeds<I extends TestTypeParams_any> = Record<string, BaseFeed<I>>;

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

@@ -1,5 +1,6 @@
-import { Ibdd_in_any } from "./CoreTypes.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
 import { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
+import { BaseSetup } from "./BaseSetup.js";
 /**
  * Represents a collection of Given conditions keyed by their names.
  * Givens are typically organized as named collections because:
@@ -7,9 +8,14 @@ import { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
  * - 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
+ * @deprecated Use BaseSetup for unified terminology
  */
-export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
-export declare abstract class BaseGiven<I extends Ibdd_in_any> {
+export type IGivens<I extends TestTypeParams_any> = Record<string, BaseGiven<I>>;
+/**
+ * BaseGiven extends BaseSetup for BDD pattern.
+ * @deprecated Use BaseSetup for unified terminology
+ */
+export declare abstract class BaseGiven<I extends TestTypeParams_any> extends BaseSetup<I> {
     features: string[];
     whens: any[];
     thens: any[];
@@ -38,6 +44,7 @@ export declare abstract class BaseGiven<I extends Ibdd_in_any> {
         status: boolean | undefined;
     };
     abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any): Promise<I["istore"]>;
+    setupThat(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, artifactory: ITestArtifactory, setupCB: I["given"], initialValues: any): Promise<I["istore"]>;
     afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory): Promise<I["istore"]>;
     give(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
 }

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

@@ -0,0 +1,16 @@
+import { BaseSetup } from "./BaseSetup.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseMap extends BaseSetup to support TDT (Table Driven Testing) pattern.
+ * It sets up the test table data.
+ */
+export declare class BaseMap<I extends TestTypeParams_any> extends BaseSetup<I> {
+    tableData: any[];
+    constructor(features: string[], feeds: any[], // These will be processed as actions
+    validates: any[], // These will be processed as checks
+    mapCB: I["given"], initialValues: any, tableData?: any[]);
+    map(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
+    getTableData(): any[];
+}
+export type IMaps<I extends TestTypeParams_any> = Record<string, BaseMap<I>>;

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

@@ -0,0 +1,39 @@
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseSetup is the unified base class for all setup phases.
+ * It covers BDD's Given, AAA's Arrange, and TDT's Map.
+ * @deprecated Use BaseGiven, BaseArrange, or BaseMap for specific patterns
+ */
+export declare abstract class BaseSetup<I extends TestTypeParams_any> {
+    features: string[];
+    actions: any[];
+    checks: any[];
+    error: Error;
+    fail: any;
+    store: I["istore"];
+    recommendedFsPath: string;
+    setupCB: I["given"];
+    initialValues: any;
+    key: string;
+    failed: boolean;
+    artifacts: string[];
+    fails: number;
+    status: boolean | undefined;
+    addArtifact(path: string): void;
+    constructor(features: string[], actions: any[], checks: any[], setupCB: I["given"], initialValues: any);
+    toObj(): {
+        key: string;
+        actions: any[];
+        checks: any[];
+        error: (string | Error | undefined)[] | null;
+        failed: boolean;
+        features: string[];
+        artifacts: string[];
+        status: boolean | undefined;
+    };
+    abstract setupThat(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, artifactory: ITestArtifactory, setupCB: I["given"], initialValues: any): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory): Promise<I["istore"]>;
+    setup(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
+}
+export type ISetups<I extends TestTypeParams_any> = Record<string, BaseSetup<I>>;

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

@@ -1,4 +1,4 @@
-import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+import { TestTypeParams_any, TestSpecShape_any } from "./CoreTypes.js";
 import { IGivens } from "./BaseGiven";
 import { ITestResourceConfiguration, ITestArtifactory } from "./types.js";
 /**
@@ -9,8 +9,8 @@ import { ITestResourceConfiguration, ITestArtifactory } from "./types.js";
  * - 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> {
+export type ISuites<I extends TestTypeParams_any, O extends TestSpecShape_any> = Record<string, BaseSuite<I, O>>;
+export declare abstract class BaseSuite<I extends TestTypeParams_any, O extends TestSpecShape_any> {
     name: string;
     givens: IGivens<I>;
     store: I["istore"];

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

@@ -1,6 +1,11 @@
-import { Ibdd_in_any } from "./CoreTypes.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
 import { ITestResourceConfiguration } from "./types.js";
-export declare abstract class BaseThen<I extends Ibdd_in_any> {
+import { BaseCheck } from "./BaseCheck.js";
+/**
+ * BaseThen extends BaseCheck for BDD pattern.
+ * @deprecated Use BaseCheck for unified terminology
+ */
+export declare abstract class BaseThen<I extends TestTypeParams_any> extends BaseCheck<I> {
     name: string;
     thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
     error: boolean;
@@ -24,5 +29,6 @@ export declare abstract class BaseThen<I extends Ibdd_in_any> {
  * - 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
+ * @deprecated Use IChecks for unified terminology
  */
-export type IThens<I extends Ibdd_in_any> = Record<string, BaseThen<I>>;
+export type IThens<I extends TestTypeParams_any> = Record<string, BaseThen<I>>;

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

@@ -0,0 +1,15 @@
+import { BaseCheck } from "./BaseCheck.js";
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseValidate extends BaseCheck to support TDT (Table Driven Testing) pattern.
+ * It validates the output against expected results.
+ */
+export declare class BaseValidate<I extends TestTypeParams_any> extends BaseCheck<I> {
+    expectedResult: any;
+    constructor(name: string, validateCB: (val: I["iselection"]) => Promise<I["then"]>);
+    setExpectedResult(expected: any): void;
+    validate(store: I["istore"], validateCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITestResourceConfiguration): Promise<I["iselection"]>;
+    check(store: I["istore"], testResourceConfiguration: any, filepath: string, expectedResult: any): Promise<I["then"] | undefined>;
+}
+export type IValidates<I extends TestTypeParams_any> = Record<string, BaseValidate<I>>;

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

@@ -1,5 +1,10 @@
-import { Ibdd_in_any } from "./CoreTypes.js";
-export declare abstract class BaseWhen<I extends Ibdd_in_any> {
+import { TestTypeParams_any } from "./CoreTypes.js";
+import { BaseAction } from "./BaseAction.js";
+/**
+ * BaseWhen extends BaseAction for BDD pattern.
+ * @deprecated Use BaseAction for unified terminology
+ */
+export declare abstract class BaseWhen<I extends TestTypeParams_any> extends BaseAction<I> {
     name: string;
     whenCB: (x: I["iselection"]) => I["then"];
     error: Error;
@@ -8,6 +13,7 @@ export declare abstract class BaseWhen<I extends Ibdd_in_any> {
     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): Promise<any>;
+    performAction(store: I["istore"], actionCB: (x: I["iselection"]) => I["then"], testResource: any): Promise<any>;
     toObj(): {
         name: string;
         status: boolean | undefined;
@@ -23,5 +29,6 @@ export declare abstract class BaseWhen<I extends Ibdd_in_any> {
  * - 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
+ * @deprecated Use IActions for unified terminology
  */
-export type IWhens<I extends Ibdd_in_any> = Record<string, BaseWhen<I>>;
+export type IWhens<I extends TestTypeParams_any> = Record<string, BaseWhen<I>>;

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

@@ -5,15 +5,16 @@ import { ITestResourceConfiguration } from "./types";
 export type SuiteSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["suites"]]: (name: string, givens: IGivens<I>) => BaseSuite<I, O>;
 };
-export type ITestAdapter<I extends Ibdd_in_any> = {
-    assertThis: (x: I["then"]) => any;
-    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITestResourceConfiguration) => Promise<I["istore"]>;
-    butThen: (store: I["istore"], thenCB: I["then"], testResource: ITestResourceConfiguration) => Promise<I["iselection"]>;
-    afterAll: (store: I["istore"]) => any;
-    afterEach: (store: I["istore"], key: string) => Promise<unknown>;
-    beforeAll: (input: I["iinput"], testResource: ITestResourceConfiguration) => Promise<I["isubject"]>;
-    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITestResourceConfiguration, initialValues: any) => Promise<I["istore"]>;
+export type IUniversalTestAdapter<I extends TestTypeParams_any> = {
+    prepareAll: (input: I["iinput"], testResource: ITestResourceConfiguration) => Promise<I["isubject"]>;
+    prepareEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITestResourceConfiguration, initialValues: any) => Promise<I["istore"]>;
+    execute: (store: I["istore"], actionCB: I["when"], testResource: ITestResourceConfiguration) => Promise<I["istore"]>;
+    verify: (store: I["istore"], checkCB: I["then"], testResource: ITestResourceConfiguration) => Promise<I["iselection"]>;
+    cleanupEach: (store: I["istore"], key: string) => Promise<unknown>;
+    cleanupAll: (store: I["istore"]) => any;
+    assert: (x: I["then"]) => any;
 };
+export type ITestAdapter<I extends TestTypeParams_any> = IUniversalTestAdapter<I>;
 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>;
@@ -23,20 +24,22 @@ export type ITestImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any, m
     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> = {
+export type TestSpecShape<ISuites extends TestSuiteShape = TestSuiteShape, ISetups extends TestGivenShape = TestGivenShape, IActions extends TestWhenShape = TestWhenShape, IChecks extends TestThenShape = TestThenShape> = {
     suites: ISuites;
-    givens: IGivens;
-    whens: IWhens;
-    thens: IThens;
+    givens: ISetups;
+    whens: IActions;
+    thens: IChecks;
 };
-export type Ibdd_out_any = Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape>;
-export type Ibdd_in<IInput, // Type of initial test input
+export type TestSpecShape_any = TestSpecShape<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape>;
+export type Ibdd_out<ISuites, IGivens, IWhens, IThens> = TestSpecShape<ISuites, IGivens, IWhens, IThens>;
+export type Ibdd_out_any = TestSpecShape_any;
+export type TestTypeParams<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> = {
+ISetup, // Type for Setup step functions (formerly Given)
+IAction, // Type for Action step functions (formerly When)
+ICheck> = {
     /** Initial input required to start tests */
     iinput: IInput;
     /** The subject being tested (class, function, etc) */
@@ -45,11 +48,13 @@ IThen> = {
     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;
+    /** Function type for Setup steps (Given/Arrange/Map) */
+    given: ISetup;
+    /** Function type for Action steps (When/Act/Feed) */
+    when: IAction;
+    /** Function type for Check steps (Then/Assert/Validate) */
+    then: ICheck;
 };
-export type Ibdd_in_any = Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
+export type TestTypeParams_any = TestTypeParams<unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
+export type Ibdd_in<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen> = TestTypeParams<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen>;
+export type Ibdd_in_any = TestTypeParams_any;

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

@@ -1,9 +1,9 @@
-import { Ibdd_in_any, Ibdd_out_any, ITestSpecification, ITestImplementation, ITestAdapter, Ibdd_out } from "./CoreTypes";
+import { TestTypeParams_any, TestSpecShape_any, ITestSpecification, ITestImplementation, ITestAdapter } from "./CoreTypes";
 import BaseTiposkripto from "./BaseTiposkripto";
 import { ITTestResourceRequest } from "./types";
-export declare class NodeTiposkripto<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends BaseTiposkripto<I, O, M> {
+export declare class NodeTiposkripto<I extends TestTypeParams_any, O extends TestSpecShape_any, M> extends BaseTiposkripto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
     writeFileSync(filename: string, payload: string): void;
 }
-declare const tiposkripto: <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<BaseTiposkripto<I, O, M>>;
+declare const tiposkripto: <I extends TestTypeParams_any, O extends TestSpecShape_any, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<BaseTiposkripto<I, O, M>>;
 export default tiposkripto;

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

@@ -1,9 +1,9 @@
-import { Ibdd_in_any, Ibdd_out, Ibdd_out_any, ITestAdapter, ITestImplementation, ITestSpecification } from "./CoreTypes.js";
+import { TestTypeParams_any, TestSpecShape_any, ITestAdapter, ITestImplementation, ITestSpecification } from "./CoreTypes.js";
 import BaseTiposkripto from "./BaseTiposkripto";
 import { ITTestResourceRequest } from "./types";
-export declare class WebTiposkripto<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends BaseTiposkripto<I, O, M> {
+export declare class WebTiposkripto<I extends TestTypeParams_any, O extends TestSpecShape_any, M> extends BaseTiposkripto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
     writeFileSync(filename: string, payload: string): void;
 }
-declare const tiposkripto: <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<BaseTiposkripto<I, O, M>>;
+declare const tiposkripto: <I extends TestTypeParams_any, O extends TestSpecShape_any, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<BaseTiposkripto<I, O, M>>;
 export default tiposkripto;

package/dist/types/lib/tiposkripto/src/flavored/Decorators.d.ts

@@ -0,0 +1,22 @@
+export declare function suite(name: string): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => {
+    new (...args: any[]): {};
+    suiteName: string;
+    isTestSuite: boolean;
+    tests: Array<{
+        given: string;
+        when?: string;
+        then?: string;
+        method: string;
+        args?: any[];
+    }>;
+} & T;
+export declare function given(description: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function when(description: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function then(description: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function runSuite(testClass: any): Promise<{
+    suiteName: any;
+    tests: never[];
+    passed: boolean;
+}>;

package/dist/types/lib/tiposkripto/src/flavored/FluentBuilder.d.ts

@@ -0,0 +1,31 @@
+export declare class FluentTestBuilder<T = any> {
+    private givenDesc;
+    private setup;
+    private whenSteps;
+    private thenSteps;
+    constructor(givenDesc: string, setup: () => T | Promise<T>);
+    when<A extends any[]>(description: string, action: (store: T, ...args: A) => T | Promise<T>, ...args: A): this;
+    then<A extends any[]>(description: string, assertion: (store: T, ...args: A) => void | Promise<void>, ...args: A): this;
+    run(): Promise<{
+        success: boolean;
+        store?: T;
+        error?: any;
+    }>;
+    toBaseline(): {
+        specification: (Suite: any, Given: any, When: any, Then: any) => any[];
+        implementation: {
+            suites: {
+                Default: string;
+            };
+            givens: {
+                Default: () => () => T | Promise<T>;
+            };
+            whens: Record<string, Function>;
+            thens: Record<string, Function>;
+        };
+    };
+}
+export declare function given<T>(description: string, setup: () => T | Promise<T>): FluentTestBuilder<T>;
+export declare const flavored: {
+    given: typeof given;
+};

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

@@ -0,0 +1,17 @@
+export * from './Decorators';
+export * from './FluentBuilder';
+import { given, flavored } from './FluentBuilder';
+import { suite, given as givenDecorator, when, then, runSuite } from './Decorators';
+export { given, flavored, suite, givenDecorator, when, then, runSuite };
+declare const _default: {
+    given: typeof given;
+    flavored: {
+        given: typeof given;
+    };
+    suite: typeof suite;
+    givenDecorator: typeof givenDecorator;
+    when: typeof when;
+    then: typeof then;
+    runSuite: typeof runSuite;
+};
+export default _default;

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

@@ -1,3 +1,45 @@
-import { Ibdd_in_any, ITestAdapter } from "./CoreTypes";
-export declare const BaseAdapter: <T extends Ibdd_in_any>() => ITestAdapter<T>;
-export declare const DefaultAdapter: <T extends Ibdd_in_any>(p: Partial<ITestAdapter<T>>) => ITestAdapter<T>;
+import { Ibdd_in_any } from "./CoreTypes";
+export declare const BaseAdapter: <T extends TestTypeParams_any>() => IUniversalTestAdapter<T>;
+export declare const DefaultAdapter: <T extends TestTypeParams_any>(p: Partial<IUniversalTestAdapter<T>>) => IUniversalTestAdapter<T>;
+export { BaseSetup } from "./BaseSetup.js";
+export { BaseAction } from "./BaseAction.js";
+export { BaseCheck } from "./BaseCheck.js";
+export { BaseArrange } from "./BaseArrange.js";
+export { BaseAct } from "./BaseAct.js";
+export { BaseAssert } from "./BaseAssert.js";
+export { BaseMap } from "./BaseMap.js";
+export { BaseFeed } from "./BaseFeed.js";
+export { BaseValidate } from "./BaseValidate.js";
+export { BaseGiven } from "./BaseGiven.js";
+export { BaseWhen } from "./BaseWhen.js";
+export { BaseThen } from "./BaseThen.js";
+export declare function createAAASpecification<I extends Ibdd_in_any, O extends Ibdd_out_any>(Suite: any, Arrange: any, Act: any, Assert: any): {
+    Suite: {
+        Default: (name: string, arrangements: Record<string, any>) => any;
+    };
+    Arrange: {
+        Default: (features: string[], acts: any[], asserts: any[], arrangeCB: I["given"], initialValues: any) => any;
+    };
+    Act: {
+        Default: (name: string, actCB: (x: I["iselection"]) => I["then"]) => any;
+    };
+    Assert: {
+        Default: (name: string, assertCB: (val: I["iselection"]) => Promise<I["then"]>) => any;
+    };
+};
+export declare function createTDTSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any>(Suite: any, Map: any, Feed: any, Validate: any): {
+    Suite: {
+        Default: (name: string, maps: Record<string, any>) => any;
+    };
+    Map: {
+        Default: (features: string[], feeds: any[], validates: any[], mapCB: I["given"], initialValues: any, tableData?: any[]) => any;
+    };
+    Feed: {
+        Default: (name: string, feedCB: (x: I["iselection"]) => I["then"]) => any;
+    };
+    Validate: {
+        Default: (name: string, validateCB: (val: I["iselection"]) => Promise<I["then"]>) => any;
+    };
+};
+export declare const AAA: typeof createAAASpecification;
+export declare const TDT: typeof createTDTSpecification;

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

@@ -21,6 +21,18 @@ export type ITTestResourceRequirement = {
     ports: number;
     fs: string;
 };
+export type ISetups<I extends TestTypeParams_any> = Record<string, import("./BaseSetup").BaseSetup<I>>;
+export type IActions<I extends TestTypeParams_any> = Record<string, import("./BaseAction").BaseAction<I>>;
+export type IChecks<I extends TestTypeParams_any> = Record<string, import("./BaseCheck").BaseCheck<I>>;
+export type IArranges<I extends TestTypeParams_any> = Record<string, import("./BaseArrange").BaseArrange<I>>;
+export type IActs<I extends TestTypeParams_any> = Record<string, import("./BaseAct").BaseAct<I>>;
+export type IAsserts<I extends TestTypeParams_any> = Record<string, import("./BaseAssert").BaseAssert<I>>;
+export type IMaps<I extends TestTypeParams_any> = Record<string, import("./BaseMap").BaseMap<I>>;
+export type IFeeds<I extends TestTypeParams_any> = Record<string, import("./BaseFeed").BaseFeed<I>>;
+export type IValidates<I extends TestTypeParams_any> = Record<string, import("./BaseValidate").BaseValidate<I>>;
+export type IGivens<I extends TestTypeParams_any> = Record<string, import("./BaseGiven").BaseGiven<I>>;
+export type IWhens<I extends TestTypeParams_any> = Record<string, import("./BaseWhen").BaseWhen<I>>;
+export type IThens<I extends TestTypeParams_any> = Record<string, import("./BaseThen").BaseThen<I>>;
 export type ITTestResourceRequest = {
     ports: number;
 };