@autobe/agent 0.28.1 → 0.29.1

package/lib/orchestrate/interface/orchestrateInterfaceEndpointsReview.js

@@ -1,488 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.orchestrateInterfaceEndpointsReview = orchestrateInterfaceEndpointsReview;
-const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
-const typia_1 = __importDefault(require("typia"));
-const uuid_1 = require("uuid");
-const assertSchemaModel_1 = require("../../context/assertSchemaModel");
-const transformInterfaceEndpointsReviewHistories_1 = require("./histories/transformInterfaceEndpointsReviewHistories");
-function orchestrateInterfaceEndpointsReview(ctx_1, endpoints_1) {
-    return __awaiter(this, arguments, void 0, function* (ctx, endpoints, message = `Review the generated endpoints`) {
-        var _a, _b, _c, _d, _e;
-        const pointer = {
-            value: null,
-        };
-        const { metric, tokenUsage } = yield ctx.conversate({
-            source: "interfaceEndpointReview",
-            histories: (0, transformInterfaceEndpointsReviewHistories_1.transformInterfaceEndpointsReviewHistories)(ctx.state(), endpoints),
-            controller: createController({
-                model: ctx.model,
-                build: (props) => {
-                    pointer.value = props;
-                },
-            }),
-            enforceFunctionCall: true,
-            message,
-        });
-        if (pointer.value === null) {
-            return endpoints;
-        }
-        const response = (_b = (_a = pointer.value) === null || _a === void 0 ? void 0 : _a.endpoints) !== null && _b !== void 0 ? _b : [];
-        ctx.dispatch({
-            id: (0, uuid_1.v7)(),
-            type: "interfaceEndpointReview",
-            endpoints,
-            content: response,
-            created_at: new Date().toISOString(),
-            review: (_c = pointer.value) === null || _c === void 0 ? void 0 : _c.review,
-            step: (_e = (_d = ctx.state().analyze) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0,
-            metric,
-            tokenUsage,
-        });
-        return response;
-    });
-}
-function createController(props) {
-    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
-    const application = collection[props.model === "chatgpt"
-        ? "chatgpt"
-        : props.model === "gemini"
-            ? "gemini"
-            : "claude"];
-    return {
-        protocol: "class",
-        name: "interface",
-        application,
-        execute: {
-            reviewEndpoints: (next) => {
-                props.build(next);
-            },
-        },
-    };
-}
-const collection = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [
-            {
-                name: "reviewEndpoints",
-                parameters: {
-                    description: " - The review results and refined endpoint collection\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceEndpointsReviewApplication.IProps}",
-                    type: "object",
-                    properties: {
-                        review: {
-                            description: "Comprehensive review analysis of all collected endpoints.\n\nContains detailed findings from the holistic review including:\n- Identified inconsistencies in naming conventions\n- Duplicate endpoints that serve the same purpose\n- Over-engineered solutions that add unnecessary complexity\n- Violations of REST API design principles\n- Recommendations for improvement and standardization\n\nThe review provides actionable feedback for creating a clean,\nconsistent, and maintainable API structure.",
-                            type: "string"
-                        },
-                        endpoints: {
-                            description: "Refined collection of API endpoints after review and cleanup.\n\nThe final optimized set of endpoints after:\n- Removing duplicates and redundant endpoints\n- Standardizing naming conventions across all paths\n- Simplifying over-engineered solutions\n- Ensuring consistent REST patterns\n- Aligning HTTP methods with their semantic meanings\n\nThis collection represents the production-ready API structure\nthat balances functionality with simplicity and maintainability.",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/AutoBeOpenApi.IEndpoint"
-                            }
-                        }
-                    },
-                    required: [
-                        "review",
-                        "endpoints"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        "AutoBeOpenApi.IEndpoint": {
-                            description: "API endpoint information.",
-                            type: "object",
-                            properties: {
-                                path: {
-                                    description: "HTTP path of the API operation.\n\nThe URL path for accessing this API operation, using path parameters\nenclosed in curly braces (e.g., `/shoppings/customers/sales/{saleId}`).\n\nIt must be corresponded to the {@link parameters path parameters}.\n\nThe path structure should clearly indicate which database entity this\noperation is manipulating, helping to ensure all entities have\nappropriate API coverage.\n\nPath validation rules:\n\n- Must start with a forward slash (/)\n- Can contain only: letters (a-z, A-Z), numbers (0-9), forward slashes (/),\n  curly braces for parameters ({paramName}), hyphens (-), and underscores\n  (_)\n- Parameters must be enclosed in curly braces: {paramName}\n- Resource names should be in camelCase\n- No quotes, spaces, or invalid special characters allowed\n- No domain or role-based prefixes\n\nValid examples:\n\n- \"/users\"\n- \"/users/{userId}\"\n- \"/articles/{articleId}/comments\"\n- \"/attachmentFiles\"\n- \"/orders/{orderId}/items/{itemId}\"\n\nInvalid examples:\n\n- \"'/users'\" (contains quotes)\n- \"/user profile\" (contains space)\n- \"/users/[userId]\" (wrong bracket format)\n- \"/admin/users\" (role prefix)\n- \"/api/v1/users\" (API prefix)\n\n\n@pattern ^\\/[a-zA-Z0-9\\/_{}.-]*$",
-                                    type: "string"
-                                },
-                                method: {
-                                    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",
-                                        "post",
-                                        "put",
-                                        "delete",
-                                        "patch"
-                                    ]
-                                }
-                            },
-                            required: [
-                                "path",
-                                "method"
-                            ]
-                        }
-                    }
-                },
-                description: "Reviews and refines the complete collection of API endpoints.\n\nThis method consolidates all endpoints generated independently by different\ngroups and performs holistic review to:\n- Ensure naming consistency across all endpoints\n- Remove duplicate or overlapping endpoints\n- Eliminate over-engineered solutions\n- Standardize path structures and HTTP methods\n- Verify REST API design principles\n\nThe review process examines the entire API as a cohesive system rather\nthan individual endpoints, ensuring the final API is intuitive, maintainable,\nand follows best practices.",
-                validate: (() => { const _io0 = input => "string" === typeof input.review && (Array.isArray(input.endpoints) && input.endpoints.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.review || _report(_exceptionable, {
-                        path: _path + ".review",
-                        expected: "string",
-                        value: input.review
-                    }), (Array.isArray(input.endpoints) || _report(_exceptionable, {
-                        path: _path + ".endpoints",
-                        expected: "Array<AutoBeOpenApi.IEndpoint>",
-                        value: input.endpoints
-                    })) && input.endpoints.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".endpoints[" + _index2 + "]",
-                        expected: "AutoBeOpenApi.IEndpoint",
-                        value: elem
-                    })) && _vo1(elem, _path + ".endpoints[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".endpoints[" + _index2 + "]",
-                        expected: "AutoBeOpenApi.IEndpoint",
-                        value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
-                        path: _path + ".endpoints",
-                        expected: "Array<AutoBeOpenApi.IEndpoint>",
-                        value: input.endpoints
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.path && (RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) || _report(_exceptionable, {
-                        path: _path + ".path",
-                        expected: "string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">",
-                        value: input.path
-                    })) || _report(_exceptionable, {
-                        path: _path + ".path",
-                        expected: "(string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">)",
-                        value: input.path
-                    }), "get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method || _report(_exceptionable, {
-                        path: _path + ".method",
-                        expected: "(\"delete\" | \"get\" | \"patch\" | \"post\" | \"put\")",
-                        value: input.method
-                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceEndpointsReviewApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceEndpointsReviewApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
-                            data: input
-                        };
-                    }
-                    return {
-                        success: true,
-                        data: input
-                    };
-                }; })()
-            }
-        ]
-    },
-    claude: {
-        model: "claude",
-        options: {
-            reference: true,
-            separate: null
-        },
-        functions: [
-            {
-                name: "reviewEndpoints",
-                parameters: {
-                    description: " - The review results and refined endpoint collection\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceEndpointsReviewApplication.IProps}",
-                    type: "object",
-                    properties: {
-                        review: {
-                            description: "Comprehensive review analysis of all collected endpoints.\n\nContains detailed findings from the holistic review including:\n- Identified inconsistencies in naming conventions\n- Duplicate endpoints that serve the same purpose\n- Over-engineered solutions that add unnecessary complexity\n- Violations of REST API design principles\n- Recommendations for improvement and standardization\n\nThe review provides actionable feedback for creating a clean,\nconsistent, and maintainable API structure.",
-                            type: "string"
-                        },
-                        endpoints: {
-                            description: "Refined collection of API endpoints after review and cleanup.\n\nThe final optimized set of endpoints after:\n- Removing duplicates and redundant endpoints\n- Standardizing naming conventions across all paths\n- Simplifying over-engineered solutions\n- Ensuring consistent REST patterns\n- Aligning HTTP methods with their semantic meanings\n\nThis collection represents the production-ready API structure\nthat balances functionality with simplicity and maintainability.",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/AutoBeOpenApi.IEndpoint"
-                            }
-                        }
-                    },
-                    required: [
-                        "review",
-                        "endpoints"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        "AutoBeOpenApi.IEndpoint": {
-                            description: "API endpoint information.",
-                            type: "object",
-                            properties: {
-                                path: {
-                                    description: "HTTP path of the API operation.\n\nThe URL path for accessing this API operation, using path parameters\nenclosed in curly braces (e.g., `/shoppings/customers/sales/{saleId}`).\n\nIt must be corresponded to the {@link parameters path parameters}.\n\nThe path structure should clearly indicate which database entity this\noperation is manipulating, helping to ensure all entities have\nappropriate API coverage.\n\nPath validation rules:\n\n- Must start with a forward slash (/)\n- Can contain only: letters (a-z, A-Z), numbers (0-9), forward slashes (/),\n  curly braces for parameters ({paramName}), hyphens (-), and underscores\n  (_)\n- Parameters must be enclosed in curly braces: {paramName}\n- Resource names should be in camelCase\n- No quotes, spaces, or invalid special characters allowed\n- No domain or role-based prefixes\n\nValid examples:\n\n- \"/users\"\n- \"/users/{userId}\"\n- \"/articles/{articleId}/comments\"\n- \"/attachmentFiles\"\n- \"/orders/{orderId}/items/{itemId}\"\n\nInvalid examples:\n\n- \"'/users'\" (contains quotes)\n- \"/user profile\" (contains space)\n- \"/users/[userId]\" (wrong bracket format)\n- \"/admin/users\" (role prefix)\n- \"/api/v1/users\" (API prefix)",
-                                    type: "string",
-                                    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\",\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"
-                                        },
-                                        {
-                                            "const": "post"
-                                        },
-                                        {
-                                            "const": "put"
-                                        },
-                                        {
-                                            "const": "delete"
-                                        },
-                                        {
-                                            "const": "patch"
-                                        }
-                                    ]
-                                }
-                            },
-                            required: [
-                                "path",
-                                "method"
-                            ]
-                        }
-                    }
-                },
-                description: "Reviews and refines the complete collection of API endpoints.\n\nThis method consolidates all endpoints generated independently by different\ngroups and performs holistic review to:\n- Ensure naming consistency across all endpoints\n- Remove duplicate or overlapping endpoints\n- Eliminate over-engineered solutions\n- Standardize path structures and HTTP methods\n- Verify REST API design principles\n\nThe review process examines the entire API as a cohesive system rather\nthan individual endpoints, ensuring the final API is intuitive, maintainable,\nand follows best practices.",
-                validate: (() => { const _io0 = input => "string" === typeof input.review && (Array.isArray(input.endpoints) && input.endpoints.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.review || _report(_exceptionable, {
-                        path: _path + ".review",
-                        expected: "string",
-                        value: input.review
-                    }), (Array.isArray(input.endpoints) || _report(_exceptionable, {
-                        path: _path + ".endpoints",
-                        expected: "Array<AutoBeOpenApi.IEndpoint>",
-                        value: input.endpoints
-                    })) && input.endpoints.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".endpoints[" + _index2 + "]",
-                        expected: "AutoBeOpenApi.IEndpoint",
-                        value: elem
-                    })) && _vo1(elem, _path + ".endpoints[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".endpoints[" + _index2 + "]",
-                        expected: "AutoBeOpenApi.IEndpoint",
-                        value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
-                        path: _path + ".endpoints",
-                        expected: "Array<AutoBeOpenApi.IEndpoint>",
-                        value: input.endpoints
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.path && (RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) || _report(_exceptionable, {
-                        path: _path + ".path",
-                        expected: "string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">",
-                        value: input.path
-                    })) || _report(_exceptionable, {
-                        path: _path + ".path",
-                        expected: "(string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">)",
-                        value: input.path
-                    }), "get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method || _report(_exceptionable, {
-                        path: _path + ".method",
-                        expected: "(\"delete\" | \"get\" | \"patch\" | \"post\" | \"put\")",
-                        value: input.method
-                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceEndpointsReviewApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceEndpointsReviewApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
-                            data: input
-                        };
-                    }
-                    return {
-                        success: true,
-                        data: input
-                    };
-                }; })()
-            }
-        ]
-    },
-    gemini: {
-        model: "gemini",
-        options: {
-            reference: true,
-            separate: null
-        },
-        functions: [
-            {
-                name: "reviewEndpoints",
-                parameters: {
-                    description: " - The review results and refined endpoint collection\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceEndpointsReviewApplication.IProps}",
-                    type: "object",
-                    properties: {
-                        review: {
-                            description: "Comprehensive review analysis of all collected endpoints.\n\nContains detailed findings from the holistic review including:\n- Identified inconsistencies in naming conventions\n- Duplicate endpoints that serve the same purpose\n- Over-engineered solutions that add unnecessary complexity\n- Violations of REST API design principles\n- Recommendations for improvement and standardization\n\nThe review provides actionable feedback for creating a clean,\nconsistent, and maintainable API structure.",
-                            type: "string"
-                        },
-                        endpoints: {
-                            description: "Refined collection of API endpoints after review and cleanup.\n\nThe final optimized set of endpoints after:\n- Removing duplicates and redundant endpoints\n- Standardizing naming conventions across all paths\n- Simplifying over-engineered solutions\n- Ensuring consistent REST patterns\n- Aligning HTTP methods with their semantic meanings\n\nThis collection represents the production-ready API structure\nthat balances functionality with simplicity and maintainability.",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/AutoBeOpenApi.IEndpoint"
-                            }
-                        }
-                    },
-                    required: [
-                        "review",
-                        "endpoints"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        "AutoBeOpenApi.IEndpoint": {
-                            description: "API endpoint information.",
-                            type: "object",
-                            properties: {
-                                path: {
-                                    description: "HTTP path of the API operation.\n\nThe URL path for accessing this API operation, using path parameters\nenclosed in curly braces (e.g., `/shoppings/customers/sales/{saleId}`).\n\nIt must be corresponded to the {@link parameters path parameters}.\n\nThe path structure should clearly indicate which database entity this\noperation is manipulating, helping to ensure all entities have\nappropriate API coverage.\n\nPath validation rules:\n\n- Must start with a forward slash (/)\n- Can contain only: letters (a-z, A-Z), numbers (0-9), forward slashes (/),\n  curly braces for parameters ({paramName}), hyphens (-), and underscores\n  (_)\n- Parameters must be enclosed in curly braces: {paramName}\n- Resource names should be in camelCase\n- No quotes, spaces, or invalid special characters allowed\n- No domain or role-based prefixes\n\nValid examples:\n\n- \"/users\"\n- \"/users/{userId}\"\n- \"/articles/{articleId}/comments\"\n- \"/attachmentFiles\"\n- \"/orders/{orderId}/items/{itemId}\"\n\nInvalid examples:\n\n- \"'/users'\" (contains quotes)\n- \"/user profile\" (contains space)\n- \"/users/[userId]\" (wrong bracket format)\n- \"/admin/users\" (role prefix)\n- \"/api/v1/users\" (API prefix)",
-                                    type: "string",
-                                    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\",\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",
-                                        "post",
-                                        "put",
-                                        "delete",
-                                        "patch"
-                                    ]
-                                }
-                            },
-                            required: [
-                                "path",
-                                "method"
-                            ]
-                        }
-                    }
-                },
-                description: "Reviews and refines the complete collection of API endpoints.\n\nThis method consolidates all endpoints generated independently by different\ngroups and performs holistic review to:\n- Ensure naming consistency across all endpoints\n- Remove duplicate or overlapping endpoints\n- Eliminate over-engineered solutions\n- Standardize path structures and HTTP methods\n- Verify REST API design principles\n\nThe review process examines the entire API as a cohesive system rather\nthan individual endpoints, ensuring the final API is intuitive, maintainable,\nand follows best practices.",
-                validate: (() => { const _io0 = input => "string" === typeof input.review && (Array.isArray(input.endpoints) && input.endpoints.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.review || _report(_exceptionable, {
-                        path: _path + ".review",
-                        expected: "string",
-                        value: input.review
-                    }), (Array.isArray(input.endpoints) || _report(_exceptionable, {
-                        path: _path + ".endpoints",
-                        expected: "Array<AutoBeOpenApi.IEndpoint>",
-                        value: input.endpoints
-                    })) && input.endpoints.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".endpoints[" + _index2 + "]",
-                        expected: "AutoBeOpenApi.IEndpoint",
-                        value: elem
-                    })) && _vo1(elem, _path + ".endpoints[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".endpoints[" + _index2 + "]",
-                        expected: "AutoBeOpenApi.IEndpoint",
-                        value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
-                        path: _path + ".endpoints",
-                        expected: "Array<AutoBeOpenApi.IEndpoint>",
-                        value: input.endpoints
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.path && (RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) || _report(_exceptionable, {
-                        path: _path + ".path",
-                        expected: "string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">",
-                        value: input.path
-                    })) || _report(_exceptionable, {
-                        path: _path + ".path",
-                        expected: "(string & Pattern<\"^\\\\/[a-zA-Z0-9\\\\/_{}.-]*$\">)",
-                        value: input.path
-                    }), "get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method || _report(_exceptionable, {
-                        path: _path + ".method",
-                        expected: "(\"delete\" | \"get\" | \"patch\" | \"post\" | \"put\")",
-                        value: input.method
-                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceEndpointsReviewApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceEndpointsReviewApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
-                            data: input
-                        };
-                    }
-                    return {
-                        success: true,
-                        data: input
-                    };
-                }; })()
-            }
-        ]
-    },
-};
-//# sourceMappingURL=orchestrateInterfaceEndpointsReview.js.map

