@nestia/e2e 10.0.1 → 11.0.0-dev.20260305

package/lib/DynamicExecutor.js

@@ -1,373 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicExecutor = void 0;
-var fs_1 = __importDefault(require("fs"));
-var path_1 = __importDefault(require("path"));
-/**
- * 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
- */
-var DynamicExecutor;
-(function (DynamicExecutor) {
-    var _this = this;
-    /**
-     * 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
-     */
-    DynamicExecutor.assert = function (props) { return main(true)(props); };
-    /**
-     * 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
-     */
-    DynamicExecutor.validate = function (props) { return main(false)(props); };
-    var main = function (assert) {
-        return function (props) { return __awaiter(_this, void 0, void 0, function () {
-            var report, executor, processes;
-            var _this = this;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        report = {
-                            location: props.location,
-                            time: Date.now(),
-                            executions: [],
-                        };
-                        executor = execute(props)(report)(assert);
-                        return [4 /*yield*/, iterate({
-                                extension: (_a = props.extension) !== null && _a !== void 0 ? _a : "js",
-                                location: props.location,
-                                executor: executor,
-                            })];
-                    case 1:
-                        processes = _c.sent();
-                        return [4 /*yield*/, Promise.all(new Array((_b = props.simultaneous) !== null && _b !== void 0 ? _b : 1).fill(0).map(function () { return __awaiter(_this, void 0, void 0, function () {
-                                var task;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!(processes.length !== 0)) return [3 /*break*/, 2];
-                                            task = processes.shift();
-                                            return [4 /*yield*/, (task === null || task === void 0 ? void 0 : task())];
-                                        case 1:
-                                            _a.sent();
-                                            return [3 /*break*/, 0];
-                                        case 2: return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 2:
-                        _c.sent();
-                        report.time = Date.now() - report.time;
-                        return [2 /*return*/, report];
-                }
-            });
-        }); };
-    };
-    var iterate = function (props) { return __awaiter(_this, void 0, void 0, function () {
-        var container, visitor;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    container = [];
-                    visitor = function (path) { return __awaiter(_this, void 0, void 0, function () {
-                        var directory, _loop_1, directory_1, directory_1_1, file, e_1_1;
-                        var e_1, _a;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0: return [4 /*yield*/, fs_1.default.promises.readdir(path)];
-                                case 1:
-                                    directory = _b.sent();
-                                    _loop_1 = function (file) {
-                                        var location_1, stats, modulo;
-                                        return __generator(this, function (_c) {
-                                            switch (_c.label) {
-                                                case 0:
-                                                    location_1 = path_1.default.resolve("".concat(path, "/").concat(file));
-                                                    return [4 /*yield*/, fs_1.default.promises.lstat(location_1)];
-                                                case 1:
-                                                    stats = _c.sent();
-                                                    if (!(stats.isDirectory() === true)) return [3 /*break*/, 3];
-                                                    return [4 /*yield*/, visitor(location_1)];
-                                                case 2:
-                                                    _c.sent();
-                                                    return [2 /*return*/, "continue"];
-                                                case 3:
-                                                    if (file.substr(-3) !== ".".concat(props.extension))
-                                                        return [2 /*return*/, "continue"];
-                                                    _c.label = 4;
-                                                case 4: return [4 /*yield*/, Promise.resolve("".concat(location_1)).then(function (s) { return __importStar(require(s)); })];
-                                                case 5:
-                                                    modulo = _c.sent();
-                                                    container.push(function () { return props.executor(location_1, modulo); });
-                                                    return [2 /*return*/];
-                                            }
-                                        });
-                                    };
-                                    _b.label = 2;
-                                case 2:
-                                    _b.trys.push([2, 7, 8, 9]);
-                                    directory_1 = __values(directory), directory_1_1 = directory_1.next();
-                                    _b.label = 3;
-                                case 3:
-                                    if (!!directory_1_1.done) return [3 /*break*/, 6];
-                                    file = directory_1_1.value;
-                                    return [5 /*yield**/, _loop_1(file)];
-                                case 4:
-                                    _b.sent();
-                                    _b.label = 5;
-                                case 5:
-                                    directory_1_1 = directory_1.next();
-                                    return [3 /*break*/, 3];
-                                case 6: return [3 /*break*/, 9];
-                                case 7:
-                                    e_1_1 = _b.sent();
-                                    e_1 = { error: e_1_1 };
-                                    return [3 /*break*/, 9];
-                                case 8:
-                                    try {
-                                        if (directory_1_1 && !directory_1_1.done && (_a = directory_1.return)) _a.call(directory_1);
-                                    }
-                                    finally { if (e_1) throw e_1.error; }
-                                    return [7 /*endfinally*/];
-                                case 9: return [2 /*return*/];
-                            }
-                        });
-                    }); };
-                    return [4 /*yield*/, visitor(props.location)];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/, container];
-            }
-        });
-    }); };
-    var execute = function (props) {
-        return function (report) {
-            return function (assert) {
-                return function (location, modulo) { return __awaiter(_this, void 0, void 0, function () {
-                    var _loop_2, _a, _b, _c, key, closure, e_2_1;
-                    var e_2, _d;
-                    return __generator(this, function (_e) {
-                        switch (_e.label) {
-                            case 0:
-                                _loop_2 = function (key, closure) {
-                                    var func, result, _f, exp_1;
-                                    return __generator(this, function (_g) {
-                                        switch (_g.label) {
-                                            case 0:
-                                                if (key.substring(0, props.prefix.length) !== props.prefix ||
-                                                    typeof closure !== "function" ||
-                                                    (props.filter && props.filter(key) === false))
-                                                    return [2 /*return*/, "continue"];
-                                                func = function () {
-                                                    if (props.wrapper !== undefined)
-                                                        return props.wrapper(key, closure, props.parameters(key));
-                                                    else
-                                                        return closure.apply(void 0, __spreadArray([], __read(props.parameters(key)), false));
-                                                };
-                                                result = {
-                                                    name: key,
-                                                    location: location,
-                                                    value: undefined,
-                                                    error: null,
-                                                    started_at: new Date().toISOString(),
-                                                    completed_at: new Date().toISOString(),
-                                                };
-                                                report.executions.push(result);
-                                                _g.label = 1;
-                                            case 1:
-                                                _g.trys.push([1, 3, 4, 5]);
-                                                _f = result;
-                                                return [4 /*yield*/, func()];
-                                            case 2:
-                                                _f.value = _g.sent();
-                                                result.completed_at = new Date().toISOString();
-                                                return [3 /*break*/, 5];
-                                            case 3:
-                                                exp_1 = _g.sent();
-                                                result.error = exp_1;
-                                                if (assert === true)
-                                                    throw exp_1;
-                                                return [3 /*break*/, 5];
-                                            case 4:
-                                                result.completed_at = new Date().toISOString();
-                                                if (props.onComplete)
-                                                    props.onComplete(result);
-                                                return [7 /*endfinally*/];
-                                            case 5: return [2 /*return*/];
-                                        }
-                                    });
-                                };
-                                _e.label = 1;
-                            case 1:
-                                _e.trys.push([1, 6, 7, 8]);
-                                _a = __values(Object.entries(modulo)), _b = _a.next();
-                                _e.label = 2;
-                            case 2:
-                                if (!!_b.done) return [3 /*break*/, 5];
-                                _c = __read(_b.value, 2), key = _c[0], closure = _c[1];
-                                return [5 /*yield**/, _loop_2(key, closure)];
-                            case 3:
-                                _e.sent();
-                                _e.label = 4;
-                            case 4:
-                                _b = _a.next();
-                                return [3 /*break*/, 2];
-                            case 5: return [3 /*break*/, 8];
-                            case 6:
-                                e_2_1 = _e.sent();
-                                e_2 = { error: e_2_1 };
-                                return [3 /*break*/, 8];
-                            case 7:
-                                try {
-                                    if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                                }
-                                finally { if (e_2) throw e_2.error; }
-                                return [7 /*endfinally*/];
-                            case 8: return [2 /*return*/];
-                        }
-                    });
-                }); };
-            };
-        };
-    };
-})(DynamicExecutor || (exports.DynamicExecutor = DynamicExecutor = {}));
-//# sourceMappingURL=DynamicExecutor.js.map

