@autobe/compiler 0.21.0 → 0.22.1

package/lib/raw/test.json

@@ -4,11 +4,11 @@
     "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 data should match\", expectedUser, actualUser,\n     *     (key) => key === \"updatedAt\"\n     *   );\n     *\n     *   // Validate API response structure\n     *   TestValidator.equals(\"API response structure\",\n     *     { id: 1, name: \"John\" },\n     *     { id: 1, name: \"John\" }\n     *   );\n     *\n     *   // Type-safe nullable comparisons\n     *   const nullableData: { name: string } | null = getData();\n     *   TestValidator.equals(\"nullable check\", nullableData, null);\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when values differ\n     * @param X - The first value to compare\n     * @param y - The second value to compare (can be null or undefined)\n     * @param exception - Optional filter function to exclude specific keys from\n     *   comparison\n     * @throws Error with detailed diff information when values are not equal\n     */\n    function equals<X, Y extends X>(title: string, X: X, y: Y | null | undefined, exception?: (key: string) => boolean): void;\n    /**\n     * Validates deep inequality between two values using JSON comparison.\n     *\n     * Performs recursive comparison of objects and arrays to ensure they are NOT\n     * equal. Supports an optional exception filter to ignore specific keys during\n     * comparison. Useful for validating that data has changed, objects are\n     * different, or mutations have occurred.\n     *\n     * @example\n     *   ```typescript\n     *   // Basic inequality\n     *   TestValidator.notEquals(\"user should be different after update\", originalUser, updatedUser);\n     *\n     *   // Ignore timestamps in comparison\n     *   TestValidator.notEquals(\"user data should differ\", originalUser, modifiedUser,\n     *     (key) => key === \"updatedAt\"\n     *   );\n     *\n     *   // Validate state changes\n     *   TestValidator.notEquals(\"state should have changed\", initialState, currentState);\n     *\n     *   // Type-safe nullable comparisons\n     *   const mutableData: { count: number } | null = getMutableData();\n     *   TestValidator.notEquals(\"should have changed\", mutableData, null);\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when values are\n     *   equal\n     * @param x - The first value to compare\n     * @param y - The second value to compare (can be null or undefined)\n     * @param exception - Optional filter function to exclude specific keys from\n     *   comparison\n     * @throws Error when values are equal (indicating validation failure)\n     */\n    function notEquals<X, Y extends X>(title: string, x: X, y: Y | null | undefined, exception?: (key: string) => boolean): void;\n    /**\n     * Validates that a function throws an error or rejects when executed.\n     *\n     * Expects the provided function to fail. If the function executes\n     * successfully without throwing an error or rejecting, this validator will\n     * throw an exception. Supports both synchronous and asynchronous functions.\n     *\n     * @example\n     *   ```typescript\n     *   // Synchronous error validation\n     *   TestValidator.error(\"should reject invalid email\",\n     *     () => validateEmail(\"invalid-email\")\n     *   );\n     *\n     *   // Asynchronous error validation\n     *   await TestValidator.error(\"should reject unauthorized access\",\n     *     async () => await api.functional.getSecretData()\n     *   );\n     *\n     *   // Validate input validation\n     *   TestValidator.error(\"should throw on empty string\",\n     *     () => processRequiredInput(\"\")\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when no error\n     *   occurs\n     * @param task - The function that should throw an error or reject\n     * @returns Void or Promise<void> based on the input type\n     * @throws Error when the task function does not throw an error or reject\n     */\n    function error<T>(title: string, task: () => T): T extends Promise<any> ? Promise<void> : void;\n    /**\n     * Validates that a function throws an HTTP error with specific status codes.\n     *\n     * Specialized error validator for HTTP operations. Validates that the\n     * function throws an HttpError with one of the specified status codes. Useful\n     * for testing API endpoints, authentication, and authorization logic.\n     *\n     * @example\n     *   ```typescript\n     *   // Validate 401 Unauthorized\n     *   await TestValidator.httpError(\"should return 401 for invalid token\", 401,\n     *     async () => await api.functional.getProtectedResource(\"invalid-token\")\n     *   );\n     *\n     *   // Validate multiple possible error codes\n     *   await TestValidator.httpError(\"should return client error\", [400, 404, 422],\n     *     async () => await api.functional.updateNonexistentResource(data)\n     *   );\n     *\n     *   // Validate server errors\n     *   TestValidator.httpError(\"should handle server errors\", [500, 502, 503],\n     *     () => callFaultyEndpoint()\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages\n     * @param status - Expected status code(s), can be a single number or array\n     * @param task - The function that should throw an HttpError\n     * @returns Void or Promise<void> based on the input type\n     * @throws Error when function doesn't throw HttpError or status code doesn't\n     *   match\n     */\n    function httpError<T>(title: string, status: number | number[], task: () => T): T extends Promise<any> ? Promise<void> : void;\n    /**\n     * Validates pagination index API results against expected entity order.\n     *\n     * Compares the order of entities returned by a pagination API with manually\n     * sorted expected results. Validates that entity IDs appear in the correct\n     * sequence. Commonly used for testing database queries, search results, and\n     * any paginated data APIs.\n     *\n     * @example\n     *   ```typescript\n     *   // Test article pagination\n     *   const expectedArticles = await db.articles.findAll({ order: 'created_at DESC' });\n     *   const actualArticles = await api.functional.getArticles({ page: 1, limit: 10 });\n     *\n     *   TestValidator.index(\"article pagination order\", expectedArticles, actualArticles,\n     *     true // enable trace logging\n     *   );\n     *\n     *   // Test user search results\n     *   const manuallyFilteredUsers = allUsers.filter(u => u.name.includes(\"John\"));\n     *   const apiSearchResults = await api.functional.searchUsers({ query: \"John\" });\n     *\n     *   TestValidator.index(\"user search results\", manuallyFilteredUsers, apiSearchResults);\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when order differs\n     * @param expected - The expected entities in correct order\n     * @param gotten - The actual entities returned by the API\n     * @param trace - Optional flag to enable debug logging (default: false)\n     * @throws Error when entity order differs between expected and actual results\n     */\n    const index: <X extends IEntity<any>, Y extends X>(title: string, expected: X[], gotten: Y[], trace?: boolean) => void;\n    /**\n     * Validates search functionality by testing API results against manual\n     * filtering.\n     *\n     * Comprehensive search validation that samples entities from a complete\n     * dataset, extracts search values, applies manual filtering, calls the search\n     * API, and compares results. Validates that search APIs return the correct\n     * subset of data matching the search criteria.\n     *\n     * @example\n     *   ```typescript\n     *   // Test article search functionality with exact matching\n     *   const allArticles = await db.articles.findAll();\n     *   const searchValidator = TestValidator.search(\n     *     \"article search API\",\n     *     (req) => api.searchArticles(req),\n     *     allArticles,\n     *     5 // test with 5 random samples\n     *   );\n     *\n     *   // Test exact match search\n     *   await searchValidator({\n     *     fields: [\"title\"],\n     *     values: (article) => [article.title], // full title for exact match\n     *     filter: (article, [title]) => article.title === title, // exact match\n     *     request: ([title]) => ({ search: { title } })\n     *   });\n     *\n     *   // Test partial match search with includes\n     *   await searchValidator({\n     *     fields: [\"content\"],\n     *     values: (article) => [article.content.substring(0, 20)], // partial content\n     *     filter: (article, [keyword]) => article.content.includes(keyword),\n     *     request: ([keyword]) => ({ q: keyword })\n     *   });\n     *\n     *   // Test multi-field search with exact matching\n     *   await searchValidator({\n     *     fields: [\"writer\", \"title\"],\n     *     values: (article) => [article.writer, article.title],\n     *     filter: (article, [writer, title]) =>\n     *       article.writer === writer && article.title === title,\n     *     request: ([writer, title]) => ({ search: { writer, title } })\n     *   });\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when search fails\n     * @param getter - API function that performs the search\n     * @param total - Complete dataset to sample from for testing\n     * @param sampleCount - Number of random samples to test (default: 1)\n     * @returns A function that accepts search configuration properties\n     * @throws Error when API search results don't match manual filtering results\n     */\n    const search: <Entity extends IEntity<any>, Request>(title: string, getter: (input: Request) => Promise<Entity[]>, total: Entity[], sampleCount?: number) => <Values extends any[]>(props: ISearchProps<Entity, Values, Request>) => Promise<void>;\n    /**\n     * Configuration interface for search validation functionality.\n     *\n     * Defines the structure needed to validate search operations by specifying\n     * how to extract search values from entities, filter the dataset manually,\n     * and construct API requests.\n     *\n     * @template Entity - Type of entities being searched, must have an ID field\n     * @template Values - Tuple type representing the search values extracted from\n     *   entities\n     * @template Request - Type of the API request object\n     */\n    interface ISearchProps<Entity extends IEntity<any>, Values extends any[], Request> {\n        /** Field names being searched, used in error messages for identification */\n        fields: string[];\n        /**\n         * Extracts search values from a sample entity\n         *\n         * @param entity - The entity to extract search values from\n         * @returns Tuple of values used for searching\n         */\n        values(entity: Entity): Values;\n        /**\n         * Manual filter function to determine if an entity matches search criteria\n         *\n         * @param entity - Entity to test against criteria\n         * @param values - Search values to match against\n         * @returns True if entity matches the search criteria\n         */\n        filter(entity: Entity, values: Values): boolean;\n        /**\n         * Constructs API request object from search values\n         *\n         * @param values - Search values to include in request\n         * @returns Request object for the search API\n         */\n        request(values: Values): Request;\n    }\n    /**\n     * Validates sorting functionality of pagination APIs.\n     *\n     * Tests sorting operations by calling the API with sort parameters and\n     * validating that results are correctly ordered. Supports multiple fields,\n     * ascending/descending order, and optional filtering. Provides detailed error\n     * reporting for sorting failures.\n     *\n     * @example\n     *   ```typescript\n     *   // Test single field sorting with GaffComparator\n     *   const sortValidator = TestValidator.sort(\n     *     \"article sorting\",\n     *     (sortable) => api.getArticles({ sort: sortable })\n     *   )(\"created_at\")(\n     *     GaffComparator.dates((a) => a.created_at)\n     *   );\n     *\n     *   await sortValidator(\"+\"); // ascending\n     *   await sortValidator(\"-\"); // descending\n     *\n     *   // Test multi-field sorting with GaffComparator\n     *   const userSortValidator = TestValidator.sort(\n     *     \"user sorting\",\n     *     (sortable) => api.getUsers({ sort: sortable })\n     *   )(\"lastName\", \"firstName\")(\n     *     GaffComparator.strings((user) => [user.lastName, user.firstName]),\n     *     (user) => user.isActive // only test active users\n     *   );\n     *\n     *   await userSortValidator(\"+\", true); // ascending with trace logging\n     *\n     *   // Custom comparator for complex logic\n     *   const customSortValidator = TestValidator.sort(\n     *     \"custom sorting\",\n     *     (sortable) => api.getProducts({ sort: sortable })\n     *   )(\"price\", \"rating\")(\n     *     (a, b) => {\n     *       const priceDiff = a.price - b.price;\n     *       return priceDiff !== 0 ? priceDiff : b.rating - a.rating; // price asc, rating desc\n     *     }\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when sorting fails\n     * @param getter - API function that fetches sorted data\n     * @returns A currying function chain: field names, comparator, then direction\n     * @throws Error when API results are not properly sorted according to\n     *   specification\n     */\n    const sort: <T extends object, Fields extends string, Sortable extends Array<`-${Fields}` | `+${Fields}`> = Array<`-${Fields}` | `+${Fields}`>>(title: string, getter: (sortable: Sortable) => Promise<T[]>) => (...fields: Fields[]) => (comp: (x: T, y: T) => number, filter?: (elem: T) => boolean) => (direction: \"+\" | \"-\", trace?: boolean) => Promise<void>;\n    /**\n     * Type alias for sortable field specifications.\n     *\n     * Represents an array of sort field specifications where each field can be\n     * prefixed with '+' for ascending order or '-' for descending order.\n     *\n     * @example\n     *   ```typescript\n     *   type UserSortable = TestValidator.Sortable<\"name\" | \"email\" | \"created_at\">;\n     *   // Results in: Array<\"-name\" | \"+name\" | \"-email\" | \"+email\" | \"-created_at\" | \"+created_at\">\n     *\n     *   const userSort: UserSortable = [\"+name\", \"-created_at\"];\n     *   ```;\n     *\n     * @template Literal - String literal type representing available field names\n     */\n    type Sortable<Literal extends string> = Array<`-${Literal}` | `+${Literal}`>;\n}\ninterface IEntity<Type extends string | number | bigint> {\n    id: Type;\n}\nexport {};\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 data should match\", expectedUser, actualUser,\n     *     (key) => key === \"updatedAt\"\n     *   );\n     *\n     *   // Validate API response structure\n     *   TestValidator.equals(\"API response structure\",\n     *     { id: 1, name: \"John\" },\n     *     { id: 1, name: \"John\" }\n     *   );\n     *\n     *   // Type-safe nullable comparisons\n     *   const nullableData: { name: string } | null = getData();\n     *   TestValidator.equals(\"nullable check\", nullableData, null);\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when values differ\n     * @param X - The first value to compare\n     * @param y - The second value to compare (can be null or undefined)\n     * @param exception - Optional filter function to exclude specific keys from\n     *   comparison\n     * @throws Error with detailed diff information when values are not equal\n     */\n    function equals<X, Y extends X = X>(title: string, X: X, y: Y | null | undefined, exception?: (key: string) => boolean): void;\n    /**\n     * Validates deep inequality between two values using JSON comparison.\n     *\n     * Performs recursive comparison of objects and arrays to ensure they are NOT\n     * equal. Supports an optional exception filter to ignore specific keys during\n     * comparison. Useful for validating that data has changed, objects are\n     * different, or mutations have occurred.\n     *\n     * @example\n     *   ```typescript\n     *   // Basic inequality\n     *   TestValidator.notEquals(\"user should be different after update\", originalUser, updatedUser);\n     *\n     *   // Ignore timestamps in comparison\n     *   TestValidator.notEquals(\"user data should differ\", originalUser, modifiedUser,\n     *     (key) => key === \"updatedAt\"\n     *   );\n     *\n     *   // Validate state changes\n     *   TestValidator.notEquals(\"state should have changed\", initialState, currentState);\n     *\n     *   // Type-safe nullable comparisons\n     *   const mutableData: { count: number } | null = getMutableData();\n     *   TestValidator.notEquals(\"should have changed\", mutableData, null);\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when values are\n     *   equal\n     * @param x - The first value to compare\n     * @param y - The second value to compare (can be null or undefined)\n     * @param exception - Optional filter function to exclude specific keys from\n     *   comparison\n     * @throws Error when values are equal (indicating validation failure)\n     */\n    function notEquals<X, Y extends X = X>(title: string, x: X, y: Y | null | undefined, exception?: (key: string) => boolean): void;\n    /**\n     * Validates that a function throws an error or rejects when executed.\n     *\n     * Expects the provided function to fail. If the function executes\n     * successfully without throwing an error or rejecting, this validator will\n     * throw an exception. Supports both synchronous and asynchronous functions.\n     *\n     * @example\n     *   ```typescript\n     *   // Synchronous error validation\n     *   TestValidator.error(\"should reject invalid email\",\n     *     () => validateEmail(\"invalid-email\")\n     *   );\n     *\n     *   // Asynchronous error validation\n     *   await TestValidator.error(\"should reject unauthorized access\",\n     *     async () => await api.functional.getSecretData()\n     *   );\n     *\n     *   // Validate input validation\n     *   TestValidator.error(\"should throw on empty string\",\n     *     () => processRequiredInput(\"\")\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when no error\n     *   occurs\n     * @param task - The function that should throw an error or reject\n     * @returns Void or Promise<void> based on the input type\n     * @throws Error when the task function does not throw an error or reject\n     */\n    function error<T>(title: string, task: () => T): T extends Promise<any> ? Promise<void> : void;\n    /**\n     * Validates that a function throws an HTTP error with specific status codes.\n     *\n     * Specialized error validator for HTTP operations. Validates that the\n     * function throws an HttpError with one of the specified status codes. Useful\n     * for testing API endpoints, authentication, and authorization logic.\n     *\n     * @example\n     *   ```typescript\n     *   // Validate 401 Unauthorized\n     *   await TestValidator.httpError(\"should return 401 for invalid token\", 401,\n     *     async () => await api.functional.getProtectedResource(\"invalid-token\")\n     *   );\n     *\n     *   // Validate multiple possible error codes\n     *   await TestValidator.httpError(\"should return client error\", [400, 404, 422],\n     *     async () => await api.functional.updateNonexistentResource(data)\n     *   );\n     *\n     *   // Validate server errors\n     *   TestValidator.httpError(\"should handle server errors\", [500, 502, 503],\n     *     () => callFaultyEndpoint()\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages\n     * @param status - Expected status code(s), can be a single number or array\n     * @param task - The function that should throw an HttpError\n     * @returns Void or Promise<void> based on the input type\n     * @throws Error when function doesn't throw HttpError or status code doesn't\n     *   match\n     */\n    function httpError<T>(title: string, status: number | number[], task: () => T): T extends Promise<any> ? Promise<void> : void;\n    /**\n     * Validates pagination index API results against expected entity order.\n     *\n     * Compares the order of entities returned by a pagination API with manually\n     * sorted expected results. Validates that entity IDs appear in the correct\n     * sequence. Commonly used for testing database queries, search results, and\n     * any paginated data APIs.\n     *\n     * @example\n     *   ```typescript\n     *   // Test article pagination\n     *   const expectedArticles = await db.articles.findAll({ order: 'created_at DESC' });\n     *   const actualArticles = await api.functional.getArticles({ page: 1, limit: 10 });\n     *\n     *   TestValidator.index(\"article pagination order\", expectedArticles, actualArticles,\n     *     true // enable trace logging\n     *   );\n     *\n     *   // Test user search results\n     *   const manuallyFilteredUsers = allUsers.filter(u => u.name.includes(\"John\"));\n     *   const apiSearchResults = await api.functional.searchUsers({ query: \"John\" });\n     *\n     *   TestValidator.index(\"user search results\", manuallyFilteredUsers, apiSearchResults);\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when order differs\n     * @param expected - The expected entities in correct order\n     * @param gotten - The actual entities returned by the API\n     * @param trace - Optional flag to enable debug logging (default: false)\n     * @throws Error when entity order differs between expected and actual results\n     */\n    const index: <X extends IEntity<any>, Y extends X = X>(title: string, expected: X[], gotten: Y[], trace?: boolean) => void;\n    /**\n     * Validates search functionality by testing API results against manual\n     * filtering.\n     *\n     * Comprehensive search validation that samples entities from a complete\n     * dataset, extracts search values, applies manual filtering, calls the search\n     * API, and compares results. Validates that search APIs return the correct\n     * subset of data matching the search criteria.\n     *\n     * @example\n     *   ```typescript\n     *   // Test article search functionality with exact matching\n     *   const allArticles = await db.articles.findAll();\n     *   const searchValidator = TestValidator.search(\n     *     \"article search API\",\n     *     (req) => api.searchArticles(req),\n     *     allArticles,\n     *     5 // test with 5 random samples\n     *   );\n     *\n     *   // Test exact match search\n     *   await searchValidator({\n     *     fields: [\"title\"],\n     *     values: (article) => [article.title], // full title for exact match\n     *     filter: (article, [title]) => article.title === title, // exact match\n     *     request: ([title]) => ({ search: { title } })\n     *   });\n     *\n     *   // Test partial match search with includes\n     *   await searchValidator({\n     *     fields: [\"content\"],\n     *     values: (article) => [article.content.substring(0, 20)], // partial content\n     *     filter: (article, [keyword]) => article.content.includes(keyword),\n     *     request: ([keyword]) => ({ q: keyword })\n     *   });\n     *\n     *   // Test multi-field search with exact matching\n     *   await searchValidator({\n     *     fields: [\"writer\", \"title\"],\n     *     values: (article) => [article.writer, article.title],\n     *     filter: (article, [writer, title]) =>\n     *       article.writer === writer && article.title === title,\n     *     request: ([writer, title]) => ({ search: { writer, title } })\n     *   });\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when search fails\n     * @param getter - API function that performs the search\n     * @param total - Complete dataset to sample from for testing\n     * @param sampleCount - Number of random samples to test (default: 1)\n     * @returns A function that accepts search configuration properties\n     * @throws Error when API search results don't match manual filtering results\n     */\n    const search: <Entity extends IEntity<any>, Request>(title: string, getter: (input: Request) => Promise<Entity[]>, total: Entity[], sampleCount?: number) => <Values extends any[]>(props: ISearchProps<Entity, Values, Request>) => Promise<void>;\n    /**\n     * Configuration interface for search validation functionality.\n     *\n     * Defines the structure needed to validate search operations by specifying\n     * how to extract search values from entities, filter the dataset manually,\n     * and construct API requests.\n     *\n     * @template Entity - Type of entities being searched, must have an ID field\n     * @template Values - Tuple type representing the search values extracted from\n     *   entities\n     * @template Request - Type of the API request object\n     */\n    interface ISearchProps<Entity extends IEntity<any>, Values extends any[], Request> {\n        /** Field names being searched, used in error messages for identification */\n        fields: string[];\n        /**\n         * Extracts search values from a sample entity\n         *\n         * @param entity - The entity to extract search values from\n         * @returns Tuple of values used for searching\n         */\n        values(entity: Entity): Values;\n        /**\n         * Manual filter function to determine if an entity matches search criteria\n         *\n         * @param entity - Entity to test against criteria\n         * @param values - Search values to match against\n         * @returns True if entity matches the search criteria\n         */\n        filter(entity: Entity, values: Values): boolean;\n        /**\n         * Constructs API request object from search values\n         *\n         * @param values - Search values to include in request\n         * @returns Request object for the search API\n         */\n        request(values: Values): Request;\n    }\n    /**\n     * Validates sorting functionality of pagination APIs.\n     *\n     * Tests sorting operations by calling the API with sort parameters and\n     * validating that results are correctly ordered. Supports multiple fields,\n     * ascending/descending order, and optional filtering. Provides detailed error\n     * reporting for sorting failures.\n     *\n     * @example\n     *   ```typescript\n     *   // Test single field sorting with GaffComparator\n     *   const sortValidator = TestValidator.sort(\n     *     \"article sorting\",\n     *     (sortable) => api.getArticles({ sort: sortable })\n     *   )(\"created_at\")(\n     *     GaffComparator.dates((a) => a.created_at)\n     *   );\n     *\n     *   await sortValidator(\"+\"); // ascending\n     *   await sortValidator(\"-\"); // descending\n     *\n     *   // Test multi-field sorting with GaffComparator\n     *   const userSortValidator = TestValidator.sort(\n     *     \"user sorting\",\n     *     (sortable) => api.getUsers({ sort: sortable })\n     *   )(\"lastName\", \"firstName\")(\n     *     GaffComparator.strings((user) => [user.lastName, user.firstName]),\n     *     (user) => user.isActive // only test active users\n     *   );\n     *\n     *   await userSortValidator(\"+\", true); // ascending with trace logging\n     *\n     *   // Custom comparator for complex logic\n     *   const customSortValidator = TestValidator.sort(\n     *     \"custom sorting\",\n     *     (sortable) => api.getProducts({ sort: sortable })\n     *   )(\"price\", \"rating\")(\n     *     (a, b) => {\n     *       const priceDiff = a.price - b.price;\n     *       return priceDiff !== 0 ? priceDiff : b.rating - a.rating; // price asc, rating desc\n     *     }\n     *   );\n     *   ```;\n     *\n     * @param title - Descriptive title used in error messages when sorting fails\n     * @param getter - API function that fetches sorted data\n     * @returns A currying function chain: field names, comparator, then direction\n     * @throws Error when API results are not properly sorted according to\n     *   specification\n     */\n    const sort: <T extends object, Fields extends string, Sortable extends Array<`-${Fields}` | `+${Fields}`> = Array<`-${Fields}` | `+${Fields}`>>(title: string, getter: (sortable: Sortable) => Promise<T[]>) => (...fields: Fields[]) => (comp: (x: T, y: T) => number, filter?: (elem: T) => boolean) => (direction: \"+\" | \"-\", trace?: boolean) => Promise<void>;\n    /**\n     * Type alias for sortable field specifications.\n     *\n     * Represents an array of sort field specifications where each field can be\n     * prefixed with '+' for ascending order or '-' for descending order.\n     *\n     * @example\n     *   ```typescript\n     *   type UserSortable = TestValidator.Sortable<\"name\" | \"email\" | \"created_at\">;\n     *   // Results in: Array<\"-name\" | \"+name\" | \"-email\" | \"+email\" | \"-created_at\" | \"+created_at\">\n     *\n     *   const userSort: UserSortable = [\"+name\", \"-created_at\"];\n     *   ```;\n     *\n     * @template Literal - String literal type representing available field names\n     */\n    type Sortable<Literal extends string> = Array<`-${Literal}` | `+${Literal}`>;\n}\ninterface IEntity<Type extends string | number | bigint> {\n    id: Type;\n}\nexport {};\n",
     "node_modules/@nestia/e2e/lib/index.d.ts": "import * as e2e from \"./module\";\nexport default e2e;\nexport * from \"./module\";\n",
     "node_modules/@nestia/e2e/lib/internal/json_equal_to.d.ts": "export declare const json_equal_to: (exception: (key: string) => boolean) => <T>(x: T) => (y: T | null | undefined) => string[];\n",
     "node_modules/@nestia/e2e/lib/module.d.ts": "export * from \"./ArrayUtil\";\nexport * from \"./MapUtil\";\nexport * from \"./RandomGenerator\";\nexport * from \"./DynamicExecutor\";\nexport * from \"./GaffComparator\";\nexport * from \"./TestValidator\";\n",
