testeranto.tiposkripto 0.2.21 → 0.3.1

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

@@ -1,8 +1,8 @@
 import type { TestTypeParams_any } from "./CoreTypes.js";
 /**
- * BaseAction is the unified base class for all action phases.
+ * BaseAction is the internal unified base class for all action phases.
  * It covers BDD's When, AAA's Act, and TDT's Feed.
- * @deprecated Use BaseWhen, BaseAct, or BaseFeed for specific patterns
+ * This class is not exposed to users - use BaseWhen, BaseShould, or BaseIt instead.
  */
 export declare abstract class BaseAction<I extends TestTypeParams_any> {
     name: string;

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

@@ -1,9 +1,9 @@
 import type { TestTypeParams_any } from "./CoreTypes.js";
 import type { ITestResourceConfiguration } from "./types.js";
 /**
- * BaseCheck is the unified base class for all verification phases.
+ * BaseCheck is the internal 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
+ * This class is not exposed to users - use BaseThen, BaseExpected, or BaseAssert instead.
  */
 export declare abstract class BaseCheck<I extends TestTypeParams_any> {
     name: string;

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

@@ -0,0 +1,26 @@
+import { BaseSetup } from "./BaseSetup.js";
+import type { TestTypeParams_any } from "./CoreTypes.js";
+import type { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseDescribe extends BaseSetup for Describe-It pattern (AAA).
+ * Describe can be nested, and Its can mix mutations and assertions.
+ */
+export declare class BaseDescribe<I extends TestTypeParams_any> extends BaseSetup<I> {
+    /**
+     * Abstract method to be implemented by concrete Describe classes.
+     * Sets up the initial state for the Describe-It pattern (AAA Arrange phase).
+     *
+     * @param subject The test subject
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @param setupCB Setup callback function
+     * @param initialValues Initial values for setup
+     * @returns Promise resolving to the test store
+     */
+    abstract setupThat(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, artifactory: ITestArtifactory, setupCB: I["given"], initialValues: any): Promise<I["istore"]>;
+    its: any[];
+    constructor(features: string[], its: any[], describeCB: I["given"], initialValues: any);
+    setup(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
+    private createArtifactoryForIt;
+}
+export type IDescribes<I extends TestTypeParams_any> = Record<string, BaseDescribe<I>>;

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

@@ -0,0 +1,25 @@
+import { BaseCheck } from "./BaseCheck.js";
+import type { TestTypeParams_any } from "./CoreTypes.js";
+import type { ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseExpected extends BaseCheck for TDT pattern.
+ * Validates each row in table-driven testing.
+ */
+export declare class BaseExpected<I extends TestTypeParams_any> extends BaseCheck<I> {
+    /**
+     * Abstract method to be implemented by concrete Expected classes.
+     * Validates each row in table-driven testing (TDT pattern).
+     *
+     * @param store The test store
+     * @param checkCB Check callback function
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the selection for verification
+     */
+    abstract verifyCheck(store: I["istore"], checkCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITestResourceConfiguration, artifactory?: any): Promise<I["iselection"]>;
+    expectedValue: any;
+    constructor(name: string, expectedCB: (val: I["iselection"]) => Promise<I["then"]>);
+    setExpectedValue(expected: any): void;
+    validateRow(store: I["istore"], testResourceConfiguration: any, filepath: string, expectedValue: any, artifactory?: any): Promise<I["then"] | undefined>;
+}
+export type IExpecteds<I extends TestTypeParams_any> = Record<string, BaseExpected<I>>;

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

@@ -8,12 +8,10 @@ import { BaseSetup } from "./BaseSetup.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 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[];
@@ -44,6 +42,17 @@ export declare abstract class BaseGiven<I extends TestTypeParams_any> extends Ba
         artifacts: string[];
         status: boolean | undefined;
     };
+    /**
+     * Abstract method to be implemented by concrete Given classes.
+     * Sets up the initial state for the BDD Given phase.
+     *
+     * @param subject The test subject
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @param givenCB Given callback function
+     * @param initialValues Initial values for setup
+     * @returns Promise resolving to the test store
+     */
     abstract givenThat(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, 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"]>;

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

@@ -0,0 +1,23 @@
+import { BaseAction } from "./BaseAction.js";
+import type { TestTypeParams_any } from "./CoreTypes.js";
+/**
+ * BaseIt extends BaseAction for Describe-It pattern.
+ * Its can mix mutations and assertions, unlike BDD's When which only does mutations.
+ */
+export declare class BaseIt<I extends TestTypeParams_any> extends BaseAction<I> {
+    /**
+     * Abstract method to be implemented by concrete It classes.
+     * Performs the action for the Describe-It pattern (AAA Act/Assert combined phase).
+     *
+     * @param store The test store
+     * @param actionCB Action callback function
+     * @param testResource Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the result of the action
+     */
+    abstract performAction(store: I["istore"], actionCB: (x: I["iselection"]) => I["then"], testResource: any, artifactory?: any): Promise<any>;
+    constructor(name: string, itCB: (xyz: I["iselection"]) => I["then"]);
+    test(store: I["istore"], testResourceConfiguration: any, artifactory?: any): Promise<any>;
+    performIt(store: I["istore"], itCB: (x: I["iselection"]) => I["then"], testResource: any, artifactory?: any): Promise<any>;
+}
+export type IIts<I extends TestTypeParams_any> = Record<string, BaseIt<I>>;

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

@@ -1,9 +1,9 @@
 import type { TestTypeParams_any } from "./CoreTypes.js";
 import type { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
 /**
- * BaseSetup is the unified base class for all setup phases.
+ * BaseSetup is the internal 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
+ * This class is not exposed to users - use BaseGiven, BaseValue, or BaseDescribe instead.
  */
 export declare abstract class BaseSetup<I extends TestTypeParams_any> {
     features: string[];

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

@@ -0,0 +1,25 @@
+import { BaseAction } from "./BaseAction.js";
+import type { TestTypeParams_any } from "./CoreTypes.js";
+/**
+ * BaseShould extends BaseAction for TDT pattern.
+ * Processes each row in table-driven testing.
+ */
+export declare class BaseShould<I extends TestTypeParams_any> extends BaseAction<I> {
+    /**
+     * Abstract method to be implemented by concrete Should classes.
+     * Processes each row in table-driven testing (TDT pattern).
+     *
+     * @param store The test store
+     * @param actionCB Action callback function
+     * @param testResource Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the result of the action
+     */
+    abstract performAction(store: I["istore"], actionCB: (x: I["iselection"]) => I["then"], testResource: any, artifactory?: any): Promise<any>;
+    currentRow: any[];
+    rowIndex: number;
+    constructor(name: string, shouldCB: (xyz: I["iselection"]) => I["then"]);
+    setRowData(rowIndex: number, rowData: any[]): void;
+    processRow(store: I["istore"], testResourceConfiguration: any, artifactory?: any): Promise<any>;
+}
+export type IShoulds<I extends TestTypeParams_any> = Record<string, BaseShould<I>>;

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

@@ -3,11 +3,20 @@ import type { ITestResourceConfiguration } from "./types.js";
 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> {
     thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
     constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
+    /**
+     * Abstract method to be implemented by concrete Then classes.
+     * Performs the verification for the BDD Then phase.
+     *
+     * @param store The test store
+     * @param thenCB Then callback function
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the selection for verification
+     */
     abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITestResourceConfiguration, artifactory?: any): Promise<I["iselection"]>;
     test(store: I["istore"], testResourceConfiguration: ITestResourceConfiguration, filepath: string, artifactory?: any): Promise<I["then"] | undefined>;
 }
@@ -18,6 +27,5 @@ export declare abstract class BaseThen<I extends TestTypeParams_any> extends Bas
  * - 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 TestTypeParams_any> = Record<string, BaseThen<I>>;

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

@@ -25,15 +25,17 @@ export default abstract class BaseTiposkripto<I extends Ibdd_in_any = Ibdd_in_an
         suiteIndex?: number;
     }): {
         writeFileSync: (filename: string, payload: string) => void;
-        screenshot: (filename: string, payload?: string) => void;
-        openScreencast: (filename: string) => Promise<void>;
-        closeScreencast: (filename: string) => Promise<void>;
     };
     constructor(webOrNode: "web" | "node", input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
         suites: Record<string, object>;
-        givens: Record<string, any>;
-        whens: Record<string, any>;
-        thens: Record<string, any>;
+        givens?: Record<string, any>;
+        whens?: Record<string, any>;
+        thens?: Record<string, any>;
+        values?: Record<string, any>;
+        shoulds?: Record<string, any>;
+        expecteds?: Record<string, any>;
+        describes?: Record<string, any>;
+        its?: Record<string, any>;
     }, testResourceRequirement: ITTestResourceRequest | undefined, testAdapter: Partial<ITestAdapter<I>> | undefined, testResourceConfiguration: ITestResourceConfiguration, wsPort?: string, wsHost?: string);
     receiveTestResourceConfig(testResourceConfig: ITestResourceConfiguration): Promise<any>;
     Specs(): any;

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

@@ -0,0 +1,27 @@
+import { BaseSetup } from "./BaseSetup.js";
+import type { TestTypeParams_any } from "./CoreTypes.js";
+import type { ITestArtifactory, ITestResourceConfiguration } from "./types.js";
+/**
+ * BaseValue extends BaseSetup for TDT pattern.
+ * Sets up table data for table-driven testing.
+ */
+export declare class BaseValue<I extends TestTypeParams_any> extends BaseSetup<I> {
+    /**
+     * Abstract method to be implemented by concrete Value classes.
+     * Sets up table data for the TDT (Table-Driven Testing) pattern.
+     *
+     * @param subject The test subject
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @param setupCB Setup callback function
+     * @param initialValues Initial values for setup
+     * @returns Promise resolving to the test store
+     */
+    abstract setupThat(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, artifactory: ITestArtifactory, setupCB: I["given"], initialValues: any): Promise<I["istore"]>;
+    tableRows: any[][];
+    constructor(features: string[], tableRows: any[][], confirmCB: I["given"], initialValues: any);
+    setup(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
+    private processRow;
+    private createArtifactoryForRow;
+}
+export type IValues<I extends TestTypeParams_any> = Record<string, BaseValue<I>>;

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

@@ -2,11 +2,20 @@ import type { 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> {
     whenCB: (x: I["iselection"]) => I["then"];
     constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
+    /**
+     * Abstract method to be implemented by concrete When classes.
+     * Performs the action for the BDD When phase.
+     *
+     * @param store The test store
+     * @param whenCB When callback function
+     * @param testResource Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the result of the action
+     */
     abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, artifactory?: any): Promise<any>;
     performAction(store: I["istore"], actionCB: (x: I["iselection"]) => I["then"], testResource: any): Promise<any>;
     test(store: I["istore"], testResourceConfiguration: any, artifactory?: any): Promise<any>;
@@ -18,6 +27,5 @@ export declare abstract class BaseWhen<I extends TestTypeParams_any> extends Bas
  * - 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 TestTypeParams_any> = Record<string, BaseWhen<I>>;

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

@@ -12,8 +12,19 @@ export declare class WebTiposkripto<I extends TestTypeParams_any, O extends Test
     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;
     screenshot(filename: string, payload?: string): void;
-    openScreencast(filename: string): void;
-    closeScreencast(filename: string): void;
+    openScreencast(filename: string): Promise<void>;
+    closeScreencast(filename: string): Promise<void>;
+    createArtifactory(context?: {
+        givenKey?: string;
+        whenIndex?: number;
+        thenIndex?: number;
+        suiteIndex?: number;
+    }): {
+        screenshot: (filename: string, payload?: string) => void;
+        openScreencast: (filename: string) => Promise<void>;
+        closeScreencast: (filename: string) => Promise<void>;
+        writeFileSync: (filename: string, payload: string) => void;
+    };
 }
 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/index.d.ts

@@ -1,102 +1,89 @@
 import type { Ibdd_in_any, Ibdd_out_any, IUniversalTestAdapter, ITestAdapter, TestTypeParams_any } from "./CoreTypes";
 export declare const BaseAdapter: <T extends TestTypeParams_any>() => IUniversalTestAdapter<T>;
 export declare const DefaultAdapter: <T extends TestTypeParams_any>(p: Partial<ITestAdapter<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>(): {
+export { BaseValue } from "./BaseValue.js";
+export { BaseShould } from "./BaseShould.js";
+export { BaseExpected } from "./BaseExpected.js";
+export { BaseDescribe } from "./BaseDescribe.js";
+export { BaseIt } from "./BaseIt.js";
+export { BaseSetup } from "./BaseSetup.js";
+export { BaseAction } from "./BaseAction.js";
+export { BaseCheck } from "./BaseCheck.js";
+export declare function createDescribeItSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
     Suite: {
-        Default: (Suite: any, Arrange: any, Act: any, Assert: any) => (name: string, arrangements: Record<string, any>) => any;
-    };
-    Arrange: {
-        Default: (features: string[], acts: any[], asserts: any[], arrangeCB: I["given"], initialValues: any) => (Arrange: any) => any;
+        Default: (Suite: any, Describe: any, It: any) => (name: string, descriptions: Record<string, any>) => any;
     };
-    Act: {
-        Default: (name: string, actCB: (x: I["iselection"]) => I["then"]) => (Act: any) => any;
+    Describe: {
+        Default: (features: string[], its: any[], describeCB: I["given"], initialValues: any) => (Describe: any) => any;
     };
-    Assert: {
-        Default: (name: string, assertCB: (val: I["iselection"]) => Promise<I["then"]>) => (Assert: any) => any;
+    It: {
+        Default: (name: string, itCB: (x: I["iselection"]) => I["then"]) => (It: any) => any;
     };
 };
 export declare function createTDTSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
     Suite: {
-        Default: (Suite: any, Map: any, Feed: any, Validate: any) => (name: string, maps: Record<string, any>) => any;
+        Default: (Suite: any, Value: any, Should: any, Expected: any) => (name: string, confirms: Record<string, any>) => any;
     };
-    Map: {
-        Default: (features: string[], feeds: any[], validates: any[], mapCB: I["given"], initialValues: any, tableData?: any[]) => (Map: any) => any;
+    Value: {
+        Default: (features: string[], tableRows: any[][], confirmCB: I["given"], initialValues: any) => (Value: any) => any;
     };
-    Feed: {
-        Default: (name: string, feedCB: (x: I["iselection"]) => I["then"]) => (Feed: any) => any;
+    Should: {
+        Default: (name: string, shouldCB: (x: I["iselection"]) => I["then"]) => (Should: any) => any;
     };
-    Validate: {
-        Default: (name: string, validateCB: (val: I["iselection"]) => Promise<I["then"]>) => (Validate: any) => any;
+    Expected: {
+        Default: (name: string, expectedCB: (val: I["iselection"]) => Promise<I["then"]>) => (Expected: any) => any;
     };
 };
-export declare function AAA<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
+export declare function DescribeIt<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
     Suite: {
-        Default: (name: string, arrangements: Record<string, any>) => {
+        Default: (name: string, descriptions: Record<string, any>) => {
             name: string;
-            arrangements: Record<string, any>;
+            descriptions: Record<string, any>;
         };
     };
-    Arrange: {
-        Default: (features: string[], acts: any[], asserts: any[], arrangeCB: I["given"], initialValues: any) => {
+    Describe: {
+        Default: (features: string[], its: any[], describeCB: I["given"], initialValues: any) => {
             features: string[];
-            acts: any[];
-            asserts: any[];
-            arrangeCB: I["given"];
+            its: any[];
+            describeCB: I["given"];
             initialValues: any;
         };
     };
-    Act: {
-        Default: (name: string, actCB: (x: I["iselection"]) => I["then"]) => {
-            name: string;
-            actCB: (x: I["iselection"]) => I["then"];
-        };
-    };
-    Assert: {
-        Default: (name: string, assertCB: (val: I["iselection"]) => Promise<I["then"]>) => {
+    It: {
+        Default: (name: string, itCB: (x: I["iselection"]) => I["then"]) => {
             name: string;
-            assertCB: (val: I["iselection"]) => Promise<I["then"]>;
+            itCB: (x: I["iselection"]) => I["then"];
         };
     };
 };
-export declare function TDT<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
+export declare function Confirm<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
     Suite: {
-        Default: (name: string, maps: Record<string, any>) => {
+        Default: (name: string, confirms: Record<string, any>) => {
             name: string;
-            maps: Record<string, any>;
+            confirms: Record<string, any>;
         };
     };
-    Map: {
-        Default: (features: string[], feeds: any[], validates: any[], mapCB: I["given"], initialValues: any, tableData?: any[]) => {
+    Value: {
+        Default: (features: string[], tableRows: any[][], confirmCB: I["given"], initialValues: any) => {
             features: string[];
-            feeds: any[];
-            validates: any[];
-            mapCB: I["given"];
+            tableRows: any[][];
+            confirmCB: I["given"];
             initialValues: any;
-            tableData: any[];
         };
     };
-    Feed: {
-        Default: (name: string, feedCB: (x: I["iselection"]) => I["then"]) => {
+    Should: {
+        Default: (name: string, shouldCB: (x: I["iselection"]) => I["then"]) => {
             name: string;
-            feedCB: (x: I["iselection"]) => I["then"];
+            shouldCB: (x: I["iselection"]) => I["then"];
         };
     };
-    Validate: {
-        Default: (name: string, validateCB: (val: I["iselection"]) => Promise<I["then"]>) => {
+    Expected: {
+        Default: (name: string, expectedCB: (val: I["iselection"]) => Promise<I["then"]>) => {
             name: string;
-            validateCB: (val: I["iselection"]) => Promise<I["then"]>;
+            expectedCB: (val: I["iselection"]) => Promise<I["then"]>;
         };
     };
 };

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

@@ -24,12 +24,11 @@ export type ITTestResourceRequirement = {
 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 IValues<I extends TestTypeParams_any> = Record<string, import("./BaseValue").BaseValue<I>>;
+export type IShoulds<I extends TestTypeParams_any> = Record<string, import("./BaseShould").BaseShould<I>>;
+export type IExpecteds<I extends TestTypeParams_any> = Record<string, import("./BaseExpected").BaseExpected<I>>;
+export type IDescribes<I extends TestTypeParams_any> = Record<string, import("./BaseDescribe").BaseDescribe<I>>;
+export type IIts<I extends TestTypeParams_any> = Record<string, import("./BaseIt").BaseIt<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>>;