@nestia/e2e 11.0.0-dev.20260305 → 11.0.0-dev.20260312

package/lib/ArrayUtil.d.ts

@@ -0,0 +1,244 @@
+/**
+ * A namespace providing utility functions for array manipulation.
+ *
+ * This namespace contains utility functions for array operations including
+ * asynchronous processing, filtering, mapping, and repetition tasks implemented
+ * in functional programming style. Functions use direct parameter passing for
+ * simplicity while maintaining functional programming principles.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   // Asynchronous filtering example
+ *   const numbers = [1, 2, 3, 4, 5];
+ *   const evenNumbers = await ArrayUtil.asyncFilter(numbers,
+ *     async (num) => num % 2 === 0
+ *   );
+ *   console.log(evenNumbers); // [2, 4]
+ *   ```;
+ */
+export declare namespace ArrayUtil {
+    /**
+     * Filters an array by applying an asynchronous predicate function to each
+     * element.
+     *
+     * Elements are processed sequentially, ensuring order is maintained. The
+     * predicate function receives the element, index, and the full array as
+     * parameters.
+     *
+     * @example
+     *   ```typescript
+     *   const users = [
+     *     { id: 1, name: 'Alice', active: true },
+     *     { id: 2, name: 'Bob', active: false },
+     *     { id: 3, name: 'Charlie', active: true }
+     *   ];
+     *
+     *   const activeUsers = await ArrayUtil.asyncFilter(users,
+     *     async (user) => {
+     *       // Async validation logic (e.g., API call)
+     *       await new Promise(resolve => setTimeout(resolve, 100));
+     *       return user.active;
+     *     }
+     *   );
+     *   console.log(activeUsers); // [{ id: 1, name: 'Alice', active: true }, { id: 3, name: 'Charlie', active: true }]
+     *   ```;
+     *
+     * @template Input - The type of elements in the input array
+     * @param elements - The readonly array to filter
+     * @param pred - The asynchronous predicate function to test each element
+     * @returns A Promise resolving to the filtered array
+     */
+    const asyncFilter: <Input>(elements: readonly Input[], pred: (elem: Input, index: number, array: readonly Input[]) => Promise<boolean>) => Promise<Input[]>;
+    /**
+     * Executes an asynchronous function for each element in an array
+     * sequentially.
+     *
+     * Unlike JavaScript's native forEach, this function processes asynchronous
+     * functions sequentially and waits for all operations to complete. It
+     * performs sequential processing rather than parallel processing, making it
+     * suitable for operations where order matters.
+     *
+     * @example
+     *   ```typescript
+     *   const urls = ['url1', 'url2', 'url3'];
+     *
+     *   await ArrayUtil.asyncForEach(urls, async (url, index) => {
+     *   console.log(`Processing ${index}: ${url}`);
+     *   const data = await fetch(url);
+     *   await processData(data);
+     *   console.log(`Completed ${index}: ${url}`);
+     *   });
+     *   console.log('All URLs processed sequentially');
+     *   ```
+     *
+     * @template Input - The type of elements in the input array
+     * @param elements - The readonly array to process
+     * @param closure - The asynchronous function to execute for each element
+     * @returns A Promise<void> that resolves when all operations complete
+     */
+    const asyncForEach: <Input>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<any>) => Promise<void>;
+    /**
+     * Transforms each element of an array using an asynchronous function to
+     * create a new array.
+     *
+     * Similar to JavaScript's native map but processes asynchronous functions
+     * sequentially. Each element's transformation is completed before proceeding
+     * to the next element, ensuring order is maintained. This function still
+     * maintains the currying pattern for composition.
+     *
+     * @example
+     *   ```typescript
+     *   const userIds = [1, 2, 3, 4, 5];
+     *
+     *   const userDetails = await ArrayUtil.asyncMap(userIds)(
+     *   async (id, index) => {
+     *   console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);
+     *   const response = await fetch(`/api/users/${id}`);
+     *   return await response.json();
+     *   }
+     *   );
+     *   console.log('All users fetched:', userDetails);
+     *   ```
+     *
+     * @template Input - The type of elements in the input array
+     * @param elements - The readonly array to transform
+     * @returns A function that takes a transformation function and returns a
+     *   Promise resolving to the transformed array
+     */
+    const asyncMap: <Input, Output>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<Output>) => Promise<Output[]>;
+    /**
+     * Executes an asynchronous function a specified number of times sequentially.
+     *
+     * Executes the function with indices from 0 to count-1 incrementally. Each
+     * execution is performed sequentially, and all results are collected into an
+     * array.
+     *
+     * @example
+     *   ```typescript
+     *   // Generate random data 5 times
+     *   const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {
+     *     await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds
+     *     return {
+     *       id: index,
+     *       value: Math.random(),
+     *       timestamp: new Date().toISOString()
+     *     };
+     *   });
+     *   console.log('Generated data:', randomData);
+     *   ```;
+     *
+     * @template T - The type of the result from each execution
+     * @param count - The number of times to repeat (non-negative integer)
+     * @param closure - The asynchronous function to execute repeatedly
+     * @returns A Promise resolving to an array of results
+     */
+    const asyncRepeat: <T>(count: number, closure: (index: number) => Promise<T>) => Promise<T[]>;
+    /**
+     * Checks if at least one element in the array satisfies the given condition.
+     *
+     * Similar to JavaScript's native some() method. Returns true immediately when
+     * the first element satisfying the condition is found.
+     *
+     * @example
+     *   ```typescript
+     *   const numbers = [1, 3, 5, 7, 8, 9];
+     *   const products = [
+     *     { name: 'Apple', price: 100, inStock: true },
+     *     { name: 'Banana', price: 50, inStock: false },
+     *     { name: 'Orange', price: 80, inStock: true }
+     *   ];
+     *
+     *   const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);
+     *   console.log(hasEvenNumber); // true (8 exists)
+     *
+     *   const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);
+     *   console.log(hasExpensiveItem); // true (Apple costs 100)
+     *
+     *   const hasOutOfStock = ArrayUtil.has(products, product => !product.inStock);
+     *   console.log(hasOutOfStock); // true (Banana is out of stock)
+     *   ```;
+     *
+     * @template T - The type of elements in the array
+     * @param elements - The readonly array to check
+     * @param pred - The predicate function to test elements
+     * @returns Boolean indicating if any element satisfies the condition
+     */
+    const has: <T>(elements: readonly T[], pred: (elem: T) => boolean) => boolean;
+    /**
+     * Executes a function a specified number of times and collects the results
+     * into an array.
+     *
+     * A synchronous repetition function that executes the given function for each
+     * index (from 0 to count-1) and collects the results into an array.
+     *
+     * @example
+     *   ```typescript
+     *   // Generate an array of squares from 1 to 5
+     *   const squares = ArrayUtil.repeat(5, index => (index + 1) ** 2);
+     *   console.log(squares); // [1, 4, 9, 16, 25]
+     *
+     *   // Generate an array of default user objects
+     *   const users = ArrayUtil.repeat(3, index => ({
+     *   id: index + 1,
+     *   name: `User${index + 1}`,
+     *   email: `user${index + 1}@example.com`
+     *   }));
+     *   console.log(users);
+     *   // [
+     *   //   { id: 1, name: 'User1', email: 'user1@example.com' },
+     *   //   { id: 2, name: 'User2', email: 'user2@example.com' },
+     *   //   { id: 3, name: 'User3', email: 'user3@example.com' }
+     *   // ]
+     *   ```
+     *
+     * @template T - The type of the result from each execution
+     * @param count - The number of times to repeat (non-negative integer)
+     * @param closure - The function to execute repeatedly
+     * @returns An array of results
+     */
+    const repeat: <T>(count: number, closure: (index: number) => T) => T[];
+    /**
+     * Generates all possible subsets of a given array.
+     *
+     * Implements the mathematical concept of power set, generating 2^n subsets
+     * from an array of n elements. Uses depth-first search (DFS) algorithm to
+     * calculate all possible combinations of including or excluding each
+     * element.
+     *
+     * @example
+     *   ```typescript
+     *   const numbers = [1, 2, 3];
+     *   const allSubsets = ArrayUtil.subsets(numbers);
+     *   console.log(allSubsets);
+     *   // [
+     *   //   [],           // empty set
+     *   //   [3],          // {3}
+     *   //   [2],          // {2}
+     *   //   [2, 3],       // {2, 3}
+     *   //   [1],          // {1}
+     *   //   [1, 3],       // {1, 3}
+     *   //   [1, 2],       // {1, 2}
+     *   //   [1, 2, 3]     // {1, 2, 3}
+     *   // ]
+     *
+     *   const colors = ['red', 'blue'];
+     *   const colorSubsets = ArrayUtil.subsets(colors);
+     *   console.log(colorSubsets);
+     *   // [
+     *   //   [],
+     *   //   ['blue'],
+     *   //   ['red'],
+     *   //   ['red', 'blue']
+     *   // ]
+     *
+     *   // Warning: Result size grows exponentially with array size
+     *   // Example: 10 elements → 1,024 subsets, 20 elements → 1,048,576 subsets
+     *   ```;
+     *
+     * @template T - The type of elements in the array
+     * @param array - The array to generate subsets from
+     * @returns An array containing all possible subsets
+     */
+    const subsets: <T>(array: T[]) => T[][];
+}