-    "node_modules/@nestia/e2e/package.json": "{\n  \"name\": \"@nestia/e2e\",\n  \"version\": \"8.0.1\",\n  \"description\": \"E2E test utilify functions\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"npm run build:main && npm run build:test\",\n    \"build:main\": \"rimraf lib && tsc\",\n    \"build:test\": \"rimraf bin && tsc -p test/tsconfig.json\",\n    \"dev\": \"npm run build:test -- --watch\",\n    \"eslint\": \"eslint src && eslint test\",\n    \"prepare\": \"ts-patch install && typia patch\",\n    \"test\": \"node bin/test\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"e2e\",\n    \"nestia\",\n    \"nestjs\",\n    \"test\",\n    \"tdd\",\n    \"utility\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"devDependencies\": {\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.0.0\",\n    \"@types/node\": \"^18.11.18\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.57.0\",\n    \"@typescript-eslint/parser\": \"^5.57.0\",\n    \"rimraf\": \"^6.0.1\",\n    \"ts-node\": \"^10.9.1\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typescript\": \"~5.9.2\",\n    \"typescript-transform-paths\": \"^3.4.7\",\n    \"typia\": \"^9.6.1\"\n  },\n  \"files\": [\n    \"lib\",\n    \"src\",\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\"\n  ]\n}",
+    "node_modules/@nestia/e2e/package.json": "{\n  \"name\": \"@nestia/e2e\",\n  \"version\": \"8.0.7\",\n  \"description\": \"E2E test utilify functions\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"npm run build:main && npm run build:test\",\n    \"build:main\": \"rimraf lib && tsc\",\n    \"build:test\": \"rimraf bin && tsc -p test/tsconfig.json\",\n    \"dev\": \"npm run build:test -- --watch\",\n    \"eslint\": \"eslint src && eslint test\",\n    \"prepare\": \"ts-patch install && typia patch\",\n    \"test\": \"node bin/test\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"e2e\",\n    \"nestia\",\n    \"nestjs\",\n    \"test\",\n    \"tdd\",\n    \"utility\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"devDependencies\": {\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.0.0\",\n    \"@types/node\": \"^18.11.18\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.57.0\",\n    \"@typescript-eslint/parser\": \"^5.57.0\",\n    \"rimraf\": \"^6.0.1\",\n    \"ts-node\": \"^10.9.1\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typescript\": \"~5.9.2\",\n    \"typescript-transform-paths\": \"^3.4.7\",\n    \"typia\": \"^9.6.1\"\n  },\n  \"files\": [\n    \"lib\",\n    \"src\",\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\"\n  ]\n}",
     "node_modules/@nestia/fetcher/lib/AesPkcs5.d.ts": "/**\n * Utility class for the AES-128/256 encryption.\n *\n * - AES-128/256\n * - CBC mode\n * - PKCS#5 Padding\n * - Base64 Encoding\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace AesPkcs5 {\n    /**\n     * Encrypt data\n     *\n     * @param data Target data\n     * @param key Key value of the encryption.\n     * @param iv Initializer Vector for the encryption\n     * @returns Encrypted data\n     */\n    function encrypt(data: string, key: string, iv: string): string;\n    /**\n     * Decrypt data.\n     *\n     * @param data Target data\n     * @param key Key value of the decryption.\n     * @param iv Initializer Vector for the decryption\n     * @returns Decrypted data.\n     */\n    function decrypt(data: string, key: string, iv: string): string;\n}\n",
     "node_modules/@nestia/fetcher/lib/EncryptedFetcher.d.ts": "import { IConnection } from \"./IConnection\";\nimport { IFetchRoute } from \"./IFetchRoute\";\nimport { IPropagation } from \"./IPropagation\";\n/**\n * Utility class for `fetch` functions used in `@nestia/sdk` with encryption.\n *\n * `EncryptedFetcher` is a utility class designed for SDK functions generated by\n * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote\n * HTTP API encrypted by AES-PKCS algorithm. In other words, this is a\n * collection of dedicated `fetch()` functions for `@nestia/sdk` with\n * encryption.\n *\n * For reference, `EncryptedFetcher` class being used only when target\n * controller method is encrypting body data by `@EncryptedRoute` or\n * `@EncryptedBody` decorators. If those decorators are not used,\n * {@link PlainFetcher} class would be used instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace EncryptedFetcher {\n    /**\n     * Fetch function only for `HEAD` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Nothing because of `HEAD` method\n     */\n    function fetch(connection: IConnection, route: IFetchRoute<\"HEAD\">): Promise<void>;\n    /**\n     * Fetch function only for `GET` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Output>(connection: IConnection, route: IFetchRoute<\"GET\">): Promise<Output>;\n    /**\n     * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Input, Output>(connection: IConnection, route: IFetchRoute<\"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n    function propagate<Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"GET\" | \"HEAD\">): Promise<Output>;\n    function propagate<Input, Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n}\n",
     "node_modules/@nestia/fetcher/lib/FormDataInput.d.ts": "/**\n * FormData input type.\n *\n * `FormDataInput<T>` is a type for the input of the `FormData` request, casting\n * `File` property value type as an union of `File` and\n * {@link FormDataInput.IFileProps}, especially for the React Native\n * environment.\n *\n * You know what? In the React Native environment, `File` class is not\n * supported. Therefore, when composing a `FormData` request, you have to put\n * the URI address of the local filesystem with file name and content type that\n * is represented by the {@link FormDataInput.IFileProps} type.\n *\n * This `FormDataInput<T>` type is designed for that purpose. If the property\n * value type is a `File` class, it converts it to an union type of `File` and\n * {@link FormDataInput.IFileProps} type. Also, if the property value type is an\n * array of `File` class, it converts it to an array of union type of `File` and\n * {@link FormDataInput.IFileProps} type too.\n *\n * Before | After ----------|------------------------ `boolean` | `boolean`\n * `bigint` | `bigint` `number` | `number` `string` | `string` `File` | `File \\|\n * IFileProps`\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target object type.\n */\nexport type FormDataInput<T extends object> = T extends Array<any> ? never : T extends Function ? never : {\n    [P in keyof T]: T[P] extends Array<infer U> ? FormDataInput.Value<U>[] : FormDataInput.Value<T[P]>;\n};\nexport declare namespace FormDataInput {\n    /**\n     * Value type of the `FormDataInput`.\n     *\n     * `Value<T>` is a type for the property value defined in the `FormDataInput`.\n     *\n     * If the original value type is a `File` class, `Value<T>` converts it to an\n     * union type of `File` and {@link IFileProps} type which is a structured data\n     * for the URI file location in the React Native environment.\n     */\n    type Value<T> = T extends File ? T | IFileProps : T;\n    /**\n     * Properties of a file.\n     *\n     * In the React Native, this `IFileProps` structured data can replace the\n     * `File` class instance in the `FormData` request.\n     *\n     * Just put the {@link uri URI address} of the local file system with the\n     * file's {@link name} and {@link type}. It would be casted to the `File` class\n     * instance automatically in the `FormData` request.\n     *\n     * Note that, this `IFileProps` type works only in the React Native\n     * environment. If you are developing a Web or NodeJS application, you have to\n     * utilize the `File` class instance directly.\n     */\n    interface IFileProps {\n        /**\n         * URI address of the file.\n         *\n         * In the React Native, the URI address in the local file system can replace\n         * the `File` class instance. If\n         *\n         * @format uri\n         */\n        uri: string;\n        /** Name of the file. */\n        name: string;\n        /** Content type of the file. */\n        type: string;\n    }\n}\n",