package/lib/orchestrate/interface/orchestrateInterfaceEndpointsReview.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrateInterfaceEndpointsReview.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/orchestrateInterfaceEndpointsReview.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,kFA6CC;;AArDD,kDAA0B;AAC1B,+BAA0B;AAG1B,uEAAoE;AACpE,uHAAoH;AAGpH,SAAsB,mCAAmC;yDAGvD,GAAyB,EACzB,SAAoC,EACpC,UAAkB,gCAAgC;;QAElD,MAAM,OAAO,GACX;YACE,KAAK,EAAE,IAAI;SACZ,CAAC;QAEJ,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;YAClD,MAAM,EAAE,yBAAyB;YACjC,SAAS,EAAE,IAAA,uFAA0C,EACnD,GAAG,CAAC,KAAK,EAAE,EACX,SAAS,CACV;YACD,UAAU,EAAE,gBAAgB,CAAC;gBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;oBACf,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;gBACxB,CAAC;aACF,CAAC;YACF,mBAAmB,EAAE,IAAI;YACzB,OAAO;SACR,CAAC,CAAC;QAEH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YAC3B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,QAAQ,GAAG,MAAA,MAAA,OAAO,CAAC,KAAK,0CAAE,SAAS,mCAAI,EAAE,CAAC;QAChD,GAAG,CAAC,QAAQ,CAAC;YACX,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,IAAI,EAAE,yBAAyB;YAC/B,SAAS;YACT,OAAO,EAAE,QAAQ;YACjB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,MAAM,EAAE,MAAA,OAAO,CAAC,KAAK,0CAAE,MAAM;YAC7B,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;YACpC,MAAM;YACN,UAAU;SACX,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;CAAA;AAED,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,KAAK,SAAS;QACvB,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ;YACxB,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,QAAQ,CACqD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,WAAW;QACjB,WAAW;QACX,OAAO,EAAE;YACP,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE;gBACxB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SACmD;KACvD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGJ;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;CACJ,CAAC"}