package/lib/ArrayUtil.js

@@ -0,0 +1,296 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUtil = void 0;
+/**
+ * A namespace providing utility functions for array manipulation.
+ *
+ * This namespace contains utility functions for array operations including
+ * asynchronous processing, filtering, mapping, and repetition tasks implemented
+ * in functional programming style. Functions use direct parameter passing for
+ * simplicity while maintaining functional programming principles.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   // Asynchronous filtering example
+ *   const numbers = [1, 2, 3, 4, 5];
+ *   const evenNumbers = await ArrayUtil.asyncFilter(numbers,
+ *     async (num) => num % 2 === 0
+ *   );
+ *   console.log(evenNumbers); // [2, 4]
+ *   ```;
+ */
+var ArrayUtil;
+(function (ArrayUtil) {
+    /**
+     * Filters an array by applying an asynchronous predicate function to each
+     * element.
+     *
+     * Elements are processed sequentially, ensuring order is maintained. The
+     * predicate function receives the element, index, and the full array as
+     * parameters.
+     *
+     * @example
+     *   ```typescript
+     *   const users = [
+     *     { id: 1, name: 'Alice', active: true },
+     *     { id: 2, name: 'Bob', active: false },
+     *     { id: 3, name: 'Charlie', active: true }
+     *   ];
+     *
+     *   const activeUsers = await ArrayUtil.asyncFilter(users,
+     *     async (user) => {
+     *       // Async validation logic (e.g., API call)
+     *       await new Promise(resolve => setTimeout(resolve, 100));
+     *       return user.active;
+     *     }
+     *   );
+     *   console.log(activeUsers); // [{ id: 1, name: 'Alice', active: true }, { id: 3, name: 'Charlie', active: true }]
+     *   ```;
+     *
+     * @template Input - The type of elements in the input array
+     * @param elements - The readonly array to filter
+     * @param pred - The asynchronous predicate function to test each element
+     * @returns A Promise resolving to the filtered array
+     */
+    ArrayUtil.asyncFilter = (elements, pred) => __awaiter(this, void 0, void 0, function* () {
+        const ret = [];
+        yield ArrayUtil.asyncForEach(elements, (elem, index, array) => __awaiter(this, void 0, void 0, function* () {
+            const flag = yield pred(elem, index, array);
+            if (flag === true)
+                ret.push(elem);
+        }));
+        return ret;
+    });
+    /**
+     * Executes an asynchronous function for each element in an array
+     * sequentially.
+     *
+     * Unlike JavaScript's native forEach, this function processes asynchronous
+     * functions sequentially and waits for all operations to complete. It
+     * performs sequential processing rather than parallel processing, making it
+     * suitable for operations where order matters.
+     *
+     * @example
+     *   ```typescript
+     *   const urls = ['url1', 'url2', 'url3'];
+     *
+     *   await ArrayUtil.asyncForEach(urls, async (url, index) => {
+     *   console.log(`Processing ${index}: ${url}`);
+     *   const data = await fetch(url);
+     *   await processData(data);
+     *   console.log(`Completed ${index}: ${url}`);
+     *   });
+     *   console.log('All URLs processed sequentially');
+     *   ```
+     *
+     * @template Input - The type of elements in the input array
+     * @param elements - The readonly array to process
+     * @param closure - The asynchronous function to execute for each element
+     * @returns A Promise<void> that resolves when all operations complete
+     */
+    ArrayUtil.asyncForEach = (elements, closure) => __awaiter(this, void 0, void 0, function* () {
+        yield ArrayUtil.asyncRepeat(elements.length, (index) => closure(elements[index], index, elements));
+    });
+    /**
+     * Transforms each element of an array using an asynchronous function to
+     * create a new array.
+     *
+     * Similar to JavaScript's native map but processes asynchronous functions
+     * sequentially. Each element's transformation is completed before proceeding
+     * to the next element, ensuring order is maintained. This function still
+     * maintains the currying pattern for composition.
+     *
+     * @example
+     *   ```typescript
+     *   const userIds = [1, 2, 3, 4, 5];
+     *
+     *   const userDetails = await ArrayUtil.asyncMap(userIds)(
+     *   async (id, index) => {
+     *   console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);
+     *   const response = await fetch(`/api/users/${id}`);
+     *   return await response.json();
+     *   }
+     *   );
+     *   console.log('All users fetched:', userDetails);
+     *   ```
+     *
+     * @template Input - The type of elements in the input array
+     * @param elements - The readonly array to transform
+     * @returns A function that takes a transformation function and returns a
+     *   Promise resolving to the transformed array
+     */
+    ArrayUtil.asyncMap = (elements, closure) => __awaiter(this, void 0, void 0, function* () {
+        const ret = [];
+        yield ArrayUtil.asyncForEach(elements, (elem, index, array) => __awaiter(this, void 0, void 0, function* () {
+            const output = yield closure(elem, index, array);
+            ret.push(output);
+        }));
+        return ret;
+    });
+    /**
+     * Executes an asynchronous function a specified number of times sequentially.
+     *
+     * Executes the function with indices from 0 to count-1 incrementally. Each
+     * execution is performed sequentially, and all results are collected into an
+     * array.
+     *
+     * @example
+     *   ```typescript
+     *   // Generate random data 5 times
+     *   const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {
+     *     await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds
+     *     return {
+     *       id: index,
+     *       value: Math.random(),
+     *       timestamp: new Date().toISOString()
+     *     };
+     *   });
+     *   console.log('Generated data:', randomData);
+     *   ```;
+     *
+     * @template T - The type of the result from each execution
+     * @param count - The number of times to repeat (non-negative integer)
+     * @param closure - The asynchronous function to execute repeatedly
+     * @returns A Promise resolving to an array of results
+     */
+    ArrayUtil.asyncRepeat = (count, closure) => __awaiter(this, void 0, void 0, function* () {
+        const indexes = new Array(count).fill(1).map((_, index) => index);
+        const output = [];
+        for (const index of indexes)
+            output.push(yield closure(index));
+        return output;
+    });
+    /**
+     * Checks if at least one element in the array satisfies the given condition.
+     *
+     * Similar to JavaScript's native some() method. Returns true immediately when
+     * the first element satisfying the condition is found.
+     *
+     * @example
+     *   ```typescript
+     *   const numbers = [1, 3, 5, 7, 8, 9];
+     *   const products = [
+     *     { name: 'Apple', price: 100, inStock: true },
+     *     { name: 'Banana', price: 50, inStock: false },
+     *     { name: 'Orange', price: 80, inStock: true }
+     *   ];
+     *
+     *   const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);
+     *   console.log(hasEvenNumber); // true (8 exists)
+     *
+     *   const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);
+     *   console.log(hasExpensiveItem); // true (Apple costs 100)
+     *
+     *   const hasOutOfStock = ArrayUtil.has(products, product => !product.inStock);
+     *   console.log(hasOutOfStock); // true (Banana is out of stock)
+     *   ```;
+     *
+     * @template T - The type of elements in the array
+     * @param elements - The readonly array to check
+     * @param pred - The predicate function to test elements
+     * @returns Boolean indicating if any element satisfies the condition
+     */
+    ArrayUtil.has = (elements, pred) => elements.find(pred) !== undefined;
+    /**
+     * Executes a function a specified number of times and collects the results
+     * into an array.
+     *
+     * A synchronous repetition function that executes the given function for each
+     * index (from 0 to count-1) and collects the results into an array.
+     *
+     * @example
+     *   ```typescript
+     *   // Generate an array of squares from 1 to 5
+     *   const squares = ArrayUtil.repeat(5, index => (index + 1) ** 2);
+     *   console.log(squares); // [1, 4, 9, 16, 25]
+     *
+     *   // Generate an array of default user objects
+     *   const users = ArrayUtil.repeat(3, index => ({
+     *   id: index + 1,
+     *   name: `User${index + 1}`,
+     *   email: `user${index + 1}@example.com`
+     *   }));
+     *   console.log(users);
+     *   // [
+     *   //   { id: 1, name: 'User1', email: 'user1@example.com' },
+     *   //   { id: 2, name: 'User2', email: 'user2@example.com' },
+     *   //   { id: 3, name: 'User3', email: 'user3@example.com' }
+     *   // ]
+     *   ```
+     *
+     * @template T - The type of the result from each execution
+     * @param count - The number of times to repeat (non-negative integer)
+     * @param closure - The function to execute repeatedly
+     * @returns An array of results
+     */
+    ArrayUtil.repeat = (count, closure) => new Array(count).fill("").map((_, index) => closure(index));
+    /**
+     * Generates all possible subsets of a given array.
+     *
+     * Implements the mathematical concept of power set, generating 2^n subsets
+     * from an array of n elements. Uses depth-first search (DFS) algorithm to
+     * calculate all possible combinations of including or excluding each
+     * element.
+     *
+     * @example
+     *   ```typescript
+     *   const numbers = [1, 2, 3];
+     *   const allSubsets = ArrayUtil.subsets(numbers);
+     *   console.log(allSubsets);
+     *   // [
+     *   //   [],           // empty set
+     *   //   [3],          // {3}
+     *   //   [2],          // {2}
+     *   //   [2, 3],       // {2, 3}
+     *   //   [1],          // {1}
+     *   //   [1, 3],       // {1, 3}
+     *   //   [1, 2],       // {1, 2}
+     *   //   [1, 2, 3]     // {1, 2, 3}
+     *   // ]
+     *
+     *   const colors = ['red', 'blue'];
+     *   const colorSubsets = ArrayUtil.subsets(colors);
+     *   console.log(colorSubsets);
+     *   // [
+     *   //   [],
+     *   //   ['blue'],
+     *   //   ['red'],
+     *   //   ['red', 'blue']
+     *   // ]
+     *
+     *   // Warning: Result size grows exponentially with array size
+     *   // Example: 10 elements → 1,024 subsets, 20 elements → 1,048,576 subsets
+     *   ```;
+     *
+     * @template T - The type of elements in the array
+     * @param array - The array to generate subsets from
+     * @returns An array containing all possible subsets
+     */
+    ArrayUtil.subsets = (array) => {
+        const check = new Array(array.length).fill(false);
+        const output = [];
+        const dfs = (depth) => {
+            if (depth === check.length)
+                output.push(array.filter((_v, idx) => check[idx]));
+            else {
+                check[depth] = true;
+                dfs(depth + 1);
+                check[depth] = false;
+                dfs(depth + 1);
+            }
+        };
+        dfs(0);
+        return output;
+    };
+})(ArrayUtil || (exports.ArrayUtil = ArrayUtil = {}));
+//# sourceMappingURL=ArrayUtil.js.map