@@ -23,7 +23,7 @@
     "node_modules/@nestia/fetcher/lib/PlainFetcher.d.ts": "import { IConnection } from \"./IConnection\";\nimport { IFetchRoute } from \"./IFetchRoute\";\nimport { IPropagation } from \"./IPropagation\";\n/**\n * Utility class for `fetch` functions used in `@nestia/sdk`.\n *\n * `PlainFetcher` is a utility class designed for SDK functions generated by\n * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote\n * HTTP sever API. In other words, this is a collection of dedicated `fetch()`\n * functions for `@nestia/sdk`.\n *\n * For reference, `PlainFetcher` class does not encrypt or decrypt the body data\n * at all. It just delivers plain data without any post processing. If you've\n * defined a controller method through `@EncryptedRoute` or `@EncryptedBody`\n * decorator, then {@liink EncryptedFetcher} class would be used instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace PlainFetcher {\n    /**\n     * Fetch function only for `HEAD` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Nothing because of `HEAD` method\n     */\n    function fetch(connection: IConnection, route: IFetchRoute<\"HEAD\">): Promise<void>;\n    /**\n     * Fetch function only for `GET` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Output>(connection: IConnection, route: IFetchRoute<\"GET\">): Promise<Output>;\n    /**\n     * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Input, Output>(connection: IConnection, route: IFetchRoute<\"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n    function propagate<Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"GET\" | \"HEAD\">): Promise<Output>;\n    function propagate<Input, Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n}\n",
     "node_modules/@nestia/fetcher/lib/index.d.ts": "export * from \"./FormDataInput\";\nexport * from \"./HttpError\";\nexport * from \"./IConnection\";\nexport * from \"./IEncryptionPassword\";\nexport * from \"./IFetchEvent\";\nexport * from \"./IFetchRoute\";\nexport * from \"./IPropagation\";\n",
     "node_modules/@nestia/fetcher/lib/internal/FetcherBase.d.ts": "export {};\n",
