@autobe/compiler/src/raw/test.json

AI backend server code generator

{
  "node_modules/@nestia/e2e/lib/ArrayUtil.d.ts": "/**\n * A namespace providing utility functions for array manipulation.\n *\n * This namespace contains utility functions for array operations including\n * asynchronous processing, filtering, mapping, and repetition tasks implemented\n * in functional programming style. Functions use direct parameter passing for\n * simplicity while maintaining functional programming principles.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   // Asynchronous filtering example\n *   const numbers = [1, 2, 3, 4, 5];\n *   const evenNumbers = await ArrayUtil.asyncFilter(numbers,\n *     async (num) => num % 2 === 0\n *   );\n *   console.log(evenNumbers); // [2, 4]\n *   ```;\n */\nexport declare namespace ArrayUtil {\n    /**\n     * Filters an array by applying an asynchronous predicate function to each\n     * element.\n     *\n     * Elements are processed sequentially, ensuring order is maintained. The\n     * predicate function receives the element, index, and the full array as\n     * parameters.\n     *\n     * @example\n     *   ```typescript\n     *   const users = [\n     *     { id: 1, name: 'Alice', active: true },\n     *     { id: 2, name: 'Bob', active: false },\n     *     { id: 3, name: 'Charlie', active: true }\n     *   ];\n     *\n     *   const activeUsers = await ArrayUtil.asyncFilter(users,\n     *     async (user) => {\n     *       // Async validation logic (e.g., API call)\n     *       await new Promise(resolve => setTimeout(resolve, 100));\n     *       return user.active;\n     *     }\n     *   );\n     *   console.log(activeUsers); // [{ id: 1, name: 'Alice', active: true }, { id: 3, name: 'Charlie', active: true }]\n     *   ```;\n     *\n     * @template Input - The type of elements in the input array\n     * @param elements - The readonly array to filter\n     * @param pred - The asynchronous predicate function to test each element\n     * @returns A Promise resolving to the filtered array\n     */\n    const asyncFilter: <Input>(elements: readonly Input[], pred: (elem: Input, index: number, array: readonly Input[]) => Promise<boolean>) => Promise<Input[]>;\n    /**\n     * Executes an asynchronous function for each element in an array\n     * sequentially.\n     *\n     * Unlike JavaScript's native forEach, this function processes asynchronous\n     * functions sequentially and waits for all operations to complete. It\n     * performs sequential processing rather than parallel processing, making it\n     * suitable for operations where order matters.\n     *\n     * @example\n     *   ```typescript\n     *   const urls = ['url1', 'url2', 'url3'];\n     *\n     *   await ArrayUtil.asyncForEach(urls, async (url, index) => {\n     *   console.log(`Processing ${index}: ${url}`);\n     *   const data = await fetch(url);\n     *   await processData(data);\n     *   console.log(`Completed ${index}: ${url}`);\n     *   });\n     *   console.log('All URLs processed sequentially');\n     *   ```\n     *\n     * @template Input - The type of elements in the input array\n     * @param elements - The readonly array to process\n     * @param closure - The asynchronous function to execute for each element\n     * @returns A Promise<void> that resolves when all operations complete\n     */\n    const asyncForEach: <Input>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<any>) => Promise<void>;\n    /**\n     * Transforms each element of an array using an asynchronous function to\n     * create a new array.\n     *\n     * Similar to JavaScript's native map but processes asynchronous functions\n     * sequentially. Each element's transformation is completed before proceeding\n     * to the next element, ensuring order is maintained. This function still\n     * maintains the currying pattern for composition.\n     *\n     * @example\n     *   ```typescript\n     *   const userIds = [1, 2, 3, 4, 5];\n     *\n     *   const userDetails = await ArrayUtil.asyncMap(userIds)(\n     *   async (id, index) => {\n     *   console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);\n     *   const response = await fetch(`/api/users/${id}`);\n     *   return await response.json();\n     *   }\n     *   );\n     *   console.log('All users fetched:', userDetails);\n     *   ```\n     *\n     * @template Input - The type of elements in the input array\n     * @param elements - The readonly array to transform\n     * @returns A function that takes a transformation function and returns a\n     *   Promise resolving to the transformed array\n     */\n    const asyncMap: <Input, Output>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<Output>) => Promise<Output[]>;\n    /**\n     * Executes an asynchronous function a specified number of times sequentially.\n     *\n     * Executes the function with indices from 0 to count-1 incrementally. Each\n     * execution is performed sequentially, and all results are collected into an\n     * array.\n     *\n     * @example\n     *   ```typescript\n     *   // Generate random data 5 times\n     *   const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {\n     *     await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds\n     *     return {\n     *       id: index,\n     *       value: Math.random(),\n     *       timestamp: new Date().toISOString()\n     *     };\n     *   });\n     *   console.log('Generated data:', randomData);\n     *   ```;\n     *\n     * @template T - The type of the result from each execution\n     * @param count - The number of times to repeat (non-negative integer)\n     * @param closure - The asynchronous function to execute repeatedly\n     * @returns A Promise resolving to an array of results\n     */\n    const asyncRepeat: <T>(count: number, closure: (index: number) => Promise<T>) => Promise<T[]>;\n    /**\n     * Checks if at least one element in the array satisfies the given condition.\n     *\n     * Similar to JavaScript's native some() method. Returns true immediately when\n     * the first element satisfying the condition is found.\n     *\n     * @example\n     *   ```typescript\n     *   const numbers = [1, 3, 5, 7, 8, 9];\n     *   const products = [\n     *     { name: 'Apple', price: 100, inStock: true },\n     *     { name: 'Banana', price: 50, inStock: false },\n     *     { name: 'Orange', price: 80, inStock: true }\n     *   ];\n     *\n     *   const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);\n     *   console.log(hasEvenNumber); // true (8 exists)\n     *\n     *   const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);\n     *   console.log(hasExpensiveItem); // true (Apple costs 100)\n     *\n     *   const hasOutOfStock = ArrayUtil.has(products, product => !product.inStock);\n     *   console.log(hasOutOfStock); // true (Banana is out of stock)\n     *   ```;\n     *\n     * @template T - The type of elements in the array\n     * @param elements - The readonly array to check\n     * @param pred - The predicate function to test elements\n     * @returns Boolean indicating if any element satisfies the condition\n     */\n    const has: <T>(elements: readonly T[], pred: (elem: T) => boolean) => boolean;\n    /**\n     * Executes a function a specified number of times and collects the results\n     * into an array.\n     *\n     * A synchronous repetition function that executes the given function for each\n     * index (from 0 to count-1) and collects the results into an array.\n     *\n     * @example\n     *   ```typescript\n     *   // Generate an array of squares from 1 to 5\n     *   const squares = ArrayUtil.repeat(5, index => (index + 1) ** 2);\n     *   console.log(squares); // [1, 4, 9, 16, 25]\n     *\n     *   // Generate an array of default user objects\n     *   const users = ArrayUtil.repeat(3, index => ({\n     *   id: index + 1,\n     *   name: `User${index + 1}`,\n     *   email: `user${index + 1}@example.com`\n     *   }));\n     *   console.log(users);\n     *   // [\n     *   //   { id: 1, name: 'User1', email: 'user1@example.com' },\n     *   //   { id: 2, name: 'User2', email: 'user2@example.com' },\n     *   //   { id: 3, name: 'User3', email: 'user3@example.com' }\n     *   // ]\n     *   ```\n     *\n     * @template T - The type of the result from each execution\n     * @param count - The number of times to repeat (non-negative integer)\n     * @param closure - The function to execute repeatedly\n     * @returns An array of results\n     */\n    const repeat: <T>(count: number, closure: (index: number) => T) => T[];\n    /**\n     * Generates all possible subsets of a given array.\n     *\n     * Implements the mathematical concept of power set, generating 2^n subsets\n     * from an array of n elements. Uses depth-first search (DFS) algorithm to\n     * calculate all possible combinations of including or excluding each\n     * element.\n     *\n     * @example\n     *   ```typescript\n     *   const numbers = [1, 2, 3];\n     *   const allSubsets = ArrayUtil.subsets(numbers);\n     *   console.log(allSubsets);\n     *   // [\n     *   //   [],           // empty set\n     *   //   [3],          // {3}\n     *   //   [2],          // {2}\n     *   //   [2, 3],       // {2, 3}\n     *   //   [1],          // {1}\n     *   //   [1, 3],       // {1, 3}\n     *   //   [1, 2],       // {1, 2}\n     *   //   [1, 2, 3]     // {1, 2, 3}\n     *   // ]\n     *\n     *   const colors = ['red', 'blue'];\n     *   const colorSubsets = ArrayUtil.subsets(colors);\n     *   console.log(colorSubsets);\n     *   // [\n     *   //   [],\n     *   //   ['blue'],\n     *   //   ['red'],\n     *   //   ['red', 'blue']\n     *   // ]\n     *\n     *   // Warning: Result size grows exponentially with array size\n     *   // Example: 10 elements → 1,024 subsets, 20 elements → 1,048,576 subsets\n     *   ```;\n     *\n     * @template T - The type of elements in the array\n     * @param array - The array to generate subsets from\n     * @returns An array containing all possible subsets\n     */\n    const subsets: <T>(array: T[]) => T[][];\n}\n",
  "node_modules/@nestia/e2e/lib/DynamicExecutor.d.ts": "/**\n * Dynamic Executor running prefixed functions.\n *\n * `DynamicExecutor` runs every (or some filtered) prefixed functions in a\n * specific directory.\n *\n * For reference, it's useful for test program development of a backend server.\n * Just write test functions under a directory, and just specify it.\n * Furthermore, if you compose e2e test programs to utilize the `@nestia/sdk`\n * generated API functions, you can take advantage of {@link DynamicBenchmarker}\n * at the same time.\n *\n * When you want to see some utilization cases, see the below example links.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   https://github.com/samchon/nestia-start/blob/master/test/index.ts\n *\n * @example\n *   https://github.com/samchon/backend/blob/master/test/index.ts\n */\nexport declare namespace DynamicExecutor {\n    /**\n     * Function type of a prefixed.\n     *\n     * @template Arguments Type of parameters\n     * @template Ret Type of return value\n     */\n    interface Closure<Arguments extends any[], Ret = any> {\n        (...args: Arguments): Promise<Ret>;\n    }\n    /** Options for dynamic executor. */\n    interface IProps<Parameters extends any[], Ret = any> {\n        /**\n         * Prefix of function name.\n         *\n         * Every prefixed function will be executed.\n         *\n         * In other words, if a function name doesn't start with the prefix, then it\n         * would never be executed.\n         */\n        prefix: string;\n        /** Location of the test functions. */\n        location: string;\n        /**\n         * Get parameters of a function.\n         *\n         * @param name Function name\n         * @returns Parameters\n         */\n        parameters: (name: string) => Parameters;\n        /**\n         * On complete function.\n         *\n         * Listener of completion of a test function.\n         *\n         * @param exec Execution result of a test function\n         */\n        onComplete?: (exec: IExecution) => void;\n        /**\n         * Filter function whether to run or not.\n         *\n         * @param name Function name\n         * @returns Whether to run or not\n         */\n        filter?: (name: string) => boolean;\n        /**\n         * Wrapper of test function.\n         *\n         * If you specify this `wrapper` property, every dynamic functions loaded\n         * and called by this `DynamicExecutor` would be wrapped by the `wrapper`\n         * function.\n         *\n         * @param name Function name\n         * @param closure Function to be executed\n         * @param parameters Parameters, result of options.parameters function.\n         * @returns Wrapper function\n         */\n        wrapper?: (name: string, closure: Closure<Parameters, Ret>, parameters: Parameters) => Promise<any>;\n        /**\n         * Number of simultaneous requests.\n         *\n         * The number of requests to be executed simultaneously.\n         *\n         * If you configure a value greater than one, the dynamic executor will\n         * process the functions concurrently with the given capacity value.\n         *\n         * @default 1\n         */\n        simultaneous?: number;\n        /**\n         * Extension of dynamic functions.\n         *\n         * @default js\n         */\n        extension?: string;\n    }\n    /** Report, result of dynamic execution. */\n    interface IReport {\n        /** Location path of dynamic functions. */\n        location: string;\n        /** Execution results of dynamic functions. */\n        executions: IExecution[];\n        /** Total elapsed time. */\n        time: number;\n    }\n    /** Execution of a test function. */\n    interface IExecution {\n        /** Name of function. */\n        name: string;\n        /** Location path of the function. */\n        location: string;\n        /** Returned value from the function. */\n        value: unknown;\n        /** Error when occurred. */\n        error: Error | null;\n        /** Elapsed time. */\n        started_at: string;\n        /** Completion time. */\n        completed_at: string;\n    }\n    /**\n     * Prepare dynamic executor in strict mode.\n     *\n     * In strict mode, if any error occurs, the program will be terminated\n     * directly. Otherwise, {@link validate} mode does not terminate when error\n     * occurs, but just archive the error log.\n     *\n     * @param props Properties of dynamic execution\n     * @returns Report of dynamic test functions execution\n     */\n    const assert: <Arguments extends any[]>(props: IProps<Arguments>) => Promise<IReport>;\n    /**\n     * Prepare dynamic executor in loose mode.\n     *\n     * In loose mode, the program would not be terminated even when error occurs.\n     * Instead, the error would be archived and returns as a list. Otherwise,\n     * {@link assert} mode terminates the program directly when error occurs.\n     *\n     * @param props Properties of dynamic executor\n     * @returns Report of dynamic test functions execution\n     */\n    const validate: <Arguments extends any[]>(props: IProps<Arguments>) => Promise<IReport>;\n}\n",
  "node_modules/@nestia/e2e/lib/GaffComparator.d.ts": "/**\n * Type-safe comparator functions for Array.sort() operations with advanced\n * field access.\n *\n * GaffComparator provides a collection of specialized comparator functions\n * designed to work seamlessly with Array.sort() and testing frameworks like\n * TestValidator.sort(). Each comparator supports both single values and arrays\n * of values, enabling complex multi-field sorting scenarios with lexicographic\n * ordering.\n *\n * Key features:\n *\n * - Generic type safety for any object structure\n * - Support for single values or arrays of values per field\n * - Lexicographic comparison for multi-value scenarios\n * - Locale-aware string comparison\n * - Automatic type conversion for dates and numbers\n *\n * The comparators follow the standard JavaScript sort contract:\n *\n * - Return < 0 if first element should come before second\n * - Return > 0 if first element should come after second\n * - Return 0 if elements are equal\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   // Basic usage with single fields\n *   users.sort(GaffComparator.strings(user => user.name));\n *   posts.sort(GaffComparator.dates(post => post.createdAt));\n *   products.sort(GaffComparator.numbers(product => product.price));\n *\n *   // Multi-field sorting with arrays\n *   users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));\n *   events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));\n *\n *   // Integration with TestValidator's currying pattern\n *   const validator = TestValidator.sort(\"user sorting\",\n *     (sortable) => api.getUsers({ sort: sortable })\n *   )(\"name\", \"email\")(\n *     GaffComparator.strings(user => [user.name, user.email])\n *   );\n *   await validator(\"+\"); // ascending\n *   await validator(\"-\"); // descending\n *   ```;\n */\nexport declare namespace GaffComparator {\n    /**\n     * Creates a comparator function for string-based sorting with locale-aware\n     * comparison.\n     *\n     * Generates a comparator that extracts string values from objects and\n     * performs lexicographic comparison using locale-sensitive string comparison.\n     * Supports both single strings and arrays of strings for multi-field sorting\n     * scenarios.\n     *\n     * When comparing arrays, performs lexicographic ordering: compares the first\n     * elements, then the second elements if the first are equal, and so on. This\n     * enables complex sorting like \"sort by last name, then by first name\".\n     *\n     * @example\n     *   ```typescript\n     *   interface User {\n     *     id: string;\n     *     firstName: string;\n     *     lastName: string;\n     *     email: string;\n     *     status: 'active' | 'inactive';\n     *   }\n     *\n     *   const users: User[] = [\n     *     { id: '1', firstName: 'John', lastName: 'Doe', email: 'john@example.com', status: 'active' },\n     *     { id: '2', firstName: 'Jane', lastName: 'Doe', email: 'jane@example.com', status: 'inactive' },\n     *     { id: '3', firstName: 'Bob', lastName: 'Smith', email: 'bob@example.com', status: 'active' }\n     *   ];\n     *\n     *   // Single field sorting\n     *   users.sort(GaffComparator.strings(user => user.lastName));\n     *   // Result: Doe, Doe, Smith\n     *\n     *   // Multi-field sorting: last name, then first name\n     *   users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));\n     *   // Result: Doe Jane, Doe John, Smith Bob\n     *\n     *   // Status-based sorting\n     *   users.sort(GaffComparator.strings(user => user.status));\n     *   // Result: active users first, then inactive\n     *\n     *   // Complex multi-field: status, then last name, then first name\n     *   users.sort(GaffComparator.strings(user => [user.status, user.lastName, user.firstName]));\n     *\n     *   // Integration with TestValidator sorting validation\n     *   const sortValidator = TestValidator.sort(\"user name sorting\",\n     *     (sortFields) => userApi.getUsers({ sort: sortFields })\n     *   )(\"lastName\", \"firstName\")(\n     *     GaffComparator.strings(user => [user.lastName, user.firstName])\n     *   );\n     *   await sortValidator(\"+\"); // test ascending order\n     *   await sortValidator(\"-\"); // test descending order\n     *   ```;\n     *\n     * @template T - The type of objects being compared\n     * @param getter - Function that extracts string value(s) from input objects\n     * @returns A comparator function suitable for Array.sort()\n     */\n    const strings: <T>(getter: (input: T) => string | string[]) => (x: T, y: T) => number;\n    /**\n     * Creates a comparator function for date-based sorting with automatic string\n     * parsing.\n     *\n     * Generates a comparator that extracts date values from objects,\n     * automatically converting string representations to Date objects for\n     * numerical comparison. Supports both single dates and arrays of dates for\n     * complex temporal sorting.\n     *\n     * Date strings are parsed using the standard Date constructor, which supports\n     * ISO 8601 format, RFC 2822 format, and other common date representations.\n     * The comparison is performed on millisecond timestamps for precise\n     * ordering.\n     *\n     * @example\n     *   ```typescript\n     *   interface Event {\n     *     id: string;\n     *     title: string;\n     *     startDate: string;\n     *     endDate: string;\n     *     createdAt: string;\n     *     updatedAt: string;\n     *   }\n     *\n     *   const events: Event[] = [\n     *     {\n     *       id: '1',\n     *       title: 'Conference',\n     *       startDate: '2024-03-15T09:00:00Z',\n     *       endDate: '2024-03-15T17:00:00Z',\n     *       createdAt: '2024-01-10T10:00:00Z',\n     *       updatedAt: '2024-02-01T15:30:00Z'\n     *     },\n     *     {\n     *       id: '2',\n     *       title: 'Workshop',\n     *       startDate: '2024-03-10T14:00:00Z',\n     *       endDate: '2024-03-10T16:00:00Z',\n     *       createdAt: '2024-01-15T11:00:00Z',\n     *       updatedAt: '2024-01-20T09:15:00Z'\n     *     }\n     *   ];\n     *\n     *   // Sort by start date (chronological order)\n     *   events.sort(GaffComparator.dates(event => event.startDate));\n     *\n     *   // Sort by creation date (oldest first)\n     *   events.sort(GaffComparator.dates(event => event.createdAt));\n     *\n     *   // Multi-field: start date, then end date\n     *   events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));\n     *\n     *   // Sort by modification history: created date, then updated date\n     *   events.sort(GaffComparator.dates(event => [event.createdAt, event.updatedAt]));\n     *\n     *   // Validate API date sorting with TestValidator\n     *   const dateValidator = TestValidator.sort(\"event chronological sorting\",\n     *     (sortFields) => eventApi.getEvents({ sort: sortFields })\n     *   )(\"startDate\")(\n     *     GaffComparator.dates(event => event.startDate)\n     *   );\n     *   await dateValidator(\"+\", true); // ascending with trace logging\n     *\n     *   // Test complex date-based sorting\n     *   const sortByEventSchedule = GaffComparator.dates(event => [\n     *     event.startDate,\n     *     event.endDate\n     *   ]);\n     *   ```;\n     *\n     * @template T - The type of objects being compared\n     * @param getter - Function that extracts date string(s) from input objects\n     * @returns A comparator function suitable for Array.sort()\n     */\n    const dates: <T>(getter: (input: T) => string | string[]) => (x: T, y: T) => number;\n    /**\n     * Creates a comparator function for numerical sorting with multi-value\n     * support.\n     *\n     * Generates a comparator that extracts numerical values from objects and\n     * performs mathematical comparison. Supports both single numbers and arrays\n     * of numbers for complex numerical sorting scenarios like sorting by price\n     * then by rating.\n     *\n     * When comparing arrays, performs lexicographic numerical ordering: compares\n     * the first numbers, then the second numbers if the first are equal, and so\n     * on. This enables sophisticated sorting like \"sort by price ascending, then\n     * by rating descending\".\n     *\n     * @example\n     *   ```typescript\n     *   interface Product {\n     *     id: string;\n     *     name: string;\n     *     price: number;\n     *     rating: number;\n     *     stock: number;\n     *     categoryId: number;\n     *     salesCount: number;\n     *   }\n     *\n     *   const products: Product[] = [\n     *     { id: '1', name: 'Laptop', price: 999.99, rating: 4.5, stock: 15, categoryId: 1, salesCount: 150 },\n     *     { id: '2', name: 'Mouse', price: 29.99, rating: 4.2, stock: 50, categoryId: 1, salesCount: 300 },\n     *     { id: '3', name: 'Keyboard', price: 79.99, rating: 4.8, stock: 25, categoryId: 1, salesCount: 200 }\n     *   ];\n     *\n     *   // Sort by price (ascending)\n     *   products.sort(GaffComparator.numbers(product => product.price));\n     *   // Result: Mouse ($29.99), Keyboard ($79.99), Laptop ($999.99)\n     *\n     *   // Sort by rating (descending requires negation)\n     *   products.sort(GaffComparator.numbers(product => -product.rating));\n     *   // Result: Keyboard (4.8), Laptop (4.5), Mouse (4.2)\n     *\n     *   // Multi-field: category, then price\n     *   products.sort(GaffComparator.numbers(product => [product.categoryId, product.price]));\n     *\n     *   // Complex business logic: popularity (sales) then rating\n     *   products.sort(GaffComparator.numbers(product => [-product.salesCount, -product.rating]));\n     *   // Negative values for descending order\n     *\n     *   // Sort by inventory priority: low stock first, then by sales\n     *   products.sort(GaffComparator.numbers(product => [product.stock, -product.salesCount]));\n     *\n     *   // Validate API numerical sorting with TestValidator\n     *   const priceValidator = TestValidator.sort(\"product price sorting\",\n     *     (sortFields) => productApi.getProducts({ sort: sortFields })\n     *   )(\"price\")(\n     *     GaffComparator.numbers(product => product.price)\n     *   );\n     *   await priceValidator(\"+\"); // test ascending order\n     *   await priceValidator(\"-\"); // test descending order\n     *\n     *   // Test multi-criteria sorting\n     *   const sortByBusinessValue = GaffComparator.numbers(product => [\n     *     -product.salesCount,  // High sales first\n     *     -product.rating,      // High rating first\n     *     product.price         // Low price first (for tie-breaking)\n     *   ]);\n     *   ```;\n     *\n     * @template T - The type of objects being compared\n     * @param closure - Function that extracts number value(s) from input objects\n     * @returns A comparator function suitable for Array.sort()\n     */\n    const numbers: <T>(closure: (input: T) => number | number[]) => (x: T, y: T) => number;\n}\n",
  "node_modules/@nestia/e2e/lib/MapUtil.d.ts": "/**\n * A namespace providing utility functions for Map manipulation.\n *\n * This namespace contains helper functions for working with JavaScript Map\n * objects, providing convenient methods for common Map operations like\n * retrieving values with lazy initialization.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   // Create a cache with lazy initialization\n *   const cache = new Map<string, ExpensiveObject>();\n *\n *   const obj = MapUtil.take(cache, \"key1\", () => {\n *     console.log(\"Creating expensive object...\");\n *     return new ExpensiveObject();\n *   });\n *\n *   // Subsequent calls return cached value without re-creating\n *   const sameObj = MapUtil.take(cache, \"key1\", () => new ExpensiveObject());\n *   console.log(obj === sameObj); // true\n *   ```;\n */\nexport declare namespace MapUtil {\n    /**\n     * Retrieves a value from a Map or creates it using a lazy initialization\n     * function.\n     *\n     * This function implements the \"get or create\" pattern for Maps. If the key\n     * exists in the Map, it returns the existing value. Otherwise, it calls the\n     * provided factory function to create a new value, stores it in the Map, and\n     * returns it. The factory function is only called when the key doesn't exist,\n     * enabling lazy initialization and caching patterns.\n     *\n     * @example\n     *   ```typescript\n     *   // Simple caching example\n     *   const userCache = new Map<number, User>();\n     *\n     *   const user = MapUtil.take(userCache, userId, () => {\n     *     // This expensive operation only runs if userId is not cached\n     *     return fetchUserFromDatabase(userId);\n     *   });\n     *\n     *   // Configuration object caching\n     *   const configs = new Map<string, Config>();\n     *\n     *   const dbConfig = MapUtil.take(configs, \"database\", () => ({\n     *     host: \"localhost\",\n     *     port: 5432,\n     *     database: \"myapp\"\n     *   }));\n     *\n     *   // Lazy computation results\n     *   const computationCache = new Map<string, number>();\n     *\n     *   const result = MapUtil.take(computationCache, \"fibonacci-40\", () => {\n     *     console.log(\"Computing fibonacci(40)...\");\n     *     return fibonacci(40); // Only computed once\n     *   });\n     *\n     *   // Using with complex keys\n     *   const cache = new Map<[number, number], Matrix>();\n     *   const key: [number, number] = [rows, cols];\n     *\n     *   const matrix = MapUtil.take(cache, key, () =>\n     *     generateIdentityMatrix(rows, cols)\n     *   );\n     *   ```;\n     *\n     * @template K - The type of keys in the Map\n     * @template V - The type of values in the Map\n     * @param map - The Map to retrieve from or update\n     * @param key - The key to look up in the Map\n     * @param value - A factory function that creates the value if key doesn't exist\n     * @returns The existing value if found, or the newly created value\n     */\n    function take<K, V>(map: Map<K, V>, key: K, value: () => V): V;\n}\n",
  "node_modules/@nestia/e2e/lib/RandomGenerator.d.ts": "/**\n * Comprehensive random data generation utilities for testing and development.\n *\n * RandomGenerator provides a collection of functions for generating random data\n * including strings, names, content, dates, and array sampling. All functions\n * are designed to be deterministic within a single execution but produce varied\n * output across different runs, making them ideal for testing scenarios.\n *\n * The namespace includes specialized generators for:\n *\n * - Text content (alphabets, alphanumeric, names, paragraphs)\n * - Phone numbers and contact information\n * - Date ranges and time-based data\n * - Array sampling and element selection\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   // Generate test user data\n *   const testUser = {\n *     id: RandomGenerator.alphaNumeric(8),\n *     name: RandomGenerator.name(),\n *     bio: RandomGenerator.paragraph({ sentences: 3, wordMin: 5, wordMax: 10 }),\n *     phone: RandomGenerator.mobile(),\n *     createdAt: RandomGenerator.date(new Date(), 1000 * 60 * 60 * 24 * 30) // 30 days\n *   };\n *\n *   // Sample data for testing\n *   const testSample = RandomGenerator.sample(allUsers, 5);\n *   ```;\n */\nexport declare namespace RandomGenerator {\n    /**\n     * Generates a random string containing only lowercase alphabetical\n     * characters.\n     *\n     * Creates a string of specified length using only characters a-z. Each\n     * character is independently randomly selected, so the same character may\n     * appear multiple times. Useful for generating random identifiers, test\n     * names, or placeholder text.\n     *\n     * @example\n     *   ```typescript\n     *   RandomGenerator.alphabets(5);  // e.g. \"kxqpw\"\n     *   RandomGenerator.alphabets(3);  // e.g. \"mzr\"\n     *   RandomGenerator.alphabets(10); // e.g. \"qwertasdfg\"\n     *\n     *   // Generate random CSS class names\n     *   const className = `test-${RandomGenerator.alphabets(6)}`;\n     *\n     *   // Create random variable names for testing\n     *   const varName = RandomGenerator.alphabets(8);\n     *   ```\n     *\n     * @param length - The desired length of the generated alphabetic string\n     * @returns A string containing only lowercase letters of the specified length\n     */\n    const alphabets: (length: number) => string;\n    /**\n     * Generates a random alphanumeric string containing digits and lowercase\n     * letters.\n     *\n     * Creates a string of specified length using characters from 0-9 and a-z.\n     * Each position is independently randomly selected from the combined\n     * character set. Ideal for generating random IDs, tokens, passwords, or\n     * unique identifiers that need both numeric and alphabetic characters.\n     *\n     * @example\n     *   ```typescript\n     *   RandomGenerator.alphaNumeric(8);  // e.g. \"a1b2c3d4\"\n     *   RandomGenerator.alphaNumeric(12); // e.g. \"x9y8z7w6v5u4\"\n     *\n     *   // Generate random API keys\n     *   const apiKey = RandomGenerator.alphaNumeric(32);\n     *\n     *   // Create session tokens\n     *   const sessionId = `sess_${RandomGenerator.alphaNumeric(16)}`;\n     *\n     *   // Generate test database IDs\n     *   const testId = RandomGenerator.alphaNumeric(10);\n     *   ```\n     *\n     * @param length - The desired length of the generated alphanumeric string\n     * @returns A string containing digits and lowercase letters of the specified\n     *   length\n     */\n    const alphaNumeric: (length: number) => string;\n    /**\n     * Generates a random name-like string with realistic length variation.\n     *\n     * Creates a name by generating a paragraph with 2-3 words (randomly chosen).\n     * The resulting string resembles typical human names in structure and length.\n     * Each word is between 3-7 characters by default, creating realistic-looking\n     * names.\n     *\n     * @example\n     *   ```typescript\n     *   RandomGenerator.name();    // e.g. \"lorem ipsum\" (2-3 words)\n     *   RandomGenerator.name(1);   // e.g. \"dolor\" (single word)\n     *   RandomGenerator.name(3);   // e.g. \"sit amet consectetur\" (3 words)\n     *\n     *   // Generate test user names\n     *   const users = Array.from({ length: 10 }, () => ({\n     *   id: RandomGenerator.alphaNumeric(8),\n     *   name: RandomGenerator.name(),\n     *   email: `${RandomGenerator.name(1)}@test.com`\n     *   }));\n     *\n     *   // Create random author names for blog posts\n     *   const authorName = RandomGenerator.name();\n     *   ```\n     *\n     * @param length - Number of words in the name (default: random between 2-3)\n     * @returns A space-separated string of random words (each 3-7 chars by\n     *   default)\n     */\n    const name: (length?: number) => string;\n    /**\n     * Generates a random paragraph with configurable sentence structure.\n     *\n     * Creates a paragraph consisting of a specified number of \"sentences\"\n     * (words). Each sentence is a random alphabetic string, and sentences are\n     * joined with spaces. Accepts an optional configuration object for fine-tuned\n     * control over the paragraph structure.\n     *\n     * @example\n     *   ```typescript\n     *   // Generate with defaults (random 2-5 words, 3-7 characters each)\n     *   RandomGenerator.paragraph();  // e.g. \"lorem ipsum dolor\"\n     *\n     *   // Specific number of sentences\n     *   RandomGenerator.paragraph({ sentences: 5 });  // \"lorem ipsum dolor sit amet\"\n     *\n     *   // Custom word length ranges\n     *   RandomGenerator.paragraph({ sentences: 4, wordMin: 2, wordMax: 5 });\n     *   // \"ab cd ef gh\"\n     *\n     *   // Generate product descriptions\n     *   const description = RandomGenerator.paragraph({\n     *     sentences: 8,\n     *     wordMin: 4,\n     *     wordMax: 8\n     *   });\n     *\n     *   // Create test content for forms\n     *   const placeholder = RandomGenerator.paragraph({\n     *     sentences: 3,\n     *     wordMin: 5,\n     *     wordMax: 10\n     *   });\n     *   ```;\n     *\n     * @param props - Optional configuration object with sentences count and word\n     *   length ranges\n     * @returns A string containing the generated paragraph\n     */\n    const paragraph: (props?: Partial<{\n        sentences: number;\n        wordMin: number;\n        wordMax: number;\n    }>) => string;\n    /**\n     * Generates random multi-paragraph content with customizable structure.\n     *\n     * Creates content consisting of multiple paragraphs separated by double\n     * newlines. Accepts an optional configuration object to control content\n     * structure including paragraph count, sentences per paragraph, and word\n     * character lengths. Ideal for generating realistic-looking text content for\n     * testing.\n     *\n     * @example\n     *   ```typescript\n     *   // Generate with all defaults\n     *   const article = RandomGenerator.content();\n     *\n     *   // Specific structure: 5 paragraphs, 15-25 sentences each, 4-8 char words\n     *   const longContent = RandomGenerator.content({\n     *     paragraphs: 5,\n     *     sentenceMin: 15,\n     *     sentenceMax: 25,\n     *     wordMin: 4,\n     *     wordMax: 8\n     *   });\n     *\n     *   // Short content with brief sentences\n     *   const shortContent = RandomGenerator.content({\n     *     paragraphs: 2,\n     *     sentenceMin: 5,\n     *     sentenceMax: 8,\n     *     wordMin: 2,\n     *     wordMax: 4\n     *   });\n     *\n     *   // Generate blog post content\n     *   const blogPost = {\n     *     title: RandomGenerator.name(3),\n     *     content: RandomGenerator.content({\n     *       paragraphs: 4,\n     *       sentenceMin: 10,\n     *       sentenceMax: 20,\n     *       wordMin: 3,\n     *       wordMax: 7\n     *     }),\n     *     summary: RandomGenerator.paragraph({ sentences: 2 })\n     *   };\n     *\n     *   // Create test data for CMS\n     *   const pages = Array.from({ length: 10 }, () => ({\n     *     id: RandomGenerator.alphaNumeric(8),\n     *     content: RandomGenerator.content({\n     *       paragraphs: randint(2, 6),\n     *       sentenceMin: 8,\n     *       sentenceMax: 15\n     *     })\n     *   }));\n     *   ```;\n     *\n     * @param props - Optional configuration object with paragraph, sentence, and\n     *   word parameters\n     * @returns A string containing the generated multi-paragraph content\n     */\n    const content: (props?: Partial<{\n        paragraphs: number;\n        sentenceMin: number;\n        sentenceMax: number;\n        wordMin: number;\n        wordMax: number;\n    }>) => string;\n    /**\n     * Extracts a random substring from the provided content string.\n     *\n     * Selects two random positions within the content and returns the substring\n     * between them. The starting position is always before the ending position.\n     * Automatically trims whitespace from the beginning and end of the result.\n     * Useful for creating excerpts, search terms, or partial content samples.\n     *\n     * @example\n     *   ```typescript\n     *   const text = \"The quick brown fox jumps over the lazy dog\";\n     *\n     *   RandomGenerator.substring(text);  // e.g. \"quick brown fox\"\n     *   RandomGenerator.substring(text);  // e.g. \"jumps over\"\n     *   RandomGenerator.substring(text);  // e.g. \"fox jumps over the lazy\"\n     *\n     *   // Generate search terms from content\n     *   const searchQuery = RandomGenerator.substring(articleContent);\n     *\n     *   // Create excerpts for previews\n     *   const excerpt = RandomGenerator.substring(fullBlogPost);\n     *\n     *   // Generate partial matches for testing search functionality\n     *   const partialMatch = RandomGenerator.substring(productDescription);\n     *\n     *   // Create random selections for highlight testing\n     *   const selectedText = RandomGenerator.substring(documentContent);\n     *   ```;\n     *\n     * @param content - The source string to extract a substring from\n     * @returns A trimmed substring of the original content\n     */\n    const substring: (content: string) => string;\n    /**\n     * Generates a random mobile phone number with customizable prefix.\n     *\n     * Creates a mobile phone number in the format: [prefix][3-4 digits][4\n     * digits]. The middle section is 3 digits if the random number is less than\n     * 1000, otherwise 4 digits. The last section is always 4 digits, zero-padded\n     * if necessary. Commonly used for generating Korean mobile phone numbers or\n     * similar formats.\n     *\n     * @example\n     *   ```typescript\n     *   RandomGenerator.mobile();        // e.g. \"0103341234\" or \"01012345678\"\n     *   RandomGenerator.mobile(\"011\");   // e.g. \"0119876543\" or \"01112345678\"\n     *   RandomGenerator.mobile(\"+82\");   // e.g. \"+823341234\" or \"+8212345678\"\n     *\n     *   // Generate test user phone numbers\n     *   const testUsers = Array.from({ length: 100 }, () => ({\n     *     name: RandomGenerator.name(),\n     *     phone: RandomGenerator.mobile(),\n     *     altPhone: RandomGenerator.mobile(\"011\")\n     *   }));\n     *\n     *   // Create international phone numbers\n     *   const internationalPhone = RandomGenerator.mobile(\"+821\");\n     *\n     *   // Generate contact list for testing\n     *   const contacts = [\"010\", \"011\", \"016\", \"017\", \"018\", \"019\"].map(prefix => ({\n     *     carrier: prefix,\n     *     number: RandomGenerator.mobile(prefix)\n     *   }));\n     *   ```;\n     *\n     * @param prefix - The prefix string for the phone number (default: \"010\")\n     * @returns A formatted mobile phone number string\n     */\n    const mobile: (prefix?: string) => string;\n    /**\n     * Generates a random date within a specified range from a starting point.\n     *\n     * Returns a random date between the start date and start date + range. The\n     * range represents the maximum number of milliseconds to add to the starting\n     * date. Useful for generating timestamps, creation dates, or scheduling test\n     * data.\n     *\n     * @example\n     *   ```typescript\n     *   const now = new Date();\n     *   const oneDay = 24 * 60 * 60 * 1000;\n     *   const oneMonth = 30 * oneDay;\n     *\n     *   // Random date within the next 30 days\n     *   const futureDate = RandomGenerator.date(now, oneMonth);\n     *\n     *   // Random date within the past week\n     *   const pastWeek = new Date(now.getTime() - 7 * oneDay);\n     *   const recentDate = RandomGenerator.date(pastWeek, 7 * oneDay);\n     *\n     *   // Generate random creation dates for test data\n     *   const startOfYear = new Date(2024, 0, 1);\n     *   const endOfYear = new Date(2024, 11, 31).getTime() - startOfYear.getTime();\n     *   const randomCreationDate = RandomGenerator.date(startOfYear, endOfYear);\n     *\n     *   // Create test events with random timestamps\n     *   const events = Array.from({ length: 50 }, () => ({\n     *     id: RandomGenerator.alphaNumeric(8),\n     *     title: RandomGenerator.name(2),\n     *     createdAt: RandomGenerator.date(new Date(), oneMonth),\n     *     scheduledFor: RandomGenerator.date(new Date(), oneMonth * 3)\n     *   }));\n     *   ```;\n     *\n     * @param from - The starting date for the random range\n     * @param range - The range in milliseconds from the starting date\n     * @returns A random date within the specified range\n     */\n    const date: (from: Date, range: number) => Date;\n    /**\n     * Randomly samples a specified number of unique elements from an array.\n     *\n     * Selects random elements from the input array without replacement, ensuring\n     * all returned elements are unique. The sample size is automatically capped\n     * at the array length to prevent errors. Uses a Set-based approach to\n     * guarantee uniqueness of selected indices. Ideal for creating test datasets\n     * or selecting random subsets for validation.\n     *\n     * @example\n     *   ```typescript\n     *   const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n     *\n     *   RandomGenerator.sample(numbers, 3);  // e.g. [2, 7, 9]\n     *   RandomGenerator.sample(numbers, 5);  // e.g. [1, 4, 6, 8, 10]\n     *   RandomGenerator.sample(numbers, 15); // returns all 10 elements (capped at array length)\n     *\n     *   // Sample users for testing\n     *   const allUsers = await getUsersFromDatabase();\n     *   const testUsers = RandomGenerator.sample(allUsers, 10);\n     *\n     *   // Create random product selections\n     *   const featuredProducts = RandomGenerator.sample(allProducts, 5);\n     *\n     *   // Generate test data subsets\n     *   const validationSet = RandomGenerator.sample(trainingData, 100);\n     *\n     *   // Random A/B testing groups\n     *   const groupA = RandomGenerator.sample(allParticipants, 50);\n     *   const remaining = allParticipants.filter(p => !groupA.includes(p));\n     *   const groupB = RandomGenerator.sample(remaining, 50);\n     *   ```;\n     *\n     * @param array - The source array to sample from\n     * @param count - The number of elements to sample\n     * @returns An array containing the randomly selected elements\n     */\n    const sample: <T>(array: T[], count: number) => T[];\n    /**\n     * Randomly selects a single element from an array.\n     *\n     * Chooses one element at random from the provided array using uniform\n     * distribution. Each element has an equal probability of being selected. This\n     * is a convenience function equivalent to sampling with a count of 1, but\n     * returns the element directly rather than an array containing one element.\n     *\n     * @example\n     *   ```typescript\n     *   const colors = ['red', 'blue', 'green', 'yellow', 'purple'];\n     *   const fruits = ['apple', 'banana', 'orange', 'grape', 'kiwi'];\n     *\n     *   RandomGenerator.pick(colors);  // e.g. \"blue\"\n     *   RandomGenerator.pick(fruits);  // e.g. \"apple\"\n     *\n     *   // Select random configuration options\n     *   const randomTheme = RandomGenerator.pick(['light', 'dark', 'auto']);\n     *   const randomLocale = RandomGenerator.pick(['en', 'ko', 'ja', 'zh']);\n     *\n     *   // Choose random test scenarios\n     *   const testScenario = RandomGenerator.pick([\n     *     'happy_path',\n     *     'edge_case',\n     *     'error_condition',\n     *     'boundary_test'\n     *   ]);\n     *\n     *   // Random user role assignment\n     *   const userRole = RandomGenerator.pick(['admin', 'user', 'moderator']);\n     *\n     *   // Select random API endpoints for testing\n     *   const endpoints = ['/users', '/posts', '/comments', '/categories'];\n     *   const randomEndpoint = RandomGenerator.pick(endpoints);\n     *   ```;\n     *\n     * @param array - The source array to pick an element from\n     * @returns A randomly selected element from the array\n     */\n    const pick: <T>(array: readonly T[]) => T;\n}\n",
  "node_modules/@nestia/e2e/lib/TestValidator.d.ts": "/**\n * A comprehensive collection of E2E validation utilities for testing\n * applications.\n *\n * TestValidator provides type-safe validation functions for common testing\n * scenarios including condition checking, equality validation, error testing,\n * HTTP error validation, pagination testing, search functionality validation,\n * and sorting validation.\n *\n * Most functions use direct parameter passing for simplicity, while some\n * maintain currying patterns for advanced composition. All provide detailed\n * error messages for debugging failed assertions.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   // Basic condition testing\n *   TestValidator.predicate(\"user should be authenticated\", user.isAuthenticated);\n *\n *   // Equality validation\n *   TestValidator.equals(\"API response should match expected\", x, y);\n *\n *   // Error validation\n *   TestValidator.error(\"should throw on invalid input\", () => assertInput(\"\"));\n *   ```;\n */\nexport declare namespace TestValidator {\n    /**\n     * Validates that a given condition evaluates to true.\n     *\n     * Supports synchronous boolean values, synchronous functions returning\n     * boolean, and asynchronous functions returning Promise<boolean>. The return\n     * type is automatically inferred based on the input type.\n     *\n     * @example\n     *   ```typescript\n     *   // Synchronous boolean\n     *   TestValidator.predicate(\"user should exist\", user !== null);\n     *\n     *   // Synchronous function\n     *   TestValidator.predicate(\"array should be empty\", () => arr.length === 0);\n     *\n     *   // Asynchronous function\n     *   await TestValidator.predicate(\"database should be connected\",\n     *     async () => await db.ping()\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when validation\n     *   fails\n     * @param condition - The condition to validate (boolean, function, or async\n     *   function)\n     * @returns Void or Promise<void> based on the input type\n     * @throws Error with descriptive message when condition is not satisfied\n     */\n    function predicate<T extends boolean | (() => boolean) | (() => Promise<boolean>)>(title: string, condition: T): T extends () => Promise<boolean> ? Promise<void> : void;\n    /**\n     * Validates deep equality between two values using JSON comparison.\n     *\n     * Performs recursive comparison of objects and arrays. Supports an optional\n     * exception filter to ignore specific keys during comparison. Useful for\n     * validating API responses, data transformations, and object state changes.\n     *\n     * @example\n     *   ```typescript\n     *   // Basic equality\n     *   TestValidator.equals(\"response should match expected\", expectedUser, actualUser);\n     *\n     *   // Ignore timestamps in comparison\n     *   TestValidator.equals(\"user da