package/lib/DynamicExecutor.js.map

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

package/lib/GaffComparator.d.ts

@@ -1,255 +0,0 @@
-/**
- * Type-safe comparator functions for Array.sort() operations with advanced
- * field access.
- *
- * GaffComparator provides a collection of specialized comparator functions
- * designed to work seamlessly with Array.sort() and testing frameworks like
- * TestValidator.sort(). Each comparator supports both single values and arrays
- * of values, enabling complex multi-field sorting scenarios with lexicographic
- * ordering.
- *
- * Key features:
- *
- * - Generic type safety for any object structure
- * - Support for single values or arrays of values per field
- * - Lexicographic comparison for multi-value scenarios
- * - Locale-aware string comparison
- * - Automatic type conversion for dates and numbers
- *
- * The comparators follow the standard JavaScript sort contract:
- *
- * - Return < 0 if first element should come before second
- * - Return > 0 if first element should come after second
- * - Return 0 if elements are equal
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   ```typescript
- *   // Basic usage with single fields
- *   users.sort(GaffComparator.strings(user => user.name));
- *   posts.sort(GaffComparator.dates(post => post.createdAt));
- *   products.sort(GaffComparator.numbers(product => product.price));
- *
- *   // Multi-field sorting with arrays
- *   users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));
- *   events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));
- *
- *   // Integration with TestValidator's currying pattern
- *   const validator = TestValidator.sort("user sorting",
- *     (sortable) => api.getUsers({ sort: sortable })
- *   )("name", "email")(
- *     GaffComparator.strings(user => [user.name, user.email])
- *   );
- *   await validator("+"); // ascending
- *   await validator("-"); // descending
- *   ```;
- */
-export declare namespace GaffComparator {
-    /**
-     * Creates a comparator function for string-based sorting with locale-aware
-     * comparison.
-     *
-     * Generates a comparator that extracts string values from objects and
-     * performs lexicographic comparison using locale-sensitive string comparison.
-     * Supports both single strings and arrays of strings for multi-field sorting
-     * scenarios.
-     *
-     * When comparing arrays, performs lexicographic ordering: compares the first
-     * elements, then the second elements if the first are equal, and so on. This
-     * enables complex sorting like "sort by last name, then by first name".
-     *
-     * @example
-     *   ```typescript
-     *   interface User {
-     *     id: string;
-     *     firstName: string;
-     *     lastName: string;
-     *     email: string;
-     *     status: 'active' | 'inactive';
-     *   }
-     *
-     *   const users: User[] = [
-     *     { id: '1', firstName: 'John', lastName: 'Doe', email: 'john@example.com', status: 'active' },
-     *     { id: '2', firstName: 'Jane', lastName: 'Doe', email: 'jane@example.com', status: 'inactive' },
-     *     { id: '3', firstName: 'Bob', lastName: 'Smith', email: 'bob@example.com', status: 'active' }
-     *   ];
-     *
-     *   // Single field sorting
-     *   users.sort(GaffComparator.strings(user => user.lastName));
-     *   // Result: Doe, Doe, Smith
-     *
-     *   // Multi-field sorting: last name, then first name
-     *   users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));
-     *   // Result: Doe Jane, Doe John, Smith Bob
-     *
-     *   // Status-based sorting
-     *   users.sort(GaffComparator.strings(user => user.status));
-     *   // Result: active users first, then inactive
-     *
-     *   // Complex multi-field: status, then last name, then first name
-     *   users.sort(GaffComparator.strings(user => [user.status, user.lastName, user.firstName]));
-     *
-     *   // Integration with TestValidator sorting validation
-     *   const sortValidator = TestValidator.sort("user name sorting",
-     *     (sortFields) => userApi.getUsers({ sort: sortFields })
-     *   )("lastName", "firstName")(
-     *     GaffComparator.strings(user => [user.lastName, user.firstName])
-     *   );
-     *   await sortValidator("+"); // test ascending order
-     *   await sortValidator("-"); // test descending order
-     *   ```;
-     *
-     * @template T - The type of objects being compared
-     * @param getter - Function that extracts string value(s) from input objects
-     * @returns A comparator function suitable for Array.sort()
-     */
-    const strings: <T>(getter: (input: T) => string | string[]) => (x: T, y: T) => number;
-    /**
-     * Creates a comparator function for date-based sorting with automatic string
-     * parsing.
-     *
-     * Generates a comparator that extracts date values from objects,
-     * automatically converting string representations to Date objects for
-     * numerical comparison. Supports both single dates and arrays of dates for
-     * complex temporal sorting.
-     *
-     * Date strings are parsed using the standard Date constructor, which supports
-     * ISO 8601 format, RFC 2822 format, and other common date representations.
-     * The comparison is performed on millisecond timestamps for precise
-     * ordering.
-     *
-     * @example
-     *   ```typescript
-     *   interface Event {
-     *     id: string;
-     *     title: string;
-     *     startDate: string;
-     *     endDate: string;
-     *     createdAt: string;
-     *     updatedAt: string;
-     *   }
-     *
-     *   const events: Event[] = [
-     *     {
-     *       id: '1',
-     *       title: 'Conference',
-     *       startDate: '2024-03-15T09:00:00Z',
-     *       endDate: '2024-03-15T17:00:00Z',
-     *       createdAt: '2024-01-10T10:00:00Z',
-     *       updatedAt: '2024-02-01T15:30:00Z'
-     *     },
-     *     {
-     *       id: '2',
-     *       title: 'Workshop',
-     *       startDate: '2024-03-10T14:00:00Z',
-     *       endDate: '2024-03-10T16:00:00Z',
-     *       createdAt: '2024-01-15T11:00:00Z',
-     *       updatedAt: '2024-01-20T09:15:00Z'
-     *     }
-     *   ];
-     *
-     *   // Sort by start date (chronological order)
-     *   events.sort(GaffComparator.dates(event => event.startDate));
-     *
-     *   // Sort by creation date (oldest first)
-     *   events.sort(GaffComparator.dates(event => event.createdAt));
-     *
-     *   // Multi-field: start date, then end date
-     *   events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));
-     *
-     *   // Sort by modification history: created date, then updated date
-     *   events.sort(GaffComparator.dates(event => [event.createdAt, event.updatedAt]));
-     *
-     *   // Validate API date sorting with TestValidator
-     *   const dateValidator = TestValidator.sort("event chronological sorting",
-     *     (sortFields) => eventApi.getEvents({ sort: sortFields })
-     *   )("startDate")(
-     *     GaffComparator.dates(event => event.startDate)
-     *   );
-     *   await dateValidator("+", true); // ascending with trace logging
-     *
-     *   // Test complex date-based sorting
-     *   const sortByEventSchedule = GaffComparator.dates(event => [
-     *     event.startDate,
-     *     event.endDate
-     *   ]);
-     *   ```;
-     *
-     * @template T - The type of objects being compared
-     * @param getter - Function that extracts date string(s) from input objects
-     * @returns A comparator function suitable for Array.sort()
-     */
-    const dates: <T>(getter: (input: T) => string | string[]) => (x: T, y: T) => number;
-    /**
-     * Creates a comparator function for numerical sorting with multi-value
-     * support.
-     *
-     * Generates a comparator that extracts numerical values from objects and
-     * performs mathematical comparison. Supports both single numbers and arrays
-     * of numbers for complex numerical sorting scenarios like sorting by price
-     * then by rating.
-     *
-     * When comparing arrays, performs lexicographic numerical ordering: compares
-     * the first numbers, then the second numbers if the first are equal, and so
-     * on. This enables sophisticated sorting like "sort by price ascending, then
-     * by rating descending".
-     *
-     * @example
-     *   ```typescript
-     *   interface Product {
-     *     id: string;
-     *     name: string;
-     *     price: number;
-     *     rating: number;
-     *     stock: number;
-     *     categoryId: number;
-     *     salesCount: number;
-     *   }
-     *
-     *   const products: Product[] = [
-     *     { id: '1', name: 'Laptop', price: 999.99, rating: 4.5, stock: 15, categoryId: 1, salesCount: 150 },
-     *     { id: '2', name: 'Mouse', price: 29.99, rating: 4.2, stock: 50, categoryId: 1, salesCount: 300 },
-     *     { id: '3', name: 'Keyboard', price: 79.99, rating: 4.8, stock: 25, categoryId: 1, salesCount: 200 }
-     *   ];
-     *
-     *   // Sort by price (ascending)
-     *   products.sort(GaffComparator.numbers(product => product.price));
-     *   // Result: Mouse ($29.99), Keyboard ($79.99), Laptop ($999.99)
-     *
-     *   // Sort by rating (descending requires negation)
-     *   products.sort(GaffComparator.numbers(product => -product.rating));
-     *   // Result: Keyboard (4.8), Laptop (4.5), Mouse (4.2)
-     *
-     *   // Multi-field: category, then price
-     *   products.sort(GaffComparator.numbers(product => [product.categoryId, product.price]));
-     *
-     *   // Complex business logic: popularity (sales) then rating
-     *   products.sort(GaffComparator.numbers(product => [-product.salesCount, -product.rating]));
-     *   // Negative values for descending order
-     *
-     *   // Sort by inventory priority: low stock first, then by sales
-     *   products.sort(GaffComparator.numbers(product => [product.stock, -product.salesCount]));
-     *
-     *   // Validate API numerical sorting with TestValidator
-     *   const priceValidator = TestValidator.sort("product price sorting",
-     *     (sortFields) => productApi.getProducts({ sort: sortFields })
-     *   )("price")(
-     *     GaffComparator.numbers(product => product.price)
-     *   );
-     *   await priceValidator("+"); // test ascending order
-     *   await priceValidator("-"); // test descending order
-     *
-     *   // Test multi-criteria sorting
-     *   const sortByBusinessValue = GaffComparator.numbers(product => [
-     *     -product.salesCount,  // High sales first
-     *     -product.rating,      // High rating first
-     *     product.price         // Low price first (for tie-breaking)
-     *   ]);
-     *   ```;
-     *
-     * @template T - The type of objects being compared
-     * @param closure - Function that extracts number value(s) from input objects
-     * @returns A comparator function suitable for Array.sort()
-     */
-    const numbers: <T>(closure: (input: T) => number | number[]) => (x: T, y: T) => number;
-}