-    "node_modules/@nestia/fetcher/package.json": "{\n  \"name\": \"@nestia/fetcher\",\n  \"version\": \"8.0.1\",\n  \"description\": \"Fetcher library of Nestia SDK\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"rimraf lib && tsc\",\n    \"dev\": \"tsc -p tsconfig.test.json --watch\",\n    \"eslint\": \"eslint src\",\n    \"eslint:fix\": \"eslint src --fix\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"nestia\",\n    \"fetcher\",\n    \"sdk\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"dependencies\": {\n    \"@samchon/openapi\": \"^4.5.0\"\n  },\n  \"devDependencies\": {\n    \"@types/node\": \"^18.11.14\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.46.1\",\n    \"@typescript-eslint/parser\": \"^5.46.1\",\n    \"rimraf\": \"^6.0.1\",\n    \"typescript\": \"~5.9.2\"\n  },\n  \"files\": [\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\",\n    \"lib\",\n    \"src\"\n  ]\n}",
+    "node_modules/@nestia/fetcher/package.json": "{\n  \"name\": \"@nestia/fetcher\",\n  \"version\": \"8.0.7\",\n  \"description\": \"Fetcher library of Nestia SDK\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"rimraf lib && tsc\",\n    \"dev\": \"tsc -p tsconfig.test.json --watch\",\n    \"eslint\": \"eslint src\",\n    \"eslint:fix\": \"eslint src --fix\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"nestia\",\n    \"fetcher\",\n    \"sdk\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"dependencies\": {\n    \"@samchon/openapi\": \"^4.5.0\"\n  },\n  \"devDependencies\": {\n    \"@types/node\": \"^18.11.14\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.46.1\",\n    \"@typescript-eslint/parser\": \"^5.46.1\",\n    \"rimraf\": \"^6.0.1\",\n    \"typescript\": \"~5.9.2\"\n  },\n  \"files\": [\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\",\n    \"lib\",\n    \"src\"\n  ]\n}",
     "node_modules/@samchon/openapi/lib/HttpLlm.d.ts": "import { OpenApi } from \"./OpenApi\";\nimport { OpenApiV3 } from \"./OpenApiV3\";\nimport { OpenApiV3_1 } from \"./OpenApiV3_1\";\nimport { SwaggerV2 } from \"./SwaggerV2\";\nimport { IHttpConnection } from \"./structures/IHttpConnection\";\nimport { IHttpLlmApplication } from \"./structures/IHttpLlmApplication\";\nimport { IHttpLlmFunction } from \"./structures/IHttpLlmFunction\";\nimport { IHttpResponse } from \"./structures/IHttpResponse\";\nimport { ILlmFunction } from \"./structures/ILlmFunction\";\nimport { ILlmSchema } from \"./structures/ILlmSchema\";\n/**\n * LLM function calling application composer from OpenAPI document.\n *\n * `HttpLlm` is a module for composing LLM (Large Language Model) function\n * calling application from the {@link OpenApi.IDocument OpenAPI document}, and\n * also for LLM function call execution and parameter merging.\n *\n * At first, you can construct the LLM function calling application by the\n * {@link HttpLlm.application HttpLlm.application()} function. And then the LLM\n * has selected a {@link IHttpLlmFunction function} to call and composes its\n * arguments, you can execute the function by\n * {@link HttpLlm.execute HttpLlm.execute()} or\n * {@link HttpLlm.propagate HttpLlm.propagate()}.\n *\n * By the way, if you have configured the\n * {@link IHttpLlmApplication.IOptions.separate} option to separate the\n * parameters into human and LLM sides, you can merge these human and LLM sides'\n * parameters into one through\n * {@link HttpLlm.mergeParameters HttpLlm.mergeParameters()} before the actual\n * LLM function call execution.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace HttpLlm {\n    /**\n     * Properties for the LLM function calling application composer.\n     *\n     * @template Model Target LLM model\n     */\n    interface IApplicationProps<Model extends ILlmSchema.Model> {\n        /** Target LLM model. */\n        model: Model;\n        /** OpenAPI document to convert. */\n        document: OpenApi.IDocument | SwaggerV2.IDocument | OpenApiV3.IDocument | OpenApiV3_1.IDocument;\n        /** Options for the LLM function calling schema conversion. */\n        options?: Partial<IHttpLlmApplication.IOptions<Model>>;\n    }\n    /**\n     * Convert OpenAPI document to LLM function calling application.\n     *\n     * Converts {@link OpenApi.IDocument OpenAPI document} or\n     * {@link IHttpMigrateApplication migrated application} to the\n     * {@link IHttpLlmApplication LLM function calling application}. Every\n     * {@link OpenApi.IOperation API operations} in the OpenAPI document are\n     * converted to the {@link IHttpLlmFunction LLM function} type, and they would\n     * be used for the LLM function calling.\n     *\n     * If you have configured the {@link IHttpLlmApplication.IOptions.separate}\n     * option, every parameters in the {@link IHttpLlmFunction} would be separated\n     * into both human and LLM sides. In that case, you can merge these human and\n     * LLM sides' parameters into one through {@link HttpLlm.mergeParameters}\n     * before the actual LLM function call execution.\n     *\n     * Additionally, if you have configured the\n     * {@link IHttpLlmApplication.IOptions.keyword} as `true`, the number of\n     * {@link IHttpLlmFunction.parameters} are always 1 and the first parameter\n     * type is always {@link ILlmSchemaV3.IObject}. I recommend this option because\n     * LLM can understand the keyword arguments more easily.\n     *\n     * @param props Properties for composition\n     * @returns LLM function calling application\n     */\n    const application: <Model extends ILlmSchema.Model>(props: IApplicationProps<Model>) => IHttpLlmApplication<Model>;\n    /** Properties for the LLM function call. */\n    interface IFetchProps<Model extends ILlmSchema.Model> {\n        /** Application of the LLM function calling. */\n        application: IHttpLlmApplication<Model>;\n        /** LLM function schema to call. */\n        function: IHttpLlmFunction<ILlmSchema.Model>;\n        /** Connection info to the HTTP server. */\n        connection: IHttpConnection;\n        /** Input arguments for the function call. */\n        input: object;\n    }\n    /**\n     * Execute the LLM function call.\n     *\n     * `HttmLlm.execute()` is a function executing the target\n     * {@link OpenApi.IOperation API endpoint} with with the connection information\n     * and arguments composed by Large Language Model like OpenAI (+human\n     * sometimes).\n     *\n     * By the way, if you've configured the\n     * {@link IHttpLlmApplication.IOptions.separate}, so that the parameters are\n     * separated to human and LLM sides, you have to merge these humand and LLM\n     * sides' parameters into one through {@link HttpLlm.mergeParameters}\n     * function.\n     *\n     * About the {@link IHttpLlmApplication.IOptions.keyword} option, don't worry\n     * anything. This `HttmLlm.execute()` function will automatically recognize\n     * the keyword arguments and convert them to the proper sequence.\n     *\n     * For reference, if the target API endpoinnt responds none 200/201 status,\n     * this would be considered as an error and the {@link HttpError} would be\n     * thrown. Otherwise you don't want such rule, you can use the\n     * {@link HttpLlm.propagate} function instead.\n     *\n     * @param props Properties for the LLM function call\n     * @returns Return value (response body) from the API endpoint\n     * @throws HttpError when the API endpoint responds none 200/201 status\n     */\n    const execute: <Model extends ILlmSchema.Model>(props: IFetchProps<Model>) => Promise<unknown>;\n    /**\n     * Propagate the LLM function call.\n     *\n     * `HttmLlm.propagate()` is a function propagating the target\n     * {@link OpenApi.IOperation API endpoint} with with the connection information\n     * and arguments composed by Large Language Model like OpenAI (+human\n     * sometimes).\n     *\n     * By the way, if you've configured the\n     * {@link IHttpLlmApplication.IOptions.separate}, so that the parameters are\n     * separated to human and LLM sides, you have to merge these humand and LLM\n     * sides' parameters into one through {@link HttpLlm.mergeParameters}\n     * function.\n     *\n     * About the {@link IHttpLlmApplication.IOptions.keyword} option, don't worry\n     * anything. This `HttmLlm.propagate()` function will automatically recognize\n     * the keyword arguments and convert them to the proper sequence.\n     *\n     * For reference, the propagation means always returning the response from the\n     * API endpoint, even if the status is not 200/201. This is useful when you\n     * want to handle the response by yourself.\n     *\n     * @param props Properties for the LLM function call\n     * @returns Response from the API endpoint\n     * @throws Error only when the connection is failed\n     */\n    const propagate: <Model extends ILlmSchema.Model>(props: IFetchProps<Model>) => Promise<IHttpResponse>;\n    /** Properties for the parameters' merging. */\n    interface IMergeProps<Model extends ILlmSchema.Model> {\n        /** Metadata of the target function. */\n        function: ILlmFunction<Model>;\n        /** Arguments composed by the LLM. */\n        llm: object | null;\n        /** Arguments composed by the human. */\n        human: object | null;\n    }\n    /**\n     * Merge the parameters.\n     *\n     * If you've configured the {@link IHttpLlmApplication.IOptions.separate}\n     * option, so that the parameters are separated to human and LLM sides, you\n     * can merge these humand and LLM sides' parameters into one through this\n     * `HttpLlm.mergeParameters()` function before the actual LLM function call\n     * wexecution.\n     *\n     * On contrary, if you've not configured the\n     * {@link IHttpLlmApplication.IOptions.separate} option, this function would\n     * throw an error.\n     *\n     * @param props Properties for the parameters' merging\n     * @returns Merged parameter values\n     */\n    const mergeParameters: <Model extends ILlmSchema.Model>(props: IMergeProps<Model>) => object;\n    /**\n     * Merge two values.\n     *\n     * If both values are objects, then combines them in the properties level.\n     *\n     * Otherwise, returns the latter value if it's not null, otherwise the former\n     * value.\n     *\n     * - `return (y ?? x)`\n     *\n     * @param x Value X to merge\n     * @param y Value Y to merge\n     * @returns Merged value\n     */\n    const mergeValue: (x: unknown, y: unknown) => unknown;\n}\n",
     "node_modules/@samchon/openapi/lib/HttpMigration.d.ts": "import { OpenApi } from \"./OpenApi\";\nimport { OpenApiV3 } from \"./OpenApiV3\";\nimport { OpenApiV3_1 } from \"./OpenApiV3_1\";\nimport { SwaggerV2 } from \"./SwaggerV2\";\nimport { IHttpConnection } from \"./structures/IHttpConnection\";\nimport { IHttpMigrateApplication } from \"./structures/IHttpMigrateApplication\";\nimport { IHttpMigrateRoute } from \"./structures/IHttpMigrateRoute\";\nimport { IHttpResponse } from \"./structures/IHttpResponse\";\n/**\n * HTTP migration application composer from OpenAPI document.\n *\n * `HttpMigration` is a module for composing HTTP migration application from the\n * {@link OpenApi.IDocument OpenAPI document}. It is designed for helping the\n * OpenAPI generator libraries, which converts\n * {@link OpenApi.IOperation OpenAPI operations} to an RPC (Remote Procedure\n * Call) function.\n *\n * The key feature of the `HttpModule` is the {@link HttpMigration.application}\n * function. It converts the {@link OpenApi.IOperation OpenAPI operations} to the\n * {@link IHttpMigrateRoute HTTP migration route}, and it normalizes the OpenAPI\n * operations to the RPC function calling suitable route structure.\n *\n * The other functions, {@link HttpMigration.execute} and\n * {@link HttpMigration.propagate}, are for executing the HTTP request to the\n * HTTP server. The {@link HttpMigration.execute} function returns the response\n * body from the API endpoint when the status code is `200` or `201`. Otherwise,\n * it throws an {@link HttpError} when the status code is not `200` or `201`. The\n * {@link HttpMigration.propagate} function returns the response information from\n * the API endpoint, including the status code, headers, and response body.\n *\n * The {@link HttpLlm} module is a good example utilizing this `HttpMigration`\n * module for composing RPC function calling application. The {@link HttpLlm}\n * module composes LLM (Large Language Model) function calling application from\n * the OpenAPI document bypassing through the {@link IHttpLlmApplication} type.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace HttpMigration {\n    /**\n     * Convert HTTP migration application from OpenAPI document.\n     *\n     * `HttpMigration.application()` is a function converting the\n     * {@link OpenApi.IDocument OpenAPI document} and its\n     * {@link OpenApi.IOperation operations} to the\n     * {@link IHttpMigrateApplication HTTP migration application}.\n     *\n     * The HTTP migration application is designed for helping the OpenAPI\n     * generator libraries, which converts OpenAPI operations to an RPC (Remote\n     * Procedure Call) function. To support the OpenAPI generator libraries,\n     * {@link IHttpMigrateRoute} takes below normalization rules:\n     *\n     * - Path parameters are separated to atomic level.\n     * - Query parameters are binded into one object.\n     * - Header parameters are binded into one object.\n     * - Allow only below HTTP methods\n     *\n     *   - `head`\n     *   - `get`\n     *   - `post`\n     *   - `put`\n     *   - `patch`\n     *   - `delete`\n     * - Allow only below content media types\n     *\n     *   - `application/json`\n     *   - `application/x-www-form-urlencoded`\n     *   - `multipart/form-data`\n     *   - `text/plain`\n     *\n     * If there're some {@link OpenApi.IOperation API operations} which canont\n     * adjust the above rules or there're some logically insensible, these\n     * operation would be failed to migrate and registered into the\n     * {@link IHttpMigrateApplication.errors}.\n     *\n     * @param document OpenAPI document to migrate.\n     * @returns Migrated application.\n     */\n    const application: (document: OpenApi.IDocument | SwaggerV2.IDocument | OpenApiV3.IDocument | OpenApiV3_1.IDocument) => IHttpMigrateApplication;\n    /** Properties for the request to the HTTP server. */\n    interface IFetchProps {\n        /** Connection info to the HTTP server. */\n        connection: IHttpConnection;\n        /** Route information for the migration. */\n        route: IHttpMigrateRoute;\n        /**\n         * Path parameters.\n         *\n         * Path parameters with sequenced array or key-value paired object.\n         */\n        parameters: Array<string | number | boolean | bigint | null> | Record<string, string | number | boolean | bigint | null>;\n        /** Query parameters as a key-value paired object. */\n        query?: object | undefined;\n        /** Request body data. */\n        body?: object | undefined;\n    }\n    /**\n     * Execute the HTTP request.\n     *\n     * `HttpMigration.execute()` is a function executing the HTTP request to the\n     * HTTP server.\n     *\n     * It returns the response body from the API endpoint when the status code is\n     * `200` or `201`. Otherwise, it throws an {@link HttpError} when the status\n     * code is not `200` or `201`.\n     *\n     * If you want to get more information than the response body, or get the\n     * detailed response information even when the status code is `200` or `201`,\n     * use the {@link HttpMigration.propagate} function instead.\n     *\n     * @param props Properties for the request.\n     * @returns Return value (response body) from the API endpoint.\n     * @throws HttpError when the API endpoint responds none 200/201 status.\n     */\n    const execute: (props: IFetchProps) => Promise<unknown>;\n    /**\n     * Propagate the HTTP request.\n     *\n     * `HttpMigration.propagate()` is a function propagating the request to the\n     * HTTP server.\n     *\n     * It returns the response information from the API endpoint, including the\n     * status code, headers, and response body.\n     *\n     * Even if the status code is not `200` or `201`, this function would return\n     * the response information. By the way, if the connection to the HTTP server\n     * is failed, this function would throw an {@link Error}.\n     *\n     * @param props Properties for the request.\n     * @returns Response from the API endpoint.\n     * @throws Error when the connection is failed.\n     */\n    const propagate: (props: IFetchProps) => Promise<IHttpResponse>;\n}\n",
     "node_modules/@samchon/openapi/lib/McpLlm.d.ts": "import { ILlmSchema } from \"./structures/ILlmSchema\";\nimport { IMcpLlmApplication } from \"./structures/IMcpLlmApplication\";\nimport { IMcpTool } from \"./structures/IMcpTool\";\n/**\n * Application of LLM function calling from MCP document.\n *\n * `McpLlm` is a module for composing LLM (Large Language Model) function\n * calling application from MCP (Model Context Protocol) document.\n *\n * The reasons why `@samchon/openapi` recommends to use the function calling\n * feature instead of directly using the\n * [`mcp_servers`](https://openai.github.io/openai-agents-python/mcp/#using-mcp-servers)\n * property of LLM API are:\n *\n * - Model Specification: {@link ILlmSchema}\n * - Validation Feedback: {@link IMcpLlmFunction.validate}\n * - Selector agent for reducing context: [Agentica > Orchestration\n *   Strategy](https://wrtnlabs.io/agentica/docs/concepts/function-calling/#orchestration-strategy)\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace McpLlm {\n    /**\n     * Properties for the LLM function calling application composer.\n     *\n     * @template Model Target LLM model\n     */\n    interface IApplicationProps<Model extends ILlmSchema.Model> {\n        /** Target LLM model. */\n        model: Model;\n        /**\n         * List of tools.\n         *\n         * A list of tools defined in the MCP (Model Context Protocol) document.\n         *\n         * It is better to validate the tools using the\n         * [`typia.assert<T>()`](https://typia.io/docs/validate/assert) function for\n         * type safety.\n         */\n        tools: Array<IMcpTool>;\n        /** Options for the LLM function calling schema conversion. */\n        options?: Partial<IMcpLlmApplication.IOptions<Model>>;\n    }\n    /**\n     * Convert MCP document to LLM function calling application.\n     *\n     * Converts MCP (Model Context Protocol) to LLM (Large Language Model)\n     * function calling application.\n     *\n     * The reasons why `@samchon/openapi` recommends using the function calling\n     * feature instead of directly using the\n     * [`mcp_servers`](https://openai.github.io/openai-agents-python/mcp/#using-mcp-servers)\n     * property of LLM API are:\n     *\n     * - **Model Specification**: {@link ILlmSchema}\n     * - **Validation Feedback**: {@link IMcpLlmFunction.validate}\n     * - **Selector agent for reducing context**: [Agentica > Orchestration\n     *   Strategy](https://wrtnlabs.io/agentica/docs/concepts/function-calling/#orchestration-strategy)\n     *\n     * @param props Properties for composition\n     * @returns LLM function calling application\n     */\n    const application: <Model extends ILlmSchema.Model>(props: IApplicationProps<Model>) => IMcpLlmApplication<Model>;\n}\n",

package/lib/realize/testRealizeProject.js