package/lib/ArrayUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayUtil.js","sourceRoot":"","sources":["../src/ArrayUtil.ts"],"names":[],"mappings":"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"}

package/lib/DynamicExecutor.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Dynamic Executor running prefixed functions.
+ *
+ * `DynamicExecutor` runs every (or some filtered) prefixed functions in a
+ * specific directory.
+ *
+ * For reference, it's useful for test program development of a backend server.
+ * Just write test functions under a directory, and just specify it.
+ * Furthermore, if you compose e2e test programs to utilize the `@nestia/sdk`
+ * generated API functions, you can take advantage of {@link DynamicBenchmarker}
+ * at the same time.
+ *
+ * When you want to see some utilization cases, see the below example links.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   https://github.com/samchon/nestia-start/blob/master/test/index.ts
+ *
+ * @example
+ *   https://github.com/samchon/backend/blob/master/test/index.ts
+ */
+export declare namespace DynamicExecutor {
+    /**
+     * Function type of a prefixed.
+     *
+     * @template Arguments Type of parameters
+     * @template Ret Type of return value
+     */
+    interface Closure<Arguments extends any[], Ret = any> {
+        (...args: Arguments): Promise<Ret>;
+    }
+    /** Options for dynamic executor. */
+    interface IProps<Parameters extends any[], Ret = any> {
+        /**
+         * Prefix of function name.
+         *
+         * Every prefixed function will be executed.
+         *
+         * In other words, if a function name doesn't start with the prefix, then it
+         * would never be executed.
+         */
+        prefix: string;
+        /** Location of the test functions. */
+        location: string;
+        /**
+         * Get parameters of a function.
+         *
+         * @param name Function name
+         * @returns Parameters
+         */
+        parameters: (name: string) => Parameters;
+        /**
+         * On complete function.
+         *
+         * Listener of completion of a test function.
+         *
+         * @param exec Execution result of a test function
+         */
+        onComplete?: (exec: IExecution) => void;
+        /**
+         * Filter function whether to run or not.
+         *
+         * @param name Function name
+         * @returns Whether to run or not
+         */
+        filter?: (name: string) => boolean;
+        /**
+         * Wrapper of test function.
+         *
+         * If you specify this `wrapper` property, every dynamic functions loaded
+         * and called by this `DynamicExecutor` would be wrapped by the `wrapper`
+         * function.
+         *
+         * @param name Function name
+         * @param closure Function to be executed
+         * @param parameters Parameters, result of options.parameters function.
+         * @returns Wrapper function
+         */
+        wrapper?: (name: string, closure: Closure<Parameters, Ret>, parameters: Parameters) => Promise<any>;
+        /**
+         * Number of simultaneous requests.
+         *
+         * The number of requests to be executed simultaneously.
+         *
+         * If you configure a value greater than one, the dynamic executor will
+         * process the functions concurrently with the given capacity value.
+         *
+         * @default 1
+         */
+        simultaneous?: number;
+        /**
+         * Extension of dynamic functions.
+         *
+         * @default js
+         */
+        extension?: string;
+    }
+    /** Report, result of dynamic execution. */
+    interface IReport {
+        /** Location path of dynamic functions. */
+        location: string;
+        /** Execution results of dynamic functions. */
+        executions: IExecution[];
+        /** Total elapsed time. */
+        time: number;
+    }
+    /** Execution of a test function. */
+    interface IExecution {
+        /** Name of function. */
+        name: string;
+        /** Location path of the function. */
+        location: string;
+        /** Returned value from the function. */
+        value: unknown;
+        /** Error when occurred. */
+        error: Error | null;
+        /** Elapsed time. */
+        started_at: string;
+        /** Completion time. */
+        completed_at: string;
+    }
+    /**
+     * Prepare dynamic executor in strict mode.
+     *
+     * In strict mode, if any error occurs, the program will be terminated
+     * directly. Otherwise, {@link validate} mode does not terminate when error
+     * occurs, but just archive the error log.
+     *
+     * @param props Properties of dynamic execution
+     * @returns Report of dynamic test functions execution
+     */
+    const assert: <Arguments extends any[]>(props: IProps<Arguments>) => Promise<IReport>;
+    /**
+     * Prepare dynamic executor in loose mode.
+     *
+     * In loose mode, the program would not be terminated even when error occurs.
+     * Instead, the error would be archived and returns as a list. Otherwise,
+     * {@link assert} mode terminates the program directly when error occurs.
+     *
+     * @param props Properties of dynamic executor
+     * @returns Report of dynamic test functions execution
+     */
+    const validate: <Arguments extends any[]>(props: IProps<Arguments>) => Promise<IReport>;
+}