@autobe/agent 0.21.0 → 0.22.1

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceComplement.js.map

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

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceEndpoints.js

@@ -155,7 +155,7 @@ const claude = {
                                 pattern: "^\\/[a-zA-Z0-9\\/_{}.-]*$"
                             },
                             method: {
-                                description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\", not \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
+                                description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\",\nnot \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
                                 oneOf: [
                                     {
                                         "const": "get"
@@ -283,7 +283,7 @@ const collection = {
                                     type: "string"
                                 },
                                 method: {
-                                    description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\", not \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
+                                    description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\",\nnot \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
                                     type: "string",
                                     "enum": [
                                         "get",

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceEndpointsReview.js

@@ -142,7 +142,7 @@ const claude = {
                                 pattern: "^\\/[a-zA-Z0-9\\/_{}.-]*$"
                             },
                             method: {
-                                description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\", not \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
+                                description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\",\nnot \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
                                 oneOf: [
                                     {
                                         "const": "get"
@@ -275,7 +275,7 @@ const collection = {
                                     type: "string"
                                 },
                                 method: {
-                                    description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\", not \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
+                                    description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\",\nnot \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
                                     type: "string",
                                     "enum": [
                                         "get",

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceOperations.js

@@ -67,23 +67,25 @@ function orchestrateInterfaceOperations(ctx_1, endpoints_1) {
             array: endpoints,
             capacity,
         });
+        const progress = {
+            total: matrix.flat().length,
+            completed: 0,
+        };
+        const reviewProgress = {
+            total: matrix.length,
+            completed: 0,
+        };
         return (yield (0, executeCachedBatch_1.executeCachedBatch)(matrix.map((it) => (promptCacheKey) => __awaiter(this, void 0, void 0, function* () {
-            const row = yield divideAndConquer(ctx, it, 3, {
-                total: matrix.length,
-                completed: 0,
-            }, {
-                total: matrix.length,
-                completed: 0,
-            }, promptCacheKey);
+            const row = yield divideAndConquer(ctx, it, progress, reviewProgress, promptCacheKey);
             return row;
         })))).flat();
     });
 }
-function divideAndConquer(ctx, endpoints, retry, operationsProgress, operationsReviewProgress, promptCacheKey) {
+function divideAndConquer(ctx, endpoints, operationsProgress, operationsReviewProgress, promptCacheKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const remained = new tstl_1.HashSet(endpoints, OpenApiEndpointComparator_1.OpenApiEndpointComparator.hashCode, OpenApiEndpointComparator_1.OpenApiEndpointComparator.equals);
         const unique = new tstl_1.HashMap(OpenApiEndpointComparator_1.OpenApiEndpointComparator.hashCode, OpenApiEndpointComparator_1.OpenApiEndpointComparator.equals);
-        for (let i = 0; i < retry; ++i) {
+        for (let i = 0; i < ctx.retry; ++i) {
             if (remained.empty() === true || unique.size() >= endpoints.length)
                 break;
             const operations = remained.size()
@@ -153,7 +155,7 @@ function process(ctx, endpoints, progress, promptCacheKey) {
 function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const validate = (next) => {
-        const result = (() => { const _io0 = input => Array.isArray(input.operations) && input.operations.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.prisma_schemas && (Array.isArray(input.authorizationRoles) && input.authorizationRoles.every(elem => "string" === typeof elem && (RegExp("^[a-z][a-zA-Z0-9]*$").test(elem) && 1 <= elem.length))) && "string" === typeof input.description && ("string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name)) && "string" === typeof input.specification && "string" === typeof input.summary && ("string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path)) && (Array.isArray(input.parameters) && input.parameters.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (null === input.requestBody || "object" === typeof input.requestBody && null !== input.requestBody && _io6(input.requestBody)) && (null === input.responseBody || "object" === typeof input.responseBody && null !== input.responseBody && _io7(input.responseBody)) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description && ("object" === typeof input.schema && null !== input.schema && _iu0(input.schema)); const _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _io7 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _iu0 = input => (() => {
+        const result = (() => { const _io0 = input => Array.isArray(input.operations) && input.operations.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => Array.isArray(input.authorizationRoles) && input.authorizationRoles.every(elem => "string" === typeof elem && (RegExp("^[a-z][a-zA-Z0-9]*$").test(elem) && 1 <= elem.length)) && ("string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name)) && "string" === typeof input.specification && "string" === typeof input.summary && "string" === typeof input.description && ("string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path)) && (Array.isArray(input.parameters) && input.parameters.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (null === input.requestBody || "object" === typeof input.requestBody && null !== input.requestBody && _io6(input.requestBody)) && (null === input.responseBody || "object" === typeof input.responseBody && null !== input.responseBody && _io7(input.responseBody)) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description && ("object" === typeof input.schema && null !== input.schema && _iu0(input.schema)); const _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _io7 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _iu0 = input => (() => {
             if ("number" === input.type)
                 return _io4(input);
             else if ("integer" === input.type)
@@ -178,11 +180,7 @@ function createController(props) {
                 path: _path + ".operations",
                 expected: "Array<IAutoBeInterfaceOperationApplication.IOperation>",
                 value: input.operations
-            })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.prisma_schemas || _report(_exceptionable, {
-                path: _path + ".prisma_schemas",
-                expected: "string",
-                value: input.prisma_schemas
-            }), (Array.isArray(input.authorizationRoles) || _report(_exceptionable, {
+            })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [(Array.isArray(input.authorizationRoles) || _report(_exceptionable, {
                 path: _path + ".authorizationRoles",
                 expected: "Array<string & CamelPattern & MinLength<1>>",
                 value: input.authorizationRoles
@@ -202,10 +200,6 @@ function createController(props) {
                 path: _path + ".authorizationRoles",
                 expected: "Array<string & CamelPattern & MinLength<1>>",
                 value: input.authorizationRoles
-            }), "string" === typeof input.description || _report(_exceptionable, {
-                path: _path + ".description",
-                expected: "string",
-                value: input.description
             }), "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                 path: _path + ".name",
                 expected: "string & CamelPattern",
@@ -222,6 +216,10 @@ function createController(props) {
                 path: _path + ".summary",
                 expected: "string",
                 value: input.summary
+            }), "string" === typeof input.description || _report(_exceptionable, {
+                path: _path + ".description",
+                expected: "string",
+                value: input.description
             }), "string" === typeof input.path && (RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) || _report(_exceptionable, {
                 path: _path + ".path",
                 expected: "string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">",
@@ -607,10 +605,6 @@ const collection = {
                                 description: "Operation of the Restful API.\n\nThis interface defines a single API endpoint with its HTTP {@link method},\n{@link path}, {@link parameters path parameters},\n{@link requestBody request body}, and {@link responseBody} structure. It\ncorresponds to an individual operation in the paths section of an OpenAPI\ndocument.\n\nEach operation requires a detailed explanation of its purpose through the\nreason and description fields, making it clear why the API was designed and\nhow it should be used.\n\nDO: Use object types for all request bodies and responses. DO: Reference\nnamed types defined in the components section. DO: Use `application/json`\nas the content-type. DO: Use `string & tags.Format<\"uri\">` in the schema\nfor file upload/download operations instead of binary data formats.\n\nIn OpenAPI, this might represent:\n\n```json\n{\n  \"/shoppings/customers/orders\": {\n    \"post\": {\n      \"description\": \"Create a new order application from shopping cart...\",\n      \"parameters\": [...],\n      \"requestBody\": {...},\n      \"responses\": {...}\n    }\n  }\n}\n```",
                                 type: "object",
                                 properties: {
-                                    prisma_schemas: {
-                                        description: "Prisma schema models relevant to this operation.\n\nContains the complete Prisma schema definitions for all entities involved\nin this operation, including their fields, relations, and database\nconstraints. This enables comprehensive validation and schema-aware\noperation design.\n\nThe schema information serves multiple critical purposes:\n\n- **Field Verification**: Ensures all referenced fields actually exist in\n  the database schema and have the correct types\n- **Relationship Validation**: Confirms that entity relationships are\n  properly defined and can support the operation's data access patterns\n- **Soft-Delete Detection**: For DELETE operations, identifies whether\n  entities have soft-delete fields (deleted_at, is_deleted, etc.) to\n  determine if the operation should perform logical deletion instead of\n  physical removal\n- **Constraint Awareness**: Understands unique constraints, required\n  fields, and default values to generate accurate request/response\n  schemas\n\nExample content might include:\n\n```prisma\nmodel User {\n  id         String",
-                                        type: "string"
-                                    },
                                     authorizationRoles: {
                                         description: "Authorization roles required to access this API operation.\n\nThis field specifies which user roles are allowed to access this\nendpoint. Multiple roles can be specified to allow different types of\nusers to access the same endpoint.\n\n## \u26A0\uFE0F CRITICAL: Role Multiplication Effect\n\n**EACH ROLE IN THIS ARRAY GENERATES A SEPARATE ENDPOINT**\n\n- If you specify `[\"admin\", \"moderator\", \"member\"]`, this creates 3\n  separate endpoints\n- Total generated endpoints = operations \u00D7 average roles.length\n- Example: 100 operations with 3 roles each = 300 actual endpoints\n\n## \uD83D\uDD34 AVOID OVER-GENERATION\n\n**DO NOT create role-specific endpoints when a public endpoint would\nsuffice:**\n\n- \u274C BAD: Separate GET endpoints for admin, member, moderator to view the\n  same public data\n- \u2705 GOOD: Single public endpoint `[]` with role-based filtering in business\n  logic\n\n**DO NOT enumerate all possible roles when the Prisma schema uses a\nsingle User table:**\n\n- If Prisma has a User table with role/permission fields, you likely only\n  need `[\"user\"]`\n- Avoid listing `[\"admin\", \"seller\", \"buyer\", \"moderator\", ...]`\n  unnecessarily\n- The actual role checking happens in business logic, not at the endpoint\n  level\n\n## Naming Convention\n\nDO: Use camelCase for all role names.\n\n## Important Guidelines\n\n- Set to empty array `[]` for public endpoints that require no\n  authentication\n- Set to array with role strings for role-restricted endpoints\n- **MINIMIZE the number of roles per endpoint to prevent explosion**\n- Consider if the endpoint can be public with role-based filtering instead\n- The role names match exactly with the user type/role defined in the\n  database\n- This will be used by the Realize Agent to generate appropriate decorator\n  and authorization logic in the provider functions\n- The controller will apply the corresponding authentication decorator\n  based on these roles\n\n## Examples\n\n- `[]` - Public endpoint, no authentication required (PREFERRED for read\n  operations)\n- `[\"user\"]` - Any authenticated user can access (PREFERRED for\n  user-specific operations)\n- `[\"admin\"]` - Only admin users can access (USE SPARINGLY)\n- `[\"admin\", \"moderator\"]` - Both admin and moderator users can access\n  (AVOID if possible)\n- `[\"seller\"]` - Only seller users can access (ONLY if Seller is a separate\n  table)\n\n## Best Practices\n\n1. **Start with public `[]` for all read operations** unless sensitive data\n   is involved\n2. **Use single role `[\"user\"]` for authenticated operations** and handle\n   permissions in business logic\n3. **Only use multiple roles when absolutely necessary** for different\n   business logic paths\n4. **Remember: Fewer roles = Fewer endpoints = Better performance and\n   maintainability**\n\nNote: The actual authentication/authorization implementation will be\nhandled by decorators at the controller level, and the provider function\nwill receive the authenticated user object with the appropriate type.",
                                         type: "array",
@@ -619,10 +613,6 @@ const collection = {
                                             type: "string"
                                         }
                                     },
-                                    description: {
-                                        description: "Detailed description about the API operation.\n\nIMPORTANT: This field MUST be extensively detailed and MUST reference the\ndescription comments from the related Prisma DB schema tables and\ncolumns. The description should be organized into MULTIPLE PARAGRAPHS\nseparated by line breaks to improve readability and comprehension.\n\nFor example, include separate paragraphs for:\n\n- The purpose and overview of the API operation\n- Security considerations and user permissions\n- Relationship to underlying database entities\n- Validation rules and business logic\n- Related API operations that might be used together with this one\n- Expected behavior and error handling\n\nWhen writing the description, be sure to incorporate the corresponding DB\nschema's description comments, matching the level of detail and style of\nthose comments. This ensures consistency between the API documentation\nand database structure.\n\nIf there's a dependency to other APIs, please describe the dependency API\noperation in this field with detailed reason. For example, if this API\noperation needs a pre-execution of other API operation, it must be\nexplicitly described.\n\n- `GET /shoppings/customers/sales` must be pre-executed to get entire list\n  of summarized sales. Detailed sale information would be obtained by\n  specifying the sale ID in the path parameter.\n\n**CRITICAL WARNING about soft delete keywords**:\nDO NOT use terms like \"soft delete\", \"soft-delete\", or similar variations\nin this description UNLESS the operation actually implements soft deletion.\nThese keywords trigger validation logic that expects a corresponding\nsoft_delete_column to be specified. Only use these terms when you intend\nto implement soft deletion (marking records as deleted without removing\nthem from the database).\n\nExample of problematic description:\n\u274C \"This would normally be a soft-delete, but we intentionally perform\npermanent deletion here\" - This triggers soft delete validation despite\nbeing a hard delete operation.\n\n> MUST be written in English. Never use other languages.",
-                                        type: "string"
-                                    },
                                     name: {
                                         description: "Functional name of the API endpoint.\n\nThis is a semantic identifier that represents the primary function or\npurpose of the API endpoint. It serves as a canonical name that can be\nused for code generation, SDK method names, and internal references.\n\n## Reserved Word Restrictions\n\nCRITICAL: The name MUST NOT be a TypeScript/JavaScript reserved word, as\nit will be used as a class method name in generated code. Avoid names\nlike:\n\n- `delete`, `for`, `if`, `else`, `while`, `do`, `switch`, `case`, `break`\n- `continue`, `function`, `return`, `with`, `in`, `of`, `instanceof`\n- `typeof`, `void`, `var`, `let`, `const`, `class`, `extends`, `import`\n- `export`, `default`, `try`, `catch`, `finally`, `throw`, `new`\n- `super`, `this`, `null`, `true`, `false`, `async`, `await`\n- `yield`, `static`, `private`, `protected`, `public`, `implements`\n- `interface`, `package`, `enum`, `debugger`\n\nInstead, use alternative names for these operations:\n\n- Use `erase` instead of `delete`\n- Use `iterate` instead of `for`\n- Use `when` instead of `if`\n- Use `cls` instead of `class`\n\n## Standard Endpoint Names\n\nUse these conventional names based on the endpoint's primary function:\n\n- **`index`**: List/search operations that return multiple entities\n\n  - Typically used with PATCH method for complex queries\n  - Example: `PATCH /users` \u2192 `name: \"index\"`\n- **`at`**: Retrieve a specific entity by identifier\n\n  - Typically used with GET method on single resource\n  - Example: `GET /users/{userId}` \u2192 `name: \"at\"`\n- **`create`**: Create a new entity\n\n  - Typically used with POST method\n  - Example: `POST /users` \u2192 `name: \"create\"`\n- **`update`**: Update an existing entity\n\n  - Typically used with PUT method\n  - Example: `PUT /users/{userId}` \u2192 `name: \"update\"`\n- **`erase`**: Delete/remove an entity (NOT `delete` - reserved word!)\n\n  - Typically used with DELETE method\n  - Example: `DELETE /users/{userId}` \u2192 `name: \"erase\"`\n\n## Custom Endpoint Names\n\nFor specialized operations beyond basic CRUD, use descriptive verbs:\n\n- **`activate`**: Enable or turn on a feature/entity\n- **`deactivate`**: Disable or turn off a feature/entity\n- **`approve`**: Approve a request or entity\n- **`reject`**: Reject a request or entity\n- **`publish`**: Make content publicly available\n- **`archive`**: Move to archived state\n- **`restore`**: Restore from archived/deleted state\n- **`duplicate`**: Create a copy of an entity\n- **`transfer`**: Move ownership or change assignment\n- **`validate`**: Validate data or state\n- **`process`**: Execute a business process or workflow\n- **`export`**: Generate downloadable data\n- **`import`**: Process uploaded data\n\n## Naming Guidelines\n\n- MUST use camelCase naming convention\n- Use singular verb forms\n- Be concise but descriptive\n- Avoid abbreviations unless widely understood\n- Ensure the name clearly represents the endpoint's primary action\n- For nested resources, focus on the action rather than hierarchy\n- NEVER use JavaScript/TypeScript reserved words\n\nValid Examples:\n\n- `index`, `create`, `update`, `erase` (single word)\n- `updatePassword`, `cancelOrder`, `publishArticle` (camelCase)\n- `validateEmail`, `generateReport`, `exportData` (camelCase)\n\nInvalid Examples:\n\n- `update_password` (snake_case not allowed)\n- `UpdatePassword` (PascalCase not allowed)\n- `update-password` (kebab-case not allowed)\n\nPath to Name Examples:\n\n- `GET /shopping/orders/{orderId}/items` \u2192 `name: \"index\"` (lists items)\n- `POST /shopping/orders/{orderId}/cancel` \u2192 `name: \"cancel\"`\n- `PUT /users/{userId}/password` \u2192 `name: \"updatePassword\"`\n\n## Uniqueness Rule\n\nThe `name` must be unique within the API's accessor namespace. The\naccessor is formed by combining the path segments (excluding parameters)\nwith the operation name.\n\nAccessor formation:\n\n1. Extract non-parameter segments from the path (remove `{...}` parts)\n2. Join segments with dots\n3. Append the operation name\n\nExamples:\n\n- Path: `/shopping/sale/{saleId}/review/{reviewId}`, Name: `at` \u2192 Accessor:\n  `shopping.sale.review.at`\n- Path: `/users/{userId}/posts`, Name: `index` \u2192 Accessor:\n  `users.posts.index`\n- Path: `/auth/login`, Name: `signIn` \u2192 Accessor: `auth.login.signIn`\n\nEach accessor must be globally unique across the entire API. This ensures\noperations can be uniquely identified in generated SDKs and prevents\nnaming conflicts.\n\n\n@pattern ^[a-z][a-zA-Z0-9]*$",
                                         type: "string"
@@ -632,7 +622,11 @@ const collection = {
                                         type: "string"
                                     },
                                     summary: {
-                                        description: "Short summary of the API operation.\n\nThis should be a concise description of the API operation, typically one\nsentence long. It should provide a quick overview of what the API does\nwithout going into too much detail.\n\nThis summary will be used in the OpenAPI documentation to give users a\nquick understanding of the API operation's purpose.\n\nIMPORTANT: The summary should clearly indicate which Prisma DB table this\noperation relates to, helping to ensure all tables have API coverage.\n\n**CRITICAL WARNING about soft delete keywords**:\nDO NOT use terms like \"soft delete\", \"soft-delete\", or similar variations\nin this summary UNLESS the operation actually implements soft deletion.\nThese keywords trigger validation logic that expects a corresponding\nsoft_delete_column to be specified. Only use these terms when you intend\nto implement soft deletion (marking records as deleted without removing\nthem from the database).\n\n> MUST be written in English. Never use other languages",
+                                        description: "Short summary of the API operation.\n\nThis should be a concise description of the API operation, typically one\nsentence long. It should provide a quick overview of what the API does\nwithout going into too much detail.\n\nThis summary will be used in the OpenAPI documentation to give users a\nquick understanding of the API operation's purpose.\n\nIMPORTANT: The summary should clearly indicate which Prisma DB table this\noperation relates to, helping to ensure all tables have API coverage.\n\n**CRITICAL WARNING about soft delete keywords**: DO NOT use terms like\n\"soft delete\", \"soft-delete\", or similar variations in this summary\nUNLESS the operation actually implements soft deletion. These keywords\ntrigger validation logic that expects a corresponding soft_delete_column\nto be specified. Only use these terms when you intend to implement soft\ndeletion (marking records as deleted without removing them from the\ndatabase).\n\n> MUST be written in English. Never use other languages",
+                                        type: "string"
+                                    },
+                                    description: {
+                                        description: "Detailed description about the API operation.\n\nIMPORTANT: This field MUST be extensively detailed and MUST reference the\ndescription comments from the related Prisma DB schema tables and\ncolumns. The description should be organized into MULTIPLE PARAGRAPHS\nseparated by line breaks to improve readability and comprehension.\n\nFor example, include separate paragraphs for:\n\n- The purpose and overview of the API operation\n- Security considerations and user permissions\n- Relationship to underlying database entities\n- Validation rules and business logic\n- Related API operations that might be used together with this one\n- Expected behavior and error handling\n\nWhen writing the description, be sure to incorporate the corresponding DB\nschema's description comments, matching the level of detail and style of\nthose comments. This ensures consistency between the API documentation\nand database structure.\n\nIf there's a dependency to other APIs, please describe the dependency API\noperation in this field with detailed reason. For example, if this API\noperation needs a pre-execution of other API operation, it must be\nexplicitly described.\n\n- `GET /shoppings/customers/sales` must be pre-executed to get entire list\n  of summarized sales. Detailed sale information would be obtained by\n  specifying the sale ID in the path parameter.\n\n**CRITICAL WARNING about soft delete keywords**: DO NOT use terms like\n\"soft delete\", \"soft-delete\", or similar variations in this description\nUNLESS the operation actually implements soft deletion. These keywords\ntrigger validation logic that expects a corresponding soft_delete_column\nto be specified. Only use these terms when you intend to implement soft\ndeletion (marking records as deleted without removing them from the\ndatabase).\n\nExample of problematic description: \u274C \"This would normally be a\nsoft-delete, but we intentionally perform permanent deletion here\" - This\ntriggers soft delete validation despite being a hard delete operation.\n\n> MUST be written in English. Never use other languages.",
                                         type: "string"
                                     },
                                     path: {
@@ -669,7 +663,7 @@ const collection = {
                                         ]
                                     },
                                     method: {
-                                        description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\", not \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
+                                        description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\",\nnot \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
                                         type: "string",
                                         "enum": [
                                             "get",
@@ -681,12 +675,11 @@ const collection = {
                                     }
                                 },
                                 required: [
-                                    "prisma_schemas",
                                     "authorizationRoles",
-                                    "description",
                                     "name",
                                     "specification",
                                     "summary",
+                                    "description",
                                     "path",
                                     "parameters",
                                     "requestBody",
@@ -882,7 +875,7 @@ const collection = {
                         }
                     },
                     description: "Generate detailed API operations from path/method combinations.\n\nThis function creates complete API operations following REST principles and\nquality standards. Each generated operation includes specification, path,\nmethod, detailed multi-paragraph description, concise summary, parameters,\nand appropriate request/response bodies.\n\nThe function processes as many operations as possible in a single call,\nwith progress tracking to ensure iterative completion of all required\nendpoints.",
-                    validate: (() => { const _io0 = input => Array.isArray(input.operations) && input.operations.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.prisma_schemas && (Array.isArray(input.authorizationRoles) && input.authorizationRoles.every(elem => "string" === typeof elem && (RegExp("^[a-z][a-zA-Z0-9]*$").test(elem) && 1 <= elem.length))) && "string" === typeof input.description && ("string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name)) && "string" === typeof input.specification && "string" === typeof input.summary && ("string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path)) && (Array.isArray(input.parameters) && input.parameters.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (null === input.requestBody || "object" === typeof input.requestBody && null !== input.requestBody && _io6(input.requestBody)) && (null === input.responseBody || "object" === typeof input.responseBody && null !== input.responseBody && _io7(input.responseBody)) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description && ("object" === typeof input.schema && null !== input.schema && _iu0(input.schema)); const _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _io7 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _iu0 = input => (() => {
+                    validate: (() => { const _io0 = input => Array.isArray(input.operations) && input.operations.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => Array.isArray(input.authorizationRoles) && input.authorizationRoles.every(elem => "string" === typeof elem && (RegExp("^[a-z][a-zA-Z0-9]*$").test(elem) && 1 <= elem.length)) && ("string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name)) && "string" === typeof input.specification && "string" === typeof input.summary && "string" === typeof input.description && ("string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path)) && (Array.isArray(input.parameters) && input.parameters.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (null === input.requestBody || "object" === typeof input.requestBody && null !== input.requestBody && _io6(input.requestBody)) && (null === input.responseBody || "object" === typeof input.responseBody && null !== input.responseBody && _io7(input.responseBody)) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description && ("object" === typeof input.schema && null !== input.schema && _iu0(input.schema)); const _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _io7 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _iu0 = input => (() => {
                         if ("number" === input.type)
                             return _io4(input);
                         else if ("integer" === input.type)
@@ -907,11 +900,7 @@ const collection = {
                             path: _path + ".operations",
                             expected: "Array<IAutoBeInterfaceOperationApplication.IOperation>",
                             value: input.operations
-                        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.prisma_schemas || _report(_exceptionable, {
-                            path: _path + ".prisma_schemas",
-                            expected: "string",
-                            value: input.prisma_schemas
-                        }), (Array.isArray(input.authorizationRoles) || _report(_exceptionable, {
+                        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [(Array.isArray(input.authorizationRoles) || _report(_exceptionable, {
                             path: _path + ".authorizationRoles",
                             expected: "Array<string & CamelPattern & MinLength<1>>",
                             value: input.authorizationRoles
@@ -931,10 +920,6 @@ const collection = {
                             path: _path + ".authorizationRoles",
                             expected: "Array<string & CamelPattern & MinLength<1>>",
                             value: input.authorizationRoles
-                        }), "string" === typeof input.description || _report(_exceptionable, {
-                            path: _path + ".description",
-                            expected: "string",
-                            value: input.description
                         }), "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                             path: _path + ".name",
                             expected: "string & CamelPattern",
@@ -951,6 +936,10 @@ const collection = {
                             path: _path + ".summary",
                             expected: "string",
                             value: input.summary
+                        }), "string" === typeof input.description || _report(_exceptionable, {
+                            path: _path + ".description",
+                            expected: "string",
+                            value: input.description
                         }), "string" === typeof input.path && (RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) || _report(_exceptionable, {
                             path: _path + ".path",
                             expected: "string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">",
@@ -1213,10 +1202,6 @@ const collection = {
                                 description: "Operation of the Restful API.\n\nThis interface defines a single API endpoint with its HTTP {@link method},\n{@link path}, {@link parameters path parameters},\n{@link requestBody request body}, and {@link responseBody} structure. It\ncorresponds to an individual operation in the paths section of an OpenAPI\ndocument.\n\nEach operation requires a detailed explanation of its purpose through the\nreason and description fields, making it clear why the API was designed and\nhow it should be used.\n\nDO: Use object types for all request bodies and responses. DO: Reference\nnamed types defined in the components section. DO: Use `application/json`\nas the content-type. DO: Use `string & tags.Format<\"uri\">` in the schema\nfor file upload/download operations instead of binary data formats.\n\nIn OpenAPI, this might represent:\n\n```json\n{\n  \"/shoppings/customers/orders\": {\n    \"post\": {\n      \"description\": \"Create a new order application from shopping cart...\",\n      \"parameters\": [...],\n      \"requestBody\": {...},\n      \"responses\": {...}\n    }\n  }\n}\n```",
                                 type: "object",
                                 properties: {
-                                    prisma_schemas: {
-                                        description: "Prisma schema models relevant to this operation.\n\nContains the complete Prisma schema definitions for all entities involved\nin this operation, including their fields, relations, and database\nconstraints. This enables comprehensive validation and schema-aware\noperation design.\n\nThe schema information serves multiple critical purposes:\n\n- **Field Verification**: Ensures all referenced fields actually exist in\n  the database schema and have the correct types\n- **Relationship Validation**: Confirms that entity relationships are\n  properly defined and can support the operation's data access patterns\n- **Soft-Delete Detection**: For DELETE operations, identifies whether\n  entities have soft-delete fields (deleted_at, is_deleted, etc.) to\n  determine if the operation should perform logical deletion instead of\n  physical removal\n- **Constraint Awareness**: Understands unique constraints, required\n  fields, and default values to generate accurate request/response\n  schemas\n\nExample content might include:\n\n```prisma\nmodel User {\n  id         String",
-                                        type: "string"
-                                    },
                                     authorizationRoles: {
                                         description: "Authorization roles required to access this API operation.\n\nThis field specifies which user roles are allowed to access this\nendpoint. Multiple roles can be specified to allow different types of\nusers to access the same endpoint.\n\n## \u26A0\uFE0F CRITICAL: Role Multiplication Effect\n\n**EACH ROLE IN THIS ARRAY GENERATES A SEPARATE ENDPOINT**\n\n- If you specify `[\"admin\", \"moderator\", \"member\"]`, this creates 3\n  separate endpoints\n- Total generated endpoints = operations \u00D7 average roles.length\n- Example: 100 operations with 3 roles each = 300 actual endpoints\n\n## \uD83D\uDD34 AVOID OVER-GENERATION\n\n**DO NOT create role-specific endpoints when a public endpoint would\nsuffice:**\n\n- \u274C BAD: Separate GET endpoints for admin, member, moderator to view the\n  same public data\n- \u2705 GOOD: Single public endpoint `[]` with role-based filtering in business\n  logic\n\n**DO NOT enumerate all possible roles when the Prisma schema uses a\nsingle User table:**\n\n- If Prisma has a User table with role/permission fields, you likely only\n  need `[\"user\"]`\n- Avoid listing `[\"admin\", \"seller\", \"buyer\", \"moderator\", ...]`\n  unnecessarily\n- The actual role checking happens in business logic, not at the endpoint\n  level\n\n## Naming Convention\n\nDO: Use camelCase for all role names.\n\n## Important Guidelines\n\n- Set to empty array `[]` for public endpoints that require no\n  authentication\n- Set to array with role strings for role-restricted endpoints\n- **MINIMIZE the number of roles per endpoint to prevent explosion**\n- Consider if the endpoint can be public with role-based filtering instead\n- The role names match exactly with the user type/role defined in the\n  database\n- This will be used by the Realize Agent to generate appropriate decorator\n  and authorization logic in the provider functions\n- The controller will apply the corresponding authentication decorator\n  based on these roles\n\n## Examples\n\n- `[]` - Public endpoint, no authentication required (PREFERRED for read\n  operations)\n- `[\"user\"]` - Any authenticated user can access (PREFERRED for\n  user-specific operations)\n- `[\"admin\"]` - Only admin users can access (USE SPARINGLY)\n- `[\"admin\", \"moderator\"]` - Both admin and moderator users can access\n  (AVOID if possible)\n- `[\"seller\"]` - Only seller users can access (ONLY if Seller is a separate\n  table)\n\n## Best Practices\n\n1. **Start with public `[]` for all read operations** unless sensitive data\n   is involved\n2. **Use single role `[\"user\"]` for authenticated operations** and handle\n   permissions in business logic\n3. **Only use multiple roles when absolutely necessary** for different\n   business logic paths\n4. **Remember: Fewer roles = Fewer endpoints = Better performance and\n   maintainability**\n\nNote: The actual authentication/authorization implementation will be\nhandled by decorators at the controller level, and the provider function\nwill receive the authenticated user object with the appropriate type.",
                                         type: "array",
@@ -1226,10 +1211,6 @@ const collection = {
                                             minLength: 1
                                         }
                                     },
-                                    description: {
-                                        description: "Detailed description about the API operation.\n\nIMPORTANT: This field MUST be extensively detailed and MUST reference the\ndescription comments from the related Prisma DB schema tables and\ncolumns. The description should be organized into MULTIPLE PARAGRAPHS\nseparated by line breaks to improve readability and comprehension.\n\nFor example, include separate paragraphs for:\n\n- The purpose and overview of the API operation\n- Security considerations and user permissions\n- Relationship to underlying database entities\n- Validation rules and business logic\n- Related API operations that might be used together with this one\n- Expected behavior and error handling\n\nWhen writing the description, be sure to incorporate the corresponding DB\nschema's description comments, matching the level of detail and style of\nthose comments. This ensures consistency between the API documentation\nand database structure.\n\nIf there's a dependency to other APIs, please describe the dependency API\noperation in this field with detailed reason. For example, if this API\noperation needs a pre-execution of other API operation, it must be\nexplicitly described.\n\n- `GET /shoppings/customers/sales` must be pre-executed to get entire list\n  of summarized sales. Detailed sale information would be obtained by\n  specifying the sale ID in the path parameter.\n\n**CRITICAL WARNING about soft delete keywords**:\nDO NOT use terms like \"soft delete\", \"soft-delete\", or similar variations\nin this description UNLESS the operation actually implements soft deletion.\nThese keywords trigger validation logic that expects a corresponding\nsoft_delete_column to be specified. Only use these terms when you intend\nto implement soft deletion (marking records as deleted without removing\nthem from the database).\n\nExample of problematic description:\n\u274C \"This would normally be a soft-delete, but we intentionally perform\npermanent deletion here\" - This triggers soft delete validation despite\nbeing a hard delete operation.\n\n> MUST be written in English. Never use other languages.",
-                                        type: "string"
-                                    },
                                     name: {
                                         description: "Functional name of the API endpoint.\n\nThis is a semantic identifier that represents the primary function or\npurpose of the API endpoint. It serves as a canonical name that can be\nused for code generation, SDK method names, and internal references.\n\n## Reserved Word Restrictions\n\nCRITICAL: The name MUST NOT be a TypeScript/JavaScript reserved word, as\nit will be used as a class method name in generated code. Avoid names\nlike:\n\n- `delete`, `for`, `if`, `else`, `while`, `do`, `switch`, `case`, `break`\n- `continue`, `function`, `return`, `with`, `in`, `of`, `instanceof`\n- `typeof`, `void`, `var`, `let`, `const`, `class`, `extends`, `import`\n- `export`, `default`, `try`, `catch`, `finally`, `throw`, `new`\n- `super`, `this`, `null`, `true`, `false`, `async`, `await`\n- `yield`, `static`, `private`, `protected`, `public`, `implements`\n- `interface`, `package`, `enum`, `debugger`\n\nInstead, use alternative names for these operations:\n\n- Use `erase` instead of `delete`\n- Use `iterate` instead of `for`\n- Use `when` instead of `if`\n- Use `cls` instead of `class`\n\n## Standard Endpoint Names\n\nUse these conventional names based on the endpoint's primary function:\n\n- **`index`**: List/search operations that return multiple entities\n\n  - Typically used with PATCH method for complex queries\n  - Example: `PATCH /users` \u2192 `name: \"index\"`\n- **`at`**: Retrieve a specific entity by identifier\n\n  - Typically used with GET method on single resource\n  - Example: `GET /users/{userId}` \u2192 `name: \"at\"`\n- **`create`**: Create a new entity\n\n  - Typically used with POST method\n  - Example: `POST /users` \u2192 `name: \"create\"`\n- **`update`**: Update an existing entity\n\n  - Typically used with PUT method\n  - Example: `PUT /users/{userId}` \u2192 `name: \"update\"`\n- **`erase`**: Delete/remove an entity (NOT `delete` - reserved word!)\n\n  - Typically used with DELETE method\n  - Example: `DELETE /users/{userId}` \u2192 `name: \"erase\"`\n\n## Custom Endpoint Names\n\nFor specialized operations beyond basic CRUD, use descriptive verbs:\n\n- **`activate`**: Enable or turn on a feature/entity\n- **`deactivate`**: Disable or turn off a feature/entity\n- **`approve`**: Approve a request or entity\n- **`reject`**: Reject a request or entity\n- **`publish`**: Make content publicly available\n- **`archive`**: Move to archived state\n- **`restore`**: Restore from archived/deleted state\n- **`duplicate`**: Create a copy of an entity\n- **`transfer`**: Move ownership or change assignment\n- **`validate`**: Validate data or state\n- **`process`**: Execute a business process or workflow\n- **`export`**: Generate downloadable data\n- **`import`**: Process uploaded data\n\n## Naming Guidelines\n\n- MUST use camelCase naming convention\n- Use singular verb forms\n- Be concise but descriptive\n- Avoid abbreviations unless widely understood\n- Ensure the name clearly represents the endpoint's primary action\n- For nested resources, focus on the action rather than hierarchy\n- NEVER use JavaScript/TypeScript reserved words\n\nValid Examples:\n\n- `index`, `create`, `update`, `erase` (single word)\n- `updatePassword`, `cancelOrder`, `publishArticle` (camelCase)\n- `validateEmail`, `generateReport`, `exportData` (camelCase)\n\nInvalid Examples:\n\n- `update_password` (snake_case not allowed)\n- `UpdatePassword` (PascalCase not allowed)\n- `update-password` (kebab-case not allowed)\n\nPath to Name Examples:\n\n- `GET /shopping/orders/{orderId}/items` \u2192 `name: \"index\"` (lists items)\n- `POST /shopping/orders/{orderId}/cancel` \u2192 `name: \"cancel\"`\n- `PUT /users/{userId}/password` \u2192 `name: \"updatePassword\"`\n\n## Uniqueness Rule\n\nThe `name` must be unique within the API's accessor namespace. The\naccessor is formed by combining the path segments (excluding parameters)\nwith the operation name.\n\nAccessor formation:\n\n1. Extract non-parameter segments from the path (remove `{...}` parts)\n2. Join segments with dots\n3. Append the operation name\n\nExamples:\n\n- Path: `/shopping/sale/{saleId}/review/{reviewId}`, Name: `at` \u2192 Accessor:\n  `shopping.sale.review.at`\n- Path: `/users/{userId}/posts`, Name: `index` \u2192 Accessor:\n  `users.posts.index`\n- Path: `/auth/login`, Name: `signIn` \u2192 Accessor: `auth.login.signIn`\n\nEach accessor must be globally unique across the entire API. This ensures\noperations can be uniquely identified in generated SDKs and prevents\nnaming conflicts.",
                                         type: "string",
@@ -1240,7 +1221,11 @@ const collection = {
                                         type: "string"
                                     },
                                     summary: {
-                                        description: "Short summary of the API operation.\n\nThis should be a concise description of the API operation, typically one\nsentence long. It should provide a quick overview of what the API does\nwithout going into too much detail.\n\nThis summary will be used in the OpenAPI documentation to give users a\nquick understanding of the API operation's purpose.\n\nIMPORTANT: The summary should clearly indicate which Prisma DB table this\noperation relates to, helping to ensure all tables have API coverage.\n\n**CRITICAL WARNING about soft delete keywords**:\nDO NOT use terms like \"soft delete\", \"soft-delete\", or similar variations\nin this summary UNLESS the operation actually implements soft deletion.\nThese keywords trigger validation logic that expects a corresponding\nsoft_delete_column to be specified. Only use these terms when you intend\nto implement soft deletion (marking records as deleted without removing\nthem from the database).\n\n> MUST be written in English. Never use other languages",
+                                        description: "Short summary of the API operation.\n\nThis should be a concise description of the API operation, typically one\nsentence long. It should provide a quick overview of what the API does\nwithout going into too much detail.\n\nThis summary will be used in the OpenAPI documentation to give users a\nquick understanding of the API operation's purpose.\n\nIMPORTANT: The summary should clearly indicate which Prisma DB table this\noperation relates to, helping to ensure all tables have API coverage.\n\n**CRITICAL WARNING about soft delete keywords**: DO NOT use terms like\n\"soft delete\", \"soft-delete\", or similar variations in this summary\nUNLESS the operation actually implements soft deletion. These keywords\ntrigger validation logic that expects a corresponding soft_delete_column\nto be specified. Only use these terms when you intend to implement soft\ndeletion (marking records as deleted without removing them from the\ndatabase).\n\n> MUST be written in English. Never use other languages",
+                                        type: "string"
+                                    },
+                                    description: {
+                                        description: "Detailed description about the API operation.\n\nIMPORTANT: This field MUST be extensively detailed and MUST reference the\ndescription comments from the related Prisma DB schema tables and\ncolumns. The description should be organized into MULTIPLE PARAGRAPHS\nseparated by line breaks to improve readability and comprehension.\n\nFor example, include separate paragraphs for:\n\n- The purpose and overview of the API operation\n- Security considerations and user permissions\n- Relationship to underlying database entities\n- Validation rules and business logic\n- Related API operations that might be used together with this one\n- Expected behavior and error handling\n\nWhen writing the description, be sure to incorporate the corresponding DB\nschema's description comments, matching the level of detail and style of\nthose comments. This ensures consistency between the API documentation\nand database structure.\n\nIf there's a dependency to other APIs, please describe the dependency API\noperation in this field with detailed reason. For example, if this API\noperation needs a pre-execution of other API operation, it must be\nexplicitly described.\n\n- `GET /shoppings/customers/sales` must be pre-executed to get entire list\n  of summarized sales. Detailed sale information would be obtained by\n  specifying the sale ID in the path parameter.\n\n**CRITICAL WARNING about soft delete keywords**: DO NOT use terms like\n\"soft delete\", \"soft-delete\", or similar variations in this description\nUNLESS the operation actually implements soft deletion. These keywords\ntrigger validation logic that expects a corresponding soft_delete_column\nto be specified. Only use these terms when you intend to implement soft\ndeletion (marking records as deleted without removing them from the\ndatabase).\n\nExample of problematic description: \u274C \"This would normally be a\nsoft-delete, but we intentionally perform permanent deletion here\" - This\ntriggers soft delete validation despite being a hard delete operation.\n\n> MUST be written in English. Never use other languages.",
                                         type: "string"
                                     },
                                     path: {
@@ -1278,7 +1263,7 @@ const collection = {
                                         ]
                                     },
                                     method: {
-                                        description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\", not \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
+                                        description: "HTTP method of the API operation.\n\n**IMPORTANT**: Methods must be written in lowercase only (e.g., \"get\",\nnot \"GET\").\n\nNote that, if the API operation has {@link requestBody}, method must not\nbe `get`.\n\nAlso, even though the API operation has been designed to only get\ninformation, but it needs complicated request information, it must be\ndefined as `patch` method with {@link requestBody} data specification.\n\n- `get`: get information\n- `patch`: get information with complicated request data\n  ({@link requestBody})\n- `post`: create new record\n- `put`: update existing record\n- `delete`: remove record",
                                         oneOf: [
                                             {
                                                 "const": "get"
@@ -1299,12 +1284,11 @@ const collection = {
                                     }
                                 },
                                 required: [
-                                    "prisma_schemas",
                                     "authorizationRoles",
-                                    "description",
                                     "name",
                                     "specification",
                                     "summary",
+                                    "description",
                                     "path",
                                     "parameters",
                                     "requestBody",
@@ -1496,7 +1480,7 @@ const collection = {
                         }
                     },
                     description: "Generate detailed API operations from path/method combinations.\n\nThis function creates complete API operations following REST principles and\nquality standards. Each generated operation includes specification, path,\nmethod, detailed multi-paragraph description, concise summary, parameters,\nand appropriate request/response bodies.\n\nThe function processes as many operations as possible in a single call,\nwith progress tracking to ensure iterative completion of all required\nendpoints.",
-                    validate: (() => { const _io0 = input => Array.isArray(input.operations) && input.operations.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.prisma_schemas && (Array.isArray(input.authorizationRoles) && input.authorizationRoles.every(elem => "string" === typeof elem && (RegExp("^[a-z][a-zA-Z0-9]*$").test(elem) && 1 <= elem.length))) && "string" === typeof input.description && ("string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name)) && "string" === typeof input.specification && "string" === typeof input.summary && ("string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path)) && (Array.isArray(input.parameters) && input.parameters.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (null === input.requestBody || "object" === typeof input.requestBody && null !== input.requestBody && _io6(input.requestBody)) && (null === input.responseBody || "object" === typeof input.responseBody && null !== input.responseBody && _io7(input.responseBody)) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description && ("object" === typeof input.schema && null !== input.schema && _iu0(input.schema)); const _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _io7 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _iu0 = input => (() => {
+                    validate: (() => { const _io0 = input => Array.isArray(input.operations) && input.operations.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => Array.isArray(input.authorizationRoles) && input.authorizationRoles.every(elem => "string" === typeof elem && (RegExp("^[a-z][a-zA-Z0-9]*$").test(elem) && 1 <= elem.length)) && ("string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name)) && "string" === typeof input.specification && "string" === typeof input.summary && "string" === typeof input.description && ("string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path)) && (Array.isArray(input.parameters) && input.parameters.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (null === input.requestBody || "object" === typeof input.requestBody && null !== input.requestBody && _io6(input.requestBody)) && (null === input.responseBody || "object" === typeof input.responseBody && null !== input.responseBody && _io7(input.responseBody)) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description && ("object" === typeof input.schema && null !== input.schema && _iu0(input.schema)); const _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _io7 = input => "string" === typeof input.description && "string" === typeof input.typeName; const _iu0 = input => (() => {
                         if ("number" === input.type)
                             return _io4(input);
                         else if ("integer" === input.type)
@@ -1521,11 +1505,7 @@ const collection = {
                             path: _path + ".operations",
                             expected: "Array<IAutoBeInterfaceOperationApplication.IOperation>",
                             value: input.operations
-                        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.prisma_schemas || _report(_exceptionable, {
-                            path: _path + ".prisma_schemas",
-                            expected: "string",
-                            value: input.prisma_schemas
-                        }), (Array.isArray(input.authorizationRoles) || _report(_exceptionable, {
+                        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [(Array.isArray(input.authorizationRoles) || _report(_exceptionable, {
                             path: _path + ".authorizationRoles",
                             expected: "Array<string & CamelPattern & MinLength<1>>",
                             value: input.authorizationRoles
@@ -1545,10 +1525,6 @@ const collection = {
                             path: _path + ".authorizationRoles",
                             expected: "Array<string & CamelPattern & MinLength<1>>",
                             value: input.authorizationRoles
-                        }), "string" === typeof input.description || _report(_exceptionable, {
-                            path: _path + ".description",
-                            expected: "string",
-                            value: input.description
                         }), "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                             path: _path + ".name",
                             expected: "string & CamelPattern",
@@ -1565,6 +1541,10 @@ const collection = {
                             path: _path + ".summary",
                             expected: "string",
                             value: input.summary
+                        }), "string" === typeof input.description || _report(_exceptionable, {
+                            path: _path + ".description",
+                            expected: "string",
+                            value: input.description
                         }), "string" === typeof input.path && (RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) || _report(_exceptionable, {
                             path: _path + ".path",
                             expected: "string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">",

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceOperations.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrateInterfaceOperations.js","sourceRoot":"","sources":["../../../../../src/orchestrate/interface/orchestrateInterfaceOperations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"orchestrateInterfaceOperations.js","sourceRoot":"","sources":["../../../../../src/orchestrate/interface/orchestrateInterfaceOperations.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,wEAkCC;;;AApDD,yCAAqE;AAErE,+BAAkD;AAClD,kDAA0B;AAC1B,qDAAkD;AAClD,uEAAoE;AACpE,+BAA0B;AAG1B,uEAAoE;AACpE,yDAAsD;AACtD,uDAAoD;AACpD,uEAAoE;AACpE,2GAAwG;AACxG,iGAA8F;AAE9F,iFAA8E;AAE9E,SAAsB,8BAA8B;yDAGlD,GAAyB,EACzB,SAAoC,EACpC,WAAmB,CAAC;QAEpB,MAAM,MAAM,GAAgC,IAAA,yBAAW,EAAC;YACtD,KAAK,EAAE,SAAS;YAChB,QAAQ;SACT,CAAC,CAAC;QAEH,MAAM,QAAQ,GAA4B;YACxC,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM;YAC3B,SAAS,EAAE,CAAC;SACb,CAAC;QACF,MAAM,cAAc,GAA4B;YAC9C,KAAK,EAAE,MAAM,CAAC,MAAM;YACpB,SAAS,EAAE,CAAC;SACb,CAAC;QACF,OAAO,CACL,MAAM,IAAA,uCAAkB,EACtB,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAO,cAAc,EAAE,EAAE;YAC1C,MAAM,GAAG,GAA+B,MAAM,gBAAgB,CAC5D,GAAG,EACH,EAAE,EACF,QAAQ,EACR,cAAc,EACd,cAAc,CACf,CAAC;YACF,OAAO,GAAG,CAAC;QACb,CAAC,CAAA,CAAC,CACH,CACF,CAAC,IAAI,EAAE,CAAC;IACX,CAAC;CAAA;AAED,SAAe,gBAAgB,CAC7B,GAAyB,EACzB,SAAoC,EACpC,kBAA2C,EAC3C,wBAAiD,EACjD,cAAsB;;QAEtB,MAAM,QAAQ,GAAqC,IAAI,cAAO,CAC5D,SAAS,EACT,qDAAyB,CAAC,QAAQ,EAClC,qDAAyB,CAAC,MAAM,CACjC,CAAC;QACF,MAAM,MAAM,GACV,IAAI,cAAO,CACT,qDAAyB,CAAC,QAAQ,EAClC,qDAAyB,CAAC,MAAM,CACjC,CAAC;QACJ,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC;YAC3C,IAAI,QAAQ,CAAC,KAAK,EAAE,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC,MAAM;gBAAE,MAAM;YAC1E,MAAM,UAAU,GAA+B,QAAQ,CAAC,IAAI,EAAE;gBAC5D,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,kBAAkB,EAAE,cAAc,CAAC;gBAClE,CAAC,CAAC,EAAE,CAAC;YAEP,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;gBAC9B,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBACvB,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;QACD,MAAM,MAAM,GACV,MAAM,IAAA,2EAAoC,EACxC,GAAG,EACH,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,EACtC,wBAAwB,CACzB,CAAC;QACJ,KAAK,MAAM,IAAI,IAAI,MAAM;YAAE,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAClD,OAAO,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;CAAA;AAED,SAAe,OAAO,CACpB,GAAyB,EACzB,SAA2C,EAC3C,QAAiC,EACjC,cAAsB;;;QAEtB,MAAM,MAAM,GAAW,mCAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,OAAQ,CAAC,MAAM,CAAC,CAAC;QAC3E,MAAM,OAAO,GAAgD;YAC3D,KAAK,EAAE,IAAI;SACZ,CAAC;QACF,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;YAC1C,MAAM,EAAE,qBAAqB;YAC7B,SAAS,EAAE,IAAA,2EAAoC,EAC7C,GAAG,CAAC,KAAK,EAAE,EACX,SAAS,CAAC,MAAM,EAAE,CACnB;YACD,UAAU,EAAE,gBAAgB,CAAC;gBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,KAAK,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,mCAAI,EAAE;gBAC5D,KAAK,EAAE,CAAC,UAAU,EAAE,EAAE;;oBACpB,MAAA,OAAO,CAAC,KAAK,oCAAb,OAAO,CAAC,KAAK,GAAK,EAAE,EAAC;oBACrB,MAAM,MAAM,GAAiC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE;wBACjE,IAAI,EAAE,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC;4BACpC,OAAO;gEAEA,EAAE,KACL,IAAI,EACF,GAAG;wCACH,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;6CAC5B,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC;6CACzB,IAAI,CAAC,GAAG,CAAC,EACd,iBAAiB,EAAE,IAAI,EACvB,iBAAiB,EAAE,IAAI;6BAE1B,CAAC;wBACJ,OAAO,EAAE,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iCACtC,EAAE,KACL,IAAI,EACF,GAAG;gCACH,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;qCAClC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC;qCACzB,IAAI,CAAC,GAAG,CAAC,EACd,iBAAiB,EAAE,IAAI,EACvB,iBAAiB,EAAE,IAAI,IACvB,CAAC,CAAC;oBACN,CAAC,CAAC,CAAC;oBACH,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;oBACrC,QAAQ,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC;oBAC3C,QAAQ,CAAC,KAAK,IAAI,UAAU;yBACzB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CACV,SAAS,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;wBACjD,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC;4BAClC,CAAC,CAAC,CAAC;4BACH,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC;wBACpC,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,MAAM,CACjC;yBACA,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;gBAChC,CAAC;aACF,CAAC;YACF,mBAAmB,EAAE,IAAI;YACzB,cAAc;YACd,OAAO,EAAE,qBAAqB;SAC/B,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAC,oBAAoB;QAEjG,GAAG,CAAC,QAAQ,CAAC,8BACX,IAAI,EAAE,qBAAqB,EAC3B,EAAE,EAAE,IAAA,SAAE,GAAE,EACR,UAAU,EAAE,OAAO,CAAC,KAAK,EACzB,UAAU,IACP,QAAQ,KACX,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC,EACpC,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,GACI,CAAC,CAAC;QAC5C,OAAO,OAAO,CAAC,KAAK,CAAC;IACvB,CAAC;CAAA;AAED,SAAS,gBAAgB,CAAiC,KAMzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,QAAQ,GAAG,CACf,IAAa,EAC6C,EAAE;QAC5D,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBACkD,IAAI,CAAC,CAAC;QACpE,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK;YAAE,OAAO,MAAM,CAAC;QAE5C,MAAM,UAAU,GACd,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;QACzB,MAAM,MAAM,GAAyB,EAAE,CAAC;QACxC,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;YAC3B,8BAA8B;YAC9B,IAAI,EAAE,CAAC,MAAM,KAAK,KAAK,IAAI,EAAE,CAAC,WAAW,KAAK,IAAI;gBAChD,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,qBAAqB,CAAC,eAAe;oBAC3C,QAAQ,EACN,qFAAqF;oBACvF,KAAK,EAAE,EAAE,CAAC,WAAW;iBACtB,CAAC,CAAC;YACL,iBAAiB;YACjB,IAAI,iBAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,KAAK;gBACrC,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,qBAAqB,CAAC,QAAQ;oBACpC,QAAQ,EAAE,uBAAuB;oBACjC,KAAK,EAAE,EAAE,CAAC,IAAI;oBACd,WAAW,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;oDAKc,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC;;;WAGhE;iBACF,CAAC,CAAC;YACL,iBAAiB;YACjB,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,EAAE,CAAC,kBAAkB,GAAG,EAAE,CAAC;iBACpD,IAAI,EAAE,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;gBACrE,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;oBACxC,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,IAAI;wBAAE,OAAO;oBAChD,MAAM,CAAC,IAAI,CAAC;wBACV,IAAI,EAAE,qBAAqB,CAAC,wBAAwB,CAAC,GAAG;wBACxD,QAAQ,EAAE,UAAU,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;wBAC/E,WAAW,EAAE,kBAAU,CAAC,IAAI,CAAA;sBAClB,IAAI;;;;gBAIV,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;aACpD;wBACD,KAAK,EAAE,IAAI;qBACZ,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,gCAAgC;QAChC,MAAM,SAAS,GAA+C,IAAI,cAAO,CACvE,gCAAwB,CAAC,QAAQ,EACjC,gCAAwB,CAAC,MAAM,CAChC,CAAC;QACF,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;YAC3B,MAAM,GAAG,GAA4B;gBACnC,IAAI,EAAE,EAAE,CAAC,IAAI;gBACb,MAAM,EAAE,EAAE,CAAC,MAAM;aAClB,CAAC;YACF,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,KAAK,KAAK,EAAE,CAAC;gBACzC,MAAM,OAAO,GAAa,EAAE,CAAC,MAAM,CAAC;gBACpC,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,qBAAqB,CAAC,qBAAqB;oBACjD,QAAQ,EAAE,mCAAmC;oBAC7C,KAAK,EAAE,GAAG;oBACV,WAAW,EAAE,kBAAU,CAAC,IAAI,CAAA;oDACc,EAAE,CAAC,MAAM,WAAW,EAAE,CAAC,IAAI;;;;;cAKjE,OAAO;yBACN,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,wBAAwB,GAAG,qBAAqB,CAAC;yBAC9D,IAAI,CAAC,IAAI,CAAC;WACd;iBACF,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC;;gBAAM,SAAS,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,mCAAmC;QACnC,MAAM,SAAS,GAA0B,IAAI,GAAG,EAAE,CAAC;QACnD,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE;YAC3B,MAAM,GAAG,GACP,EAAE,CAAC,IAAI;iBACJ,KAAK,CAAC,GAAG,CAAC;iBACV,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC;iBAC/C,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;iBAC7B,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;YAC/B,MAAM,OAAO,GAAa,IAAA,uBAAU,EAAC,SAAS,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YAC/D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACzB,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,qBAAqB,CAAC,QAAQ;oBACpC,QAAQ,EAAE,yCAAyC;oBACnD,KAAK,EAAE,EAAE,CAAC,IAAI;oBACd,WAAW,EAAE,kBAAU,CAAC,IAAI,CAAA;4DACsB,EAAE,CAAC,IAAI,eAAe,GAAG;;;;;;;;;cASvE,OAAO;yBACN,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,eAAe,GAAG,GAAG,CAAC;yBAC5D,IAAI,CAAC,IAAI,CAAC;WACd;iBACF,CAAC,CAAC;YACL,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YACrB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,MAAM;gBACN,IAAI,EAAE,IAAI;aACX,CAAC;QACJ,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IACF,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CACjD,CACC,QAAQ,CAC2D,CAAC;IAEtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,WAAW;QACjB,WAAW;QACX,OAAO,EAAE;YACP,cAAc,EAAE,CAAC,IAAI,EAAE,EAAE;gBACvB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/B,CAAC;SAC6C;KACjD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,GAAG;IACjB,OAAO,EAAE,CAAC,QAAmB,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uHACwC;YACrE,QAAQ,EAAE;gBACR,cAAc,EAAE,QAAQ;aACzB;SACF;;QAAC;IACJ,MAAM,EAAE,CAAC,QAAmB,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uHACwC;YACpE,QAAQ,EAAE;gBACR,cAAc,EAAE,QAAQ;aACzB;SACF;;QAAC;CACL,CAAC"}