@@ -56,7 +56,7 @@ function setup(files, cwd) {
 }
 function test(props, listener, cwd) {
     return __awaiter(this, void 0, void 0, function* () {
-        const worker = new tgrid_1.WorkerConnector(null, listener, "thread");
+        const worker = new tgrid_1.WorkerConnector(null, listener, "process");
         yield worker.connect(`${cwd}/bin/test/servant.js`, {
             stdio: "ignore",
             cwd,

package/lib/realize/testRealizeProject.js.map

@@ -1 +1 @@
-{"version":3,"file":"testRealizeProject.js","sourceRoot":"","sources":["../../src/realize/testRealizeProject.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAcA,gDAiBC;AA/BD,mDAAwD;AAOxD,oDAA4B;AAC5B,4CAAoB;AACpB,4CAAoB;AACpB,iCAAgD;AAEhD,sDAAmD;AAEnD,SAAsB,kBAAkB,CACtC,KAA8B,EAC9B,QAAoC;;QAEpC,MAAM,GAAG,GAAW,GAAG,YAAE,CAAC,MAAM,EAAE,mBAAmB,gBAAM,CAAC,UAAU,EAAE,EAAE,CAAC;QAC3E,MAAM,YAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAC9B,OAAO,MAAM,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,YAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE;gBACxB,SAAS,EAAE,IAAI;gBACf,KAAK,EAAE,IAAI;aACZ,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CAAA;AAED,SAAe,KAAK,CAClB,KAA6B,EAC7B,GAAW;;QAEX,MAAM,+BAAkB,CAAC,IAAI,CAAC;YAC5B,IAAI,EAAE,GAAG;YACT,KAAK;SACN,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,CAAO,CAAS,EAAE,EAAE;YAC/B,OAAA,yBAAW,CAAC,IAAI,CAAC,CAAC,EAAE;gBAClB,GAAG;aACJ,CAAC,CAAA;UAAA,CAAC;QACL,MAAM,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3B,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC;QACpC,MAAM,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACpC,CAAC;CAAA;AAED,SAAe,IAAI,CACjB,KAA8B,EAC9B,QAAoC,EACpC,GAAW;;QAEX,MAAM,MAAM,GAIR,IAAI,uBAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAClD,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,GAAG,sBAAsB,EAAE;YACjD,KAAK,EAAE,QAAQ;YACf,GAAG;SACJ,CAAC,CAAC;QACH,MAAM,OAAO,GAAsC,MAAM,CAAC,SAAS,EAAE,CAAC;QACtE,IAAI,CAAC;YACH,MAAM,MAAM,GAA6B,MAAM,OAAO,CAAC,OAAO,CAAC;gBAC7D,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,YAAY,EAAE,KAAK,CAAC,YAAY;aACjC,CAAC,CAAC;YACH,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;CAAA"}
+{"version":3,"file":"testRealizeProject.js","sourceRoot":"","sources":["../../src/realize/testRealizeProject.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAcA,gDAiBC;AA/BD,mDAAwD;AAOxD,oDAA4B;AAC5B,4CAAoB;AACpB,4CAAoB;AACpB,iCAAgD;AAEhD,sDAAmD;AAEnD,SAAsB,kBAAkB,CACtC,KAA8B,EAC9B,QAAoC;;QAEpC,MAAM,GAAG,GAAW,GAAG,YAAE,CAAC,MAAM,EAAE,mBAAmB,gBAAM,CAAC,UAAU,EAAE,EAAE,CAAC;QAC3E,MAAM,YAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAC9B,OAAO,MAAM,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,YAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE;gBACxB,SAAS,EAAE,IAAI;gBACf,KAAK,EAAE,IAAI;aACZ,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CAAA;AAED,SAAe,KAAK,CAClB,KAA6B,EAC7B,GAAW;;QAEX,MAAM,+BAAkB,CAAC,IAAI,CAAC;YAC5B,IAAI,EAAE,GAAG;YACT,KAAK;SACN,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,CAAO,CAAS,EAAE,EAAE;YAC/B,OAAA,yBAAW,CAAC,IAAI,CAAC,CAAC,EAAE;gBAClB,GAAG;aACJ,CAAC,CAAA;UAAA,CAAC;QACL,MAAM,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3B,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC;QACpC,MAAM,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACpC,CAAC;CAAA;AAED,SAAe,IAAI,CACjB,KAA8B,EAC9B,QAAoC,EACpC,GAAW;;QAEX,MAAM,MAAM,GAIR,IAAI,uBAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QACnD,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,GAAG,sBAAsB,EAAE;YACjD,KAAK,EAAE,QAAQ;YACf,GAAG;SACJ,CAAC,CAAC;QACH,MAAM,OAAO,GAAsC,MAAM,CAAC,SAAS,EAAE,CAAC;QACtE,IAAI,CAAC;YACH,MAAM,MAAM,GAA6B,MAAM,OAAO,CAAC,OAAO,CAAC;gBAC7D,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,YAAY,EAAE,KAAK,CAAC,YAAY;aACjC,CAAC,CAAC;YACH,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobe/compiler",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "AI backend server code generator",
   "main": "lib/index.js",
   "author": "Wrtn Technologies",
@@ -13,14 +13,14 @@
     "url": "https://github.com/wrtnlabs/autobe/issues"
   },
   "dependencies": {
-    "@nestia/core": "^8.0.1",
-    "@nestia/migrate": "^8.0.1",
+    "@nestia/core": "^8.0.7",
+    "@nestia/migrate": "^8.0.7",
     "@samchon/openapi": "^4.7.1",
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
     "@typescript-eslint/eslint-plugin": "8.40.0",
     "@typescript-eslint/parser": "8.40.0",
     "embed-eslint": "^2.0.1",
-    "embed-prisma": "^1.1.0",
+    "embed-prisma": "^1.1.1",
     "embed-typescript": "^2.0.1",
     "eslint": "^9.34.0",
     "import2": "^1.0.3",
@@ -30,9 +30,9 @@
     "tgrid": "^1.2.0",
     "tstl": "^3.0.0",
     "typia": "^9.7.2",
-    "@autobe/filesystem": "^0.21.0",
-    "@autobe/interface": "^0.21.0",
-    "@autobe/utils": "^0.21.0"
+    "@autobe/interface": "^0.22.1",
+    "@autobe/filesystem": "^0.22.1",
+    "@autobe/utils": "^0.22.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",

package/src/prisma/writePrismaApplication.ts

@@ -392,7 +392,7 @@ const POSTGRES_MAIN_FILE = StringUtil.trim`
   }
   generator markdown {
     provider = "prisma-markdown"
-    output   = "../docs/ERD.md"
+    output   = "../../docs/ERD.md"
   }
 `;
 const SQLITE_MAIN_FILE = StringUtil.trim`
@@ -405,7 +405,7 @@ const SQLITE_MAIN_FILE = StringUtil.trim`
   }
   generator markdown {
     provider = "prisma-markdown"
-    output   = "../docs/ERD.md"
+    output   = "../../docs/ERD.md"
   }
 `;
 const MAX_IDENTIFIER_LENGTH = 63;

package/src/raw/AutoBeCompilerRealizeTemplate.ts

@@ -1,13 +1,13 @@
 export const AutoBeCompilerRealizeTemplate: Record<string, string> = {
   ".env.local": "API_PORT=37001\nJWT_SECRET_KEY=your_jwt_secret_key",
   ".gitignore": "bin/\ndist/\nlib/\nnode_modules/\n\nprisma/migrations\nprisma/schema/migrations\nprisma/bbs.db\n\n*.DS_Store\npackage-lock.json\npnpm-lock.yaml\n.npmrc",
-  "package.json": "{\n  \"private\": true,\n  \"name\": \"@ORGANIZATION/PROJECT\",\n  \"version\": \"0.1.0\",\n  \"description\": \"Starter kit of Nestia\",\n  \"main\": \"lib/index.js\",\n  \"scripts\": {\n    \"benchmark\": \"node bin/test/benchmark\",\n    \"test\": \"node bin/test\",\n    \"test:webpack\": \"npm run webpack && node bin/test/webpack.js\",\n    \"------------------------BUILDS------------------------\": \"\",\n    \"build\": \"npm run build:prisma && npm run build:sdk && npm run build:main && npm run build:test\",\n    \"build:api\": \"rimraf packages/api/lib && nestia all && rimraf packages/api/lib && tsc -p packages/api/tsconfig.json && rollup -c packages/api/rollup.config.js\",\n    \"build:env\": \"ts-node build/env.ts\",\n    \"build:main\": \"rimraf lib && tsc\",\n    \"build:sdk\": \"rimraf src/api/functional && nestia sdk\",\n    \"build:prisma\": \"prisma generate --schema prisma/schema\",\n    \"build:swagger\": \"nestia swagger\",\n    \"build:test\": \"rimraf bin && tsc -p test/tsconfig.json\",\n    \"dev\": \"npm run build:test -- --watch\",\n    \"eslint\": \"eslint src && eslint test\",\n    \"eslint:fix\": \"eslint --fix src && eslint --fix test\",\n    \"prepare\": \"ts-patch install && npm run build:env && npm run build:prisma\",\n    \"prettier\": \"prettier src --write && prettier test --write\",\n    \"------------------------WEBPACK------------------------\": \"\",\n    \"webpack\": \"rimraf dist && webpack\",\n    \"webpack:start\": \"cd dist && node dist/server\",\n    \"webpack:test\": \"npm run webpack && node bin/test/webpack.js\",\n    \"------------------------DEPLOYS------------------------\": \"\",\n    \"package:api\": \"npm run build:api && cd packages/api && npm publish\",\n    \"start\": \"node lib/executable/server\",\n    \"start:dev\": \"nest start --watch\",\n    \"start:swagger\": \"ts-node src/executable/swagger.ts\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia-start\"\n  },\n  \"keywords\": [\n    \"nestia\",\n    \"template\",\n    \"boilerplate\"\n  ],\n  \"author\": \"AUTHOR\",\n  \"license\": \"AGPL-3.0\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia-start/issues\"\n  },\n  \"homepage\": \"https://github.com/samchon/nestia-start#readme\",\n  \"devDependencies\": {\n    \"@autobe/interface\": \"^0.10.6\",\n    \"@nestia/benchmark\": \"^8.0.1\",\n    \"@nestia/e2e\": \"^8.0.1\",\n    \"@nestia/sdk\": \"^8.0.1\",\n    \"@nestjs/cli\": \"^11.0.7\",\n    \"@rollup/plugin-terser\": \"^0.4.4\",\n    \"@rollup/plugin-typescript\": \"^11.1.6\",\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.3.0\",\n    \"@types/bcryptjs\": \"^3.0.0\",\n    \"@types/cli\": \"^0.11.21\",\n    \"@types/cli-progress\": \"^3.11.5\",\n    \"@types/express\": \"^4.17.21\",\n    \"@types/inquirer\": \"^8.2.5\",\n    \"@types/jsonwebtoken\": \"^9.0.5\",\n    \"@types/node\": \"^18.11.0\",\n    \"@types/uuid\": \"^8.3.4\",\n    \"@typescript-eslint/eslint-plugin\": \"^8.1.0\",\n    \"@typescript-eslint/parser\": \"^8.1.0\",\n    \"chalk\": \"^4.1.2\",\n    \"cli\": \"^1.0.1\",\n    \"cli-progress\": \"^3.12.0\",\n    \"copy-webpack-plugin\": \"^11.0.0\",\n    \"eslint-plugin-deprecation\": \"^3.0.0\",\n    \"express\": \"^4.18.2\",\n    \"fastify\": \"^5.4.0\",\n    \"nestia\": \"^8.0.1\",\n    \"prettier\": \"^3.2.4\",\n    \"prettier-plugin-prisma\": \"^5.0.0\",\n    \"prisma-markdown\": \"^3.0.1\",\n    \"rimraf\": \"^3.0.2\",\n    \"rollup\": \"^4.18.0\",\n    \"source-map-support\": \"^0.5.21\",\n    \"swagger-ui-express\": \"^5.0.0\",\n    \"ts-loader\": \"^9.5.1\",\n    \"ts-node\": \"^10.9.1\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typescript\": \"~5.9.2\",\n    \"typescript-transform-paths\": \"^3.5.5\",\n    \"webpack\": \"^5.89.0\",\n    \"webpack-cli\": \"^5.1.4\",\n    \"write-file-webpack-plugin\": \"^4.5.1\"\n  },\n  \"dependencies\": {\n    \"@nestia/core\": \"^8.0.1\",\n    \"@nestia/fetcher\": \"^8.0.1\",\n    \"@nestjs/common\": \"^11.1.3\",\n    \"@nestjs/core\": \"^11.1.3\",\n    \"@nestjs/platform-express\": \"^11.1.3\",\n    \"@nestjs/platform-fastify\": \"^11.1.3\",\n    \"@prisma/client\": \"^6.11.1\",\n    \"bcryptjs\": \"^3.0.2\",\n    \"commander\": \"10.0.0\",\n    \"dotenv\": \"^16.3.1\",\n    \"dotenv-expand\": \"^10.0.0\",\n    \"inquirer\": \"8.2.5\",\n    \"jsonwebtoken\": \"^9.0.2\",\n    \"prisma\": \"^6.11.1\",\n    \"serialize-error\": \"^4.1.0\",\n    \"tgrid\": \"^1.1.0\",\n    \"tstl\": \"^3.0.0\",\n    \"typia\": \"^9.7.2\",\n    \"uuid\": \"^9.0.0\"\n  },\n  \"stackblitz\": {\n    \"startCommand\": \"npm run prepare && npm run build:test && npm run test -- --simultaneous 1\"\n  }\n}\n",
+  "package.json": "{\n  \"private\": true,\n  \"name\": \"@ORGANIZATION/PROJECT\",\n  \"version\": \"0.1.0\",\n  \"description\": \"Starter kit of Nestia\",\n  \"main\": \"lib/index.js\",\n  \"scripts\": {\n    \"benchmark\": \"node bin/test/benchmark\",\n    \"test\": \"node bin/test\",\n    \"test:webpack\": \"npm run webpack && node bin/test/webpack.js\",\n    \"------------------------BUILDS------------------------\": \"\",\n    \"build\": \"npm run build:prisma && npm run build:sdk && npm run build:main && npm run build:test\",\n    \"build:api\": \"rimraf packages/api/lib && nestia all && rimraf packages/api/lib && tsc -p packages/api/tsconfig.json && rollup -c packages/api/rollup.config.js\",\n    \"build:env\": \"ts-node build/env.ts\",\n    \"build:main\": \"rimraf lib && tsc\",\n    \"build:sdk\": \"rimraf src/api/functional && nestia sdk\",\n    \"build:prisma\": \"prisma generate --schema prisma/schema\",\n    \"build:swagger\": \"nestia swagger\",\n    \"build:test\": \"rimraf bin && tsc -p test/tsconfig.json\",\n    \"dev\": \"npm run build:test -- --watch\",\n    \"eslint\": \"eslint src && eslint test\",\n    \"eslint:fix\": \"eslint --fix src && eslint --fix test\",\n    \"prepare\": \"ts-patch install && npm run build:env && npm run build:prisma\",\n    \"prettier\": \"prettier src --write && prettier test --write\",\n    \"------------------------WEBPACK------------------------\": \"\",\n    \"webpack\": \"rimraf dist && webpack\",\n    \"webpack:start\": \"cd dist && node dist/server\",\n    \"webpack:test\": \"npm run webpack && node bin/test/webpack.js\",\n    \"------------------------DEPLOYS------------------------\": \"\",\n    \"package:api\": \"npm run build:api && cd packages/api && npm publish\",\n    \"start\": \"node lib/executable/server\",\n    \"start:dev\": \"nest start --watch\",\n    \"start:swagger\": \"ts-node src/executable/swagger.ts\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia-start\"\n  },\n  \"keywords\": [\n    \"nestia\",\n    \"template\",\n    \"boilerplate\"\n  ],\n  \"author\": \"AUTHOR\",\n  \"license\": \"AGPL-3.0\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia-start/issues\"\n  },\n  \"homepage\": \"https://github.com/samchon/nestia-start#readme\",\n  \"devDependencies\": {\n    \"@autobe/interface\": \"^0.10.6\",\n    \"@nestia/benchmark\": \"^8.0.7\",\n    \"@nestia/e2e\": \"^8.0.7\",\n    \"@nestia/sdk\": \"^8.0.7\",\n    \"@nestjs/cli\": \"^11.0.7\",\n    \"@rollup/plugin-terser\": \"^0.4.4\",\n    \"@rollup/plugin-typescript\": \"^11.1.6\",\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.3.0\",\n    \"@types/bcryptjs\": \"^3.0.0\",\n    \"@types/cli\": \"^0.11.21\",\n    \"@types/cli-progress\": \"^3.11.5\",\n    \"@types/express\": \"^4.17.21\",\n    \"@types/inquirer\": \"^8.2.5\",\n    \"@types/jsonwebtoken\": \"^9.0.5\",\n    \"@types/node\": \"^18.11.0\",\n    \"@types/uuid\": \"^8.3.4\",\n    \"@typescript-eslint/eslint-plugin\": \"^8.1.0\",\n    \"@typescript-eslint/parser\": \"^8.1.0\",\n    \"chalk\": \"^4.1.2\",\n    \"cli\": \"^1.0.1\",\n    \"cli-progress\": \"^3.12.0\",\n    \"copy-webpack-plugin\": \"^11.0.0\",\n    \"eslint-plugin-deprecation\": \"^3.0.0\",\n    \"express\": \"^4.18.2\",\n    \"fastify\": \"^5.4.0\",\n    \"nestia\": \"^8.0.7\",\n    \"prettier\": \"^3.2.4\",\n    \"prettier-plugin-prisma\": \"^5.0.0\",\n    \"prisma-markdown\": \"^3.0.1\",\n    \"rimraf\": \"^3.0.2\",\n    \"rollup\": \"^4.18.0\",\n    \"source-map-support\": \"^0.5.21\",\n    \"swagger-ui-express\": \"^5.0.0\",\n    \"ts-loader\": \"^9.5.1\",\n    \"ts-node\": \"^10.9.1\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typescript\": \"~5.9.2\",\n    \"typescript-transform-paths\": \"^3.5.5\",\n    \"webpack\": \"^5.89.0\",\n    \"webpack-cli\": \"^5.1.4\",\n    \"write-file-webpack-plugin\": \"^4.5.1\"\n  },\n  \"dependencies\": {\n    \"@nestia/core\": \"^8.0.7\",\n    \"@nestia/fetcher\": \"^8.0.7\",\n    \"@nestjs/common\": \"^11.1.3\",\n    \"@nestjs/core\": \"^11.1.3\",\n    \"@nestjs/platform-express\": \"^11.1.3\",\n    \"@nestjs/platform-fastify\": \"^11.1.3\",\n    \"@prisma/client\": \"^6.11.1\",\n    \"bcryptjs\": \"^3.0.2\",\n    \"commander\": \"10.0.0\",\n    \"dotenv\": \"^16.3.1\",\n    \"dotenv-expand\": \"^10.0.0\",\n    \"inquirer\": \"8.2.5\",\n    \"jsonwebtoken\": \"^9.0.2\",\n    \"prisma\": \"^6.11.1\",\n    \"serialize-error\": \"^4.1.0\",\n    \"tgrid\": \"^1.1.0\",\n    \"tstl\": \"^3.0.0\",\n    \"typia\": \"^9.7.2\",\n    \"uuid\": \"^9.0.0\"\n  },\n  \"stackblitz\": {\n    \"startCommand\": \"npm run prepare && npm run build:test && npm run test -- --simultaneous 1\"\n  }\n}\n",
   "src/MyGlobal.ts": "import { PrismaClient } from \"@prisma/client\";\nimport crypto from \"crypto\";\nimport dotenv from \"dotenv\";\nimport dotenvExpand from \"dotenv-expand\";\nimport { Singleton } from \"tstl\";\nimport typia from \"typia\";\n\n/* eslint-disable */\nexport class MyGlobal {\n  public static readonly prisma: PrismaClient = new PrismaClient();\n  public static testing: boolean = false;\n  public static get env(): MyGlobal.IEnvironments {\n    return environments.get();\n  }\n\n  /**\n   * Common password utilities for consistent authentication Uses native crypto\n   * module for password hashing\n   */\n  public static readonly password = {\n    // Fixed salt for password hashing (consistent across all operations)\n    FIXED_SALT: \"autobe-fixed-salt-2024\",\n\n    /**\n     * Hash a plain password using crypto.pbkdf2 All authentication operations\n     * (join, login) MUST use this method\n     *\n     * @param plainPassword - The plain text password to hash\n     * @returns The hashed password as hex string\n     */\n    async hash(plainPassword: string): Promise<string> {\n      return new Promise((resolve, reject) => {\n        crypto.pbkdf2(\n          plainPassword,\n          this.FIXED_SALT,\n          10000,\n          64,\n          \"sha512\",\n          (err: Error | null, derivedKey: Buffer) => {\n            if (err) reject(err);\n            else resolve(derivedKey.toString(\"hex\"));\n          },\n        );\n      });\n    },\n\n    /**\n     * Verify a plain password against a hashed password Login operations MUST\n     * use this method for password verification\n     *\n     * @param plainPassword - The plain text password to verify\n     * @param hashedPassword - The hashed password from database\n     * @returns True if passwords match, false otherwise\n     */\n    async verify(\n      plainPassword: string,\n      hashedPassword: string,\n    ): Promise<boolean> {\n      const hash = await this.hash(plainPassword);\n      return hash === hashedPassword;\n    },\n  };\n}\nexport namespace MyGlobal {\n  export interface IEnvironments {\n    API_PORT: `${number}`;\n\n    /** JWT Secret Key. */\n    JWT_SECRET_KEY: string;\n  }\n}\nconst environments = new Singleton(() => {\n  const env = dotenv.config();\n  dotenvExpand.expand(env);\n  return typia.assert<MyGlobal.IEnvironments>(process.env);\n});\n",
   "src/providers/authorize/jwtAuthorize.ts": "import { ForbiddenException, UnauthorizedException } from \"@nestjs/common\";\nimport jwt from \"jsonwebtoken\";\n\nimport { MyGlobal } from \"../../MyGlobal\";\n\nexport function jwtAuthorize(props: {\n  request: {\n    headers: { authorization?: string };\n  };\n}) {\n  if (!props.request.headers.authorization)\n    throw new ForbiddenException(\"No token value exists\");\n\n  // PARSE TOKEN\n  try {\n    if (\n      props.request.headers.authorization.startsWith(BEARER_PREFIX) === true\n    ) {\n      const token: string = props.request.headers.authorization.substring(\n        BEARER_PREFIX.length,\n      );\n\n      const verified = jwt.verify(token, MyGlobal.env.JWT_SECRET_KEY);\n\n      return verified;\n    } else {\n      const token = props.request.headers.authorization;\n\n      const verified = jwt.verify(token, MyGlobal.env.JWT_SECRET_KEY);\n\n      return verified;\n    }\n  } catch {\n    throw new UnauthorizedException(\"Invalid token\");\n  }\n}\n\nconst BEARER_PREFIX = \"Bearer \";\n",
   "src/setup/MySetupWizard.ts": "import cp from \"child_process\";\n\nimport { MyConfiguration } from \"../MyConfiguration\";\nimport { MyGlobal } from \"../MyGlobal\";\n\nexport namespace MySetupWizard {\n  export async function schema(): Promise<void> {\n    if (MyGlobal.testing === false)\n      throw new Error(\n        \"Error on SetupWizard.schema(): unable to reset database in non-test mode.\",\n      );\n    const execute = (type: string) => (argv: string) =>\n      cp.execSync(`npx prisma migrate ${type} --schema=prisma/schema ${argv}`, {\n        stdio: \"ignore\",\n        cwd: MyConfiguration.ROOT,\n      });\n    execute(\"reset\")(\"--force\");\n    execute(\"dev\")(\"--name init\");\n  }\n\n  export async function seed(): Promise<void> {}\n}\n",
   "src/util/toISOStringSafe.ts": "import { tags } from \"typia\";\n\n/**\n * Transforms a value that is either a Date or a string into an ISO 8601\n * formatted string. If it's already a string, it assumes it's already in ISO\n * format.\n */\nexport function toISOStringSafe(\n  value: Date | (string & tags.Format<\"date-time\">),\n): string & tags.Format<\"date-time\"> {\n  if (value instanceof Date) {\n    return value.toISOString() as string & tags.Format<\"date-time\">;\n  }\n  return value;\n}\n",
   "test/servant.ts": "import { DynamicExecutor } from \"@nestia/e2e\";\nimport { Driver, WorkerServer } from \"tgrid\";\n\nimport { MyBackend } from \"../src/MyBackend\";\nimport { MyGlobal } from \"../src/MyGlobal\";\nimport { IAutoBeRealizeTestConfig } from \"./autobe/compiler/IAutoBeRealizeTestConfig\";\nimport { IAutoBeRealizeTestListener } from \"./autobe/compiler/IAutoBeRealizeTestListener\";\nimport { IAutoBeRealizeTestOperation } from \"./autobe/compiler/IAutoBeRealizeTestOperation\";\nimport { IAutoBeRealizeTestResult } from \"./autobe/compiler/IAutoBeRealizeTestResult\";\nimport { IAutoBeRealizeTestService } from \"./autobe/compiler/IAutoBeRealizeTestService\";\nimport { TestAutomation } from \"./helpers/TestAutomation\";\n\nclass AutoBeRealizeTestService implements IAutoBeRealizeTestService {\n  public constructor(\n    private readonly listener: Driver<IAutoBeRealizeTestListener>,\n  ) {}\n\n  public async execute(\n    config: IAutoBeRealizeTestConfig,\n  ): Promise<IAutoBeRealizeTestResult> {\n    const start: Date = new Date();\n    const operations: IAutoBeRealizeTestOperation[] = [];\n    await TestAutomation.execute({\n      open: async (): Promise<MyBackend> => {\n        const backend: MyBackend = new MyBackend();\n        await backend.open();\n        return backend;\n      },\n      close: (backend: MyBackend): Promise<void> => backend.close(),\n      options: {\n        reset: config.reset ?? true,\n        simultaneous: config.simultaneous ?? 1,\n      },\n      onComplete: (exec: DynamicExecutor.IExecution): void => {\n        const op: IAutoBeRealizeTestOperation = {\n          name: exec.name,\n          location: exec.location,\n          value: exec.value,\n          error: exec.error,\n          started_at: exec.started_at,\n          completed_at: exec.completed_at,\n        };\n        this.listener.onOperation(op).catch(() => {});\n        operations.push(op);\n      },\n      onReset: (): void => {\n        this.listener.onReset().catch(() => {});\n      },\n    });\n    return {\n      reset: config.reset ?? true,\n      simultaneous: config.simultaneous ?? 1,\n      operations,\n      started_at: start.toISOString(),\n      completed_at: new Date().toISOString(),\n    };\n  }\n}\n\nconst main = async (): Promise<void> => {\n  const worker: WorkerServer<\n    null,\n    IAutoBeRealizeTestService,\n    IAutoBeRealizeTestListener\n  > = new WorkerServer();\n  const listener: Driver<IAutoBeRealizeTestListener> = worker.getDriver();\n  const service: AutoBeRealizeTestService = new AutoBeRealizeTestService(\n    listener,\n  );\n\n  MyGlobal.testing = true;\n  await worker.open(service);\n};\nmain().catch((error) => {\n  console.log(error);\n  process.exit(-1);\n});\n",
-  "tsconfig.json": "{\n  \"compilerOptions\": {\n    /* Visit https://aka.ms/tsconfig to read more about this file */\n\n    /* Projects */\n    // \"incremental\": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */\n    // \"composite\": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */\n    // \"tsBuildInfoFile\": \"./.tsbuildinfo\",              /* Specify the path to .tsbuildinfo incremental compilation file. */\n    // \"disableSourceOfProjectReferenceRedirect\": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */\n    // \"disableSolutionSearching\": true,                 /* Opt a project out of multi-project reference checking when editing. */\n    // \"disableReferencedProjectLoad\": true,             /* Reduce the number of projects loaded automatically by TypeScript. */\n\n    /* Language and Environment */\n    \"target\": \"ES2015\",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */\n    // \"lib\": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */\n    // \"jsx\": \"preserve\",                                /* Specify what JSX code is generated. */\n    \"experimentalDecorators\": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */\n    \"emitDecoratorMetadata\": true,                    /* Emit design-type metadata for decorated declarations in source files. */\n    // \"jsxFactory\": \"\",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */\n    // \"jsxFragmentFactory\": \"\",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */\n    // \"jsxImportSource\": \"\",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */\n    // \"reactNamespace\": \"\",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */\n    // \"noLib\": true,                                    /* Disable including any library files, including the default lib.d.ts. */\n    // \"useDefineForClassFields\": true,                  /* Emit ECMAScript-standard-compliant class fields. */\n    // \"moduleDetection\": \"auto\",                        /* Control what method is used to detect module-format JS files. */\n\n    /* Modules */\n    \"module\": \"commonjs\",                                /* Specify what module code is generated. */\n    // \"rootDir\": \"./\",                                  /* Specify the root folder within your source files. */\n    // \"moduleResolution\": \"node\",                       /* Specify how TypeScript looks up a file from a given module specifier. */\n    // \"baseUrl\": \"./\",                                  /* Specify the base directory to resolve non-relative module names. */\n    \"paths\": {\n      \"@ORGANIZATION/PROJECT-api/lib/*\": [\"./src/api/*\"],\n      \"@ORGANIZATION/PROJECT-api\": [\"./src/api\"],\n    },                                      /* Specify a set of entries that re-map imports to additional lookup locations. */\n    // \"rootDirs\": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */\n    // \"typeRoots\": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */\n    // \"types\": [],                                      /* Specify type package names to be included without being referenced in a source file. */\n    // \"allowUmdGlobalAccess\": true,                     /* Allow accessing UMD globals from modules. */\n    // \"moduleSuffixes\": [],                             /* List of file name suffixes to search when resolving a module. */\n    // \"resolveJsonModule\": true,                        /* Enable importing .json files. */\n    // \"noResolve\": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */\n\n    /* JavaScript Support */\n    // \"allowJs\": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */\n    // \"checkJs\": true,                                  /* Enable error reporting in type-checked JavaScript files. */\n    // \"maxNodeModuleJsDepth\": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */\n\n    /* Emit */\n    // \"declaration\": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */\n    // \"declarationMap\": true,                           /* Create sourcemaps for d.ts files. */\n    // \"emitDeclarationOnly\": true,                      /* Only output d.ts files and not JavaScript files. */\n    \"sourceMap\": true,                                /* Create source map files for emitted JavaScript files. */\n    // \"outFile\": \"./\",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */\n    \"outDir\": \"./lib\",                                   /* Specify an output folder for all emitted files. */\n    // \"removeComments\": true,                           /* Disable emitting comments. */\n    // \"noEmit\": true,                                   /* Disable emitting files from a compilation. */\n    // \"importHelpers\": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */\n    // \"importsNotUsedAsValues\": \"remove\",               /* Specify emit/checking behavior for imports that are only used for types. */\n    // \"downlevelIteration\": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */\n    // \"sourceRoot\": \"\",                                 /* Specify the root path for debuggers to find the reference source code. */\n    // \"mapRoot\": \"\",                                    /* Specify the location where debugger should locate map files instead of generated locations. */\n    // \"inlineSourceMap\": true,                          /* Include sourcemap files inside the emitted JavaScript. */\n    // \"inlineSources\": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */\n    // \"emitBOM\": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */\n    \"newLine\": \"lf\",                                /* Set the newline character for emitting files. */\n    \"stripInternal\": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */\n    // \"noEmitHelpers\": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */\n    // \"noEmitOnError\": true,                            /* Disable emitting files if any type checking errors are reported. */\n    // \"preserveConstEnums\": true,                       /* Disable erasing 'const enum' declarations in generated code. */\n    // \"declarationDir\": \"./\",                           /* Specify the output directory for generated declaration files. */\n    // \"preserveValueImports\": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */\n\n    /* Interop Constraints */\n    // \"isolatedModules\": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */\n    // \"allowSyntheticDefaultImports\": true,             /* Allow 'import x from y' when a module doesn't have a default export. */\n    \"esModuleInterop\": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */\n    // \"preserveSymlinks\": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */\n    \"forceConsistentCasingInFileNames\": true,            /* Ensure that casing is correct in imports. */\n\n    /* Type Checking */\n    \"strict\": true,                                      /* Enable all strict type-checking options. */\n    // \"noImplicitAny\": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */\n    // \"strictNullChecks\": true,                         /* When type checking, take into account 'null' and 'undefined'. */\n    // \"strictFunctionTypes\": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */\n    // \"strictBindCallApply\": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */\n    // \"strictPropertyInitialization\": true,             /* Check for class properties that are declared but not set in the constructor. */\n    // \"noImplicitThis\": true,                           /* Enable error reporting when 'this' is given the type 'any'. */\n    // \"useUnknownInCatchVariables\": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */\n    // \"alwaysStrict\": true,                             /* Ensure 'use strict' is always emitted. */\n    \"noUnusedLocals\": false,                           /* Enable error reporting when local variables aren't read. */\n    \"noUnusedParameters\": false,                       /* Raise an error when a function parameter isn't read. */\n    // \"exactOptionalPropertyTypes\": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */\n    \"noImplicitReturns\": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */\n    \"noFallthroughCasesInSwitch\": true,               /* Enable error reporting for fallthrough cases in switch statements. */\n    // \"noUncheckedIndexedAccess\": true,                 /* Add 'undefined' to a type when accessed using an index. */\n    // \"noImplicitOverride\": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */\n    // \"noPropertyAccessFromIndexSignature\": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */\n    // \"allowUnusedLabels\": true,                        /* Disable error reporting for unused labels. */\n    // \"allowUnreachableCode\": true,                     /* Disable error reporting for unreachable code. */\n\n    /* Completeness */\n    // \"skipDefaultLibCheck\": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */\n    \"skipLibCheck\": true,                                 /* Skip type checking all .d.ts files. */\n    \"plugins\": [\n      { \"transform\": \"typescript-transform-paths\" },\n      { \"transform\": \"typia/lib/transform\" },\n      { \n        \"transform\": \"@nestia/core/lib/transform\",\n        /**\n         * Validate request body.\n         * \n         *   - \"assert\": Use typia.assert() function\n         *   - \"is\": Use typia.is() function\n         *   - \"validate\": Use typia.validate() function\n         *   - \"assertEquals\": Use typia.assertEquals() function\n         *   - \"equals\": Use typia.equals() function\n         *   - \"validateEquals\": Use typia.validateEquals() function\n         */\n        \"validate\": \"validate\",\n        /**\n         * Validate JSON typed response body.\n         * \n         *   - \"assert\": Use typia.assertStringify() function\n         *   - \"is\": Use typia.isStringify() function\n         *   - \"validate\": Use typia.validateStringify() function\n         *   - \"validate.log\": typia.validateStringify(), but do not throw and just log it\n         *   - \"stringify\": Use typia.stringify() function, but dangerous\n         *   - null: Just use JSON.stringify() function, without boosting\n         */\n        \"stringify\": \"assert\",\n      },\n    ]\n  },\n  \"include\": [\n    \"src\"\n  ],\n  \"exclude\": [\n    \"node_modules\",\n    \"packages\",\n  ]\n}\n",
+  "tsconfig.json": "{\n  \"compilerOptions\": {\n    /* Visit https://aka.ms/tsconfig to read more about this file */\n\n    /* Projects */\n    // \"incremental\": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */\n    // \"composite\": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */\n    // \"tsBuildInfoFile\": \"./.tsbuildinfo\",              /* Specify the path to .tsbuildinfo incremental compilation file. */\n    // \"disableSourceOfProjectReferenceRedirect\": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */\n    // \"disableSolutionSearching\": true,                 /* Opt a project out of multi-project reference checking when editing. */\n    // \"disableReferencedProjectLoad\": true,             /* Reduce the number of projects loaded automatically by TypeScript. */\n\n    /* Language and Environment */\n    \"target\": \"ES2015\",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */\n    \"lib\": [\n      \"DOM\",\n      \"ESNext\",\n    ],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */\n    // \"jsx\": \"preserve\",                                /* Specify what JSX code is generated. */\n    \"experimentalDecorators\": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */\n    \"emitDecoratorMetadata\": true,                    /* Emit design-type metadata for decorated declarations in source files. */\n    // \"jsxFactory\": \"\",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */\n    // \"jsxFragmentFactory\": \"\",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */\n    // \"jsxImportSource\": \"\",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */\n    // \"reactNamespace\": \"\",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */\n    // \"noLib\": true,                                    /* Disable including any library files, including the default lib.d.ts. */\n    // \"useDefineForClassFields\": true,                  /* Emit ECMAScript-standard-compliant class fields. */\n    // \"moduleDetection\": \"auto\",                        /* Control what method is used to detect module-format JS files. */\n\n    /* Modules */\n    \"module\": \"commonjs\",                                /* Specify what module code is generated. */\n    // \"rootDir\": \"./\",                                  /* Specify the root folder within your source files. */\n    // \"moduleResolution\": \"node\",                       /* Specify how TypeScript looks up a file from a given module specifier. */\n    // \"baseUrl\": \"./\",                                  /* Specify the base directory to resolve non-relative module names. */\n    \"paths\": {\n      \"@ORGANIZATION/PROJECT-api/lib/*\": [\"./src/api/*\"],\n      \"@ORGANIZATION/PROJECT-api\": [\"./src/api\"],\n    },                                      /* Specify a set of entries that re-map imports to additional lookup locations. */\n    // \"rootDirs\": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */\n    // \"typeRoots\": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */\n    // \"types\": [],                                      /* Specify type package names to be included without being referenced in a source file. */\n    // \"allowUmdGlobalAccess\": true,                     /* Allow accessing UMD globals from modules. */\n    // \"moduleSuffixes\": [],                             /* List of file name suffixes to search when resolving a module. */\n    // \"resolveJsonModule\": true,                        /* Enable importing .json files. */\n    // \"noResolve\": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */\n\n    /* JavaScript Support */\n    // \"allowJs\": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */\n    // \"checkJs\": true,                                  /* Enable error reporting in type-checked JavaScript files. */\n    // \"maxNodeModuleJsDepth\": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */\n\n    /* Emit */\n    // \"declaration\": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */\n    // \"declarationMap\": true,                           /* Create sourcemaps for d.ts files. */\n    // \"emitDeclarationOnly\": true,                      /* Only output d.ts files and not JavaScript files. */\n    \"sourceMap\": true,                                /* Create source map files for emitted JavaScript files. */\n    // \"outFile\": \"./\",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */\n    \"outDir\": \"./lib\",                                   /* Specify an output folder for all emitted files. */\n    // \"removeComments\": true,                           /* Disable emitting comments. */\n    // \"noEmit\": true,                                   /* Disable emitting files from a compilation. */\n    // \"importHelpers\": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */\n    // \"importsNotUsedAsValues\": \"remove\",               /* Specify emit/checking behavior for imports that are only used for types. */\n    // \"downlevelIteration\": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */\n    // \"sourceRoot\": \"\",                                 /* Specify the root path for debuggers to find the reference source code. */\n    // \"mapRoot\": \"\",                                    /* Specify the location where debugger should locate map files instead of generated locations. */\n    // \"inlineSourceMap\": true,                          /* Include sourcemap files inside the emitted JavaScript. */\n    // \"inlineSources\": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */\n    // \"emitBOM\": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */\n    \"newLine\": \"lf\",                                /* Set the newline character for emitting files. */\n    \"stripInternal\": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */\n    // \"noEmitHelpers\": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */\n    // \"noEmitOnError\": true,                            /* Disable emitting files if any type checking errors are reported. */\n    // \"preserveConstEnums\": true,                       /* Disable erasing 'const enum' declarations in generated code. */\n    // \"declarationDir\": \"./\",                           /* Specify the output directory for generated declaration files. */\n    // \"preserveValueImports\": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */\n\n    /* Interop Constraints */\n    // \"isolatedModules\": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */\n    // \"allowSyntheticDefaultImports\": true,             /* Allow 'import x from y' when a module doesn't have a default export. */\n    \"esModuleInterop\": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */\n    // \"preserveSymlinks\": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */\n    \"forceConsistentCasingInFileNames\": true,            /* Ensure that casing is correct in imports. */\n\n    /* Type Checking */\n    \"strict\": true,                                      /* Enable all strict type-checking options. */\n    // \"noImplicitAny\": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */\n    // \"strictNullChecks\": true,                         /* When type checking, take into account 'null' and 'undefined'. */\n    // \"strictFunctionTypes\": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */\n    // \"strictBindCallApply\": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */\n    // \"strictPropertyInitialization\": true,             /* Check for class properties that are declared but not set in the constructor. */\n    // \"noImplicitThis\": true,                           /* Enable error reporting when 'this' is given the type 'any'. */\n    // \"useUnknownInCatchVariables\": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */\n    // \"alwaysStrict\": true,                             /* Ensure 'use strict' is always emitted. */\n    \"noUnusedLocals\": false,                           /* Enable error reporting when local variables aren't read. */\n    \"noUnusedParameters\": false,                       /* Raise an error when a function parameter isn't read. */\n    // \"exactOptionalPropertyTypes\": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */\n    \"noImplicitReturns\": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */\n    \"noFallthroughCasesInSwitch\": true,               /* Enable error reporting for fallthrough cases in switch statements. */\n    // \"noUncheckedIndexedAccess\": true,                 /* Add 'undefined' to a type when accessed using an index. */\n    // \"noImplicitOverride\": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */\n    // \"noPropertyAccessFromIndexSignature\": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */\n    // \"allowUnusedLabels\": true,                        /* Disable error reporting for unused labels. */\n    // \"allowUnreachableCode\": true,                     /* Disable error reporting for unreachable code. */\n\n    /* Completeness */\n    // \"skipDefaultLibCheck\": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */\n    \"skipLibCheck\": true,                                 /* Skip type checking all .d.ts files. */\n    \"plugins\": [\n      { \"transform\": \"typescript-transform-paths\" },\n      { \"transform\": \"typia/lib/transform\" },\n      { \n        \"transform\": \"@nestia/core/lib/transform\",\n        /**\n         * Validate request body.\n         * \n         *   - \"assert\": Use typia.assert() function\n         *   - \"is\": Use typia.is() function\n         *   - \"validate\": Use typia.validate() function\n         *   - \"assertEquals\": Use typia.assertEquals() function\n         *   - \"equals\": Use typia.equals() function\n         *   - \"validateEquals\": Use typia.validateEquals() function\n         */\n        \"validate\": \"validate\",\n        /**\n         * Validate JSON typed response body.\n         * \n         *   - \"assert\": Use typia.assertStringify() function\n         *   - \"is\": Use typia.isStringify() function\n         *   - \"validate\": Use typia.validateStringify() function\n         *   - \"validate.log\": typia.validateStringify(), but do not throw and just log it\n         *   - \"stringify\": Use typia.stringify() function, but dangerous\n         *   - null: Just use JSON.stringify() function, without boosting\n         */\n        \"stringify\": \"assert\",\n      },\n    ]\n  },\n  \"include\": [\n    \"src\"\n  ],\n  \"exclude\": [\n    \"node_modules\",\n    \"packages\",\n  ]\n}\n",
   "test/autobe/compiler/IAutoBeRealizeTestOperation.ts": "//---------------------------------------------------\n// Cloned from @autobe/interface\n//---------------------------------------------------\nimport { tags } from \"typia\";\n\n/**\n * Detailed result interface representing the execution outcome of an individual\n * E2E test function during comprehensive backend implementation validation.\n *\n * This interface captures comprehensive information about a single test\n * operation execution, including identification details, execution results,\n * error conditions, and precise timing data. Each operation represents the\n * validation of a specific API endpoint or business scenario through Test\n * agent-generated E2E test functions executed against the fully implemented\n * backend application.\n *\n * The operation result provides granular visibility into test execution\n * outcomes, enabling detailed analysis of implementation quality, business\n * logic compliance, and performance characteristics at the individual test\n * level. This detailed tracking supports comprehensive validation reporting and\n * precise identification of implementation issues when they occur.\n *\n * @author Samchon\n */\nexport interface IAutoBeRealizeTestOperation {\n  /**\n   * Unique identifier name of the executed E2E test function.\n   *\n   * Specifies the function name that was executed during this test operation,\n   * typically corresponding to the Test agent-generated test function\n   * identifier. This name provides direct traceability between test results and\n   * the specific business scenarios, API endpoints, or validation logic being\n   * tested.\n   *\n   * The test function name serves as the primary identifier for correlating\n   * execution results with the original test scenarios, enabling stakeholders\n   * to understand which specific functionality was validated and whether the\n   * implementation correctly fulfills the intended business requirements and\n   * API contracts.\n   */\n  name: string;\n\n  /**\n   * File system path location of the executed test function source code.\n   *\n   * Specifies the relative or absolute path to the test file that contains the\n   * executed function within the project structure. This location information\n   * enables direct navigation to the test source code for detailed analysis,\n   * debugging, result interpretation, or modification purposes.\n   *\n   * The file location provides essential context for understanding test\n   * organization, enables developers to quickly locate and examine the specific\n   * test implementation, and supports comprehensive test suite maintenance and\n   * documentation activities.\n   */\n  location: string;\n\n  /**\n   * Return value or result data produced by the test function execution.\n   *\n   * Contains the actual value returned by the test function upon completion,\n   * regardless of whether execution succeeded or failed. This could include API\n   * response objects, validation results, test data, computed values, or any\n   * other output that the test function produces as part of its business logic\n   * validation or endpoint testing.\n   *\n   * For successful test executions, this value represents the expected result\n   * that demonstrates correct implementation behavior. The return value\n   * provides insight into the test execution flow and can be analyzed to verify\n   * that API responses match expected formats, business logic produces correct\n   * outcomes, and data transformations operate as intended.\n   */\n  value: unknown;\n\n  /**\n   * Error information captured during test function execution, if any occurred.\n   *\n   * Contains detailed error information when the test function encounters\n   * exceptions, assertion failures, timeout conditions, or other error states\n   * during execution. When null, it indicates that the test completed\n   * successfully without encountering any error conditions. When present, the\n   * error provides comprehensive diagnostic information for understanding\n   * implementation issues or test failures.\n   *\n   * Error information is crucial for identifying implementation defects, API\n   * contract violations, business logic errors, integration failures, or\n   * performance issues that prevent the backend application from meeting its\n   * requirements. The error details enable developers to pinpoint specific\n   * problems and implement necessary corrections to achieve full compliance\n   * with validation scenarios.\n   */\n  error: null | unknown;\n\n  /**\n   * Precise timestamp when this specific test operation began execution.\n   *\n   * Records the exact moment when this individual test function started\n   * execution, providing the reference point for measuring test duration and\n   * understanding the temporal sequence of test operations within the overall\n   * validation process. This timestamp enables detailed performance analysis\n   * and execution timeline reconstruction.\n   *\n   * The start timestamp is essential for identifying execution patterns,\n   * analyzing test concurrency behavior, measuring individual test performance,\n   * and understanding the temporal distribution of test execution within the\n   * comprehensive validation suite.\n   */\n  started_at: string & tags.Format<\"date-time\">;\n\n  /**\n   * Precise timestamp when this specific test operation finished execution.\n   *\n   * Records the exact moment when this individual test function completed\n   * execution, regardless of whether it succeeded or failed. Combined with the\n   * start timestamp, this enables precise calculation of test execution\n   * duration and provides completion reference for the overall test timeline.\n   *\n   * The completion timestamp is valuable for performance analysis of individual\n   * test operations, identifying slow-performing test scenarios, understanding\n   * test execution efficiency, and maintaining comprehensive audit trails of\n   * the validation process. It supports optimization efforts and helps identify\n   * potential bottlenecks in either the test implementation or the backend\n   * application being validated.\n   */\n  completed_at: string & tags.Format<\"date-time\">;\n}\n",
   "test/autobe/compiler/IAutoBeRealizeTestConfig.ts": "//---------------------------------------------------\n// Cloned from @autobe/interface\n//---------------------------------------------------\n/**\n * Configuration interface defining the essential execution parameters required\n * for comprehensive E2E test suite validation against fully implemented backend\n * applications.\n *\n * This interface encapsulates the core execution settings and control\n * parameters necessary to orchestrate the final validation phase of the AutoBE\n * development pipeline. It provides streamlined configuration options that\n * control test execution behavior, database management, and performance\n * characteristics without requiring direct access to implementation files or\n * database schemas.\n *\n * The configuration assumes that the test execution environment has been\n * pre-configured with all necessary resources including generated\n * implementation files, database schemas, and package dependencies. This\n * interface focuses solely on runtime execution parameters that control how the\n * test suite operates within the prepared environment.\n *\n * This lightweight configuration approach enables flexible test execution\n * across different environments while maintaining clear separation between\n * resource provisioning and execution control, supporting both development and\n * production validation scenarios.\n *\n * @author Samchon\n */\nexport interface IAutoBeRealizeTestConfig {\n  /**\n   * Optional flag indicating whether to perform a complete database reset\n   * before test execution.\n   *\n   * When true, specifies that the test execution should begin with a\n   * comprehensive database reset, purging all existing data and reconstructing\n   * tables to their initial schema-defined state. When false, test execution\n   * proceeds with the current database state, which may contain residual data\n   * from previous operations.\n   *\n   * Database reset is crucial for ensuring test isolation, reproducibility, and\n   * deterministic results. Clean state testing eliminates interference from\n   * residual data and guarantees that each test execution cycle operates under\n   * identical baseline conditions, enabling accurate validation of backend\n   * implementation behavior.\n   *\n   * @default true\n   */\n  reset?: boolean;\n\n  /**\n   * Optional specification of the maximum number of test functions to execute\n   * concurrently during the test suite run.\n   *\n   * Defines the concurrent execution limit for E2E test functions to optimize\n   * testing performance while maintaining system stability and resource\n   * management. This value balances test execution speed with resource\n   * consumption and helps prevent system overload during comprehensive\n   * validation.\n   *\n   * Concurrent execution significantly reduces total testing time for large\n   * test suites while validating the backend application's ability to handle\n   * parallel requests correctly. The simultaneous limit ensures controlled load\n   * conditions that provide meaningful performance insights while maintaining\n   * test reliability and result accuracy.\n   *\n   * @default 1\n   */\n  simultaneous?: number;\n}\n",
   "test/autobe/compiler/IAutoBeRealizeTestResult.ts": "//---------------------------------------------------\n// Cloned from @autobe/interface\n//---------------------------------------------------\nimport { tags } from \"typia\";\n\nimport { IAutoBeRealizeTestOperation } from \"./IAutoBeRealizeTestOperation\";\n\n/**\n * Comprehensive result interface containing complete information about E2E test\n * suite execution for backend implementation validation.\n *\n * This interface represents the final consolidated results of executing the\n * entire Test agent-generated E2E test suite against the fully implemented\n * backend application. It encapsulates all aspects of the test execution\n * process including configuration parameters, individual operation results, and\n * timing information that collectively determine the validation outcome of the\n * generated backend implementation.\n *\n * The result structure provides stakeholders with comprehensive visibility into\n * the validation process, enabling detailed analysis of backend implementation\n * quality, compliance with requirements, and production readiness assessment\n * based on exhaustive functional testing.\n *\n * @author Samchon\n */\nexport interface IAutoBeRealizeTestResult {\n  /**\n   * Whether the test execution included a clean database reset before testing.\n   *\n   * Indicates if the test suite execution began with a complete database reset\n   * to ensure clean testing conditions. When true, all existing data was purged\n   * and database tables were reconstructed to their initial state before test\n   * execution commenced, guaranteeing test isolation and reproducibility.\n   *\n   * Database reset is essential for ensuring that test results are\n   * deterministic and accurately reflect the application's behavior under\n   * controlled conditions, free from interference by residual data from\n   * previous executions or development activities. This flag helps stakeholders\n   * understand the testing conditions and trust the reliability of results.\n   */\n  reset: boolean;\n\n  /**\n   * Number of test functions that were executed simultaneously during the test\n   * suite run.\n   *\n   * Specifies the concurrent execution limit that was applied during E2E test\n   * function execution to optimize testing performance while maintaining system\n   * stability. This value represents the balance between test execution speed\n   * and resource consumption that was used to validate the backend\n   * implementation's ability to handle concurrent requests.\n   *\n   * The simultaneous execution count provides insight into the load conditions\n   * under which the backend application was validated, helping stakeholders\n   * understand the concurrency testing coverage and the application's\n   * performance characteristics under parallel request scenarios.\n   */\n  simultaneous: number;\n\n  /**\n   * Complete collection of individual test operation results with detailed\n   * execution information.\n   *\n   * Contains the comprehensive array of {@link IAutoBeRealizeTestOperation}\n   * results representing every E2E test function that was executed during the\n   * validation process. Each operation result includes detailed information\n   * about test execution outcomes, return values, error conditions, timing\n   * data, and validation status for specific API endpoints or business\n   * scenarios.\n   *\n   * This complete result set enables stakeholders to perform detailed analysis\n   * of which functionality passed validation, which tests failed, what specific\n   * issues were encountered, and how the backend implementation performs under\n   * various test scenarios. The operation results serve as the authoritative\n   * record of implementation quality and compliance with established\n   * requirements.\n   */\n  operations: IAutoBeRealizeTestOperation[];\n\n  /**\n   * Timestamp when the comprehensive test suite execution was initiated.\n   *\n   * Records the exact moment when the E2E test suite execution began, marking\n   * the start of the final validation phase in the AutoBE development pipeline.\n   * This timestamp provides the reference point for understanding the complete\n   * test execution timeline and measuring the duration of comprehensive backend\n   * validation.\n   *\n   * The start timestamp is essential for performance analysis of the entire\n   * validation process, enabling stakeholders to understand test execution\n   * efficiency and identify potential optimization opportunities in the testing\n   * infrastructure or backend implementation.\n   */\n  started_at: string & tags.Format<\"date-time\">;\n\n  /**\n   * Timestamp when the entire test suite execution was finalized.\n   *\n   * Records the exact moment when all planned E2E test operations finished\n   * execution, marking the completion of the comprehensive validation process.\n   * This timestamp represents the definitive end point of the AutoBE\n   * development pipeline validation phase and provides the completion reference\n   * for calculating total validation duration.\n   *\n   * The completion timestamp serves as the official validation completion\n   * marker for stakeholders tracking project delivery milestones and provides\n   * essential audit trail information for the complete development and\n   * validation cycle. Combined with the start timestamp, it enables precise\n   * measurement of the total time required for comprehensive backend\n   * validation.\n   */\n  completed_at: string & tags.Format<\"date-time\">;\n}\n",