@autobe/agent 0.28.1 → 0.29.0

package/lib/orchestrate/interface/orchestrateInterfaceGroups.js

@@ -1,458 +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.orchestrateInterfaceGroups = orchestrateInterfaceGroups;
-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 transformInterfaceGroupHistories_1 = require("./histories/transformInterfaceGroupHistories");
-function orchestrateInterfaceGroups(ctx, props) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const start = new Date();
-        const pointer = {
-            value: null,
-        };
-        const { metric, tokenUsage } = yield ctx.conversate({
-            source: "interfaceGroup",
-            histories: (0, transformInterfaceGroupHistories_1.transformInterfaceGroupHistories)({
-                state: ctx.state(),
-                instruction: props.instruction,
-            }),
-            controller: createController({
-                model: ctx.model,
-                build: (next) => {
-                    pointer.value = next;
-                },
-            }),
-            enforceFunctionCall: true,
-            message: (_a = props.message) !== null && _a !== void 0 ? _a : "Design API operations for the given assets.",
-        });
-        if (pointer.value === null)
-            throw new Error("Failed to generate groups."); // unreachable
-        return {
-            type: "interfaceGroup",
-            id: (0, uuid_1.v7)(),
-            created_at: start.toISOString(),
-            groups: pointer.value.groups,
-            metric,
-            tokenUsage,
-            step: (_c = (_b = ctx.state().analyze) === null || _b === void 0 ? void 0 : _b.step) !== null && _c !== void 0 ? _c : 0,
-        };
-    });
-}
-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: {
-            makeGroups: (next) => {
-                props.build(next);
-            },
-        },
-    };
-}
-const collection = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [
-            {
-                name: "makeGroups",
-                parameters: {
-                    description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
-                    type: "object",
-                    properties: {
-                        groups: {
-                            description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.\n\n\n@minItems 1",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
-                            }
-                        }
-                    },
-                    required: [
-                        "groups"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        "IAutoBeInterfaceGroupApplication.IGroup": {
-                            description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
-                            type: "object",
-                            properties: {
-                                name: {
-                                    description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.\n\n\n@minLength 1",
-                                    type: "string"
-                                },
-                                description: {
-                                    description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"\n\n\n@minLength 1",
-                                    type: "string"
-                                }
-                            },
-                            required: [
-                                "name",
-                                "description"
-                            ]
-                        }
-                    }
-                },
-                description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
-                validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                        value: input.groups
-                    })) && ((1 <= input.groups.length || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "Array<> & MinItems<1>",
-                        value: input.groups
-                    })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".groups[" + _index2 + "]",
-                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                        value: elem
-                    })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".groups[" + _index2 + "]",
-                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                        value: elem
-                    })).every(flag => flag)) || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                        value: input.groups
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
-                        path: _path + ".name",
-                        expected: "string & MinLength<1>",
-                        value: input.name
-                    })) || _report(_exceptionable, {
-                        path: _path + ".name",
-                        expected: "(string & MinLength<1>)",
-                        value: input.name
-                    }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "string & MinLength<1>",
-                        value: input.description
-                    })) || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "(string & MinLength<1>)",
-                        value: input.description
-                    })].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: "IAutoBeInterfaceGroupApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceGroupApplication.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: "makeGroups",
-                parameters: {
-                    description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
-                    type: "object",
-                    properties: {
-                        groups: {
-                            description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
-                            },
-                            minItems: 1
-                        }
-                    },
-                    required: [
-                        "groups"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        "IAutoBeInterfaceGroupApplication.IGroup": {
-                            description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
-                            type: "object",
-                            properties: {
-                                name: {
-                                    description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.",
-                                    type: "string",
-                                    minLength: 1
-                                },
-                                description: {
-                                    description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"",
-                                    type: "string",
-                                    minLength: 1
-                                }
-                            },
-                            required: [
-                                "name",
-                                "description"
-                            ]
-                        }
-                    }
-                },
-                description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
-                validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                        value: input.groups
-                    })) && ((1 <= input.groups.length || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "Array<> & MinItems<1>",
-                        value: input.groups
-                    })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".groups[" + _index2 + "]",
-                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                        value: elem
-                    })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".groups[" + _index2 + "]",
-                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                        value: elem
-                    })).every(flag => flag)) || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                        value: input.groups
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
-                        path: _path + ".name",
-                        expected: "string & MinLength<1>",
-                        value: input.name
-                    })) || _report(_exceptionable, {
-                        path: _path + ".name",
-                        expected: "(string & MinLength<1>)",
-                        value: input.name
-                    }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "string & MinLength<1>",
-                        value: input.description
-                    })) || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "(string & MinLength<1>)",
-                        value: input.description
-                    })].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: "IAutoBeInterfaceGroupApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceGroupApplication.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: "makeGroups",
-                parameters: {
-                    description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
-                    type: "object",
-                    properties: {
-                        groups: {
-                            description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
-                            },
-                            minItems: 1
-                        }
-                    },
-                    required: [
-                        "groups"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        "IAutoBeInterfaceGroupApplication.IGroup": {
-                            description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
-                            type: "object",
-                            properties: {
-                                name: {
-                                    description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.",
-                                    type: "string",
-                                    minLength: 1
-                                },
-                                description: {
-                                    description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"",
-                                    type: "string",
-                                    minLength: 1
-                                }
-                            },
-                            required: [
-                                "name",
-                                "description"
-                            ]
-                        }
-                    }
-                },
-                description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
-                validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                        value: input.groups
-                    })) && ((1 <= input.groups.length || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "Array<> & MinItems<1>",
-                        value: input.groups
-                    })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".groups[" + _index2 + "]",
-                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                        value: elem
-                    })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".groups[" + _index2 + "]",
-                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                        value: elem
-                    })).every(flag => flag)) || _report(_exceptionable, {
-                        path: _path + ".groups",
-                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                        value: input.groups
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
-                        path: _path + ".name",
-                        expected: "string & MinLength<1>",
-                        value: input.name
-                    })) || _report(_exceptionable, {
-                        path: _path + ".name",
-                        expected: "(string & MinLength<1>)",
-                        value: input.name
-                    }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "string & MinLength<1>",
-                        value: input.description
-                    })) || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "(string & MinLength<1>)",
-                        value: input.description
-                    })].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: "IAutoBeInterfaceGroupApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeInterfaceGroupApplication.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=orchestrateInterfaceGroups.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrateInterfaceGroups.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/orchestrateInterfaceGroups.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,gEAsCC;;AA9CD,kDAA0B;AAC1B,+BAA0B;AAG1B,uEAAoE;AACpE,mGAAgG;AAGhG,SAAsB,0BAA0B,CAG9C,GAAyB,EACzB,KAGC;;;QAED,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;QAC/B,MAAM,OAAO,GAA6D;YACxE,KAAK,EAAE,IAAI;SACZ,CAAC;QACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;YAClD,MAAM,EAAE,gBAAgB;YACxB,SAAS,EAAE,IAAA,mEAAgC,EAAC;gBAC1C,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW;aAC/B,CAAC;YACF,UAAU,EAAE,gBAAgB,CAAC;gBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE;oBACd,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;gBACvB,CAAC;aACF,CAAC;YACF,mBAAmB,EAAE,IAAI;YACzB,OAAO,EAAE,MAAA,KAAK,CAAC,OAAO,mCAAI,6CAA6C;SACxE,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAC,cAAc;QACzF,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM;YAC5B,MAAM;YACN,UAAU;YACV,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;SACD,CAAC;IACxC,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,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;gBACnB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SACyC;KAC7C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGJ;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;CACJ,CAAC"}

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

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

package/lib/orchestrate/interface/orchestrateInterfaceOperationsReview.d.ts

@@ -1,4 +0,0 @@
-import { AutoBeOpenApi, AutoBeProgressEventBase } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceOperationsReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], progress: AutoBeProgressEventBase): Promise<AutoBeOpenApi.IOperation[]>;

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

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