@autobe/agent 0.3.24 → 0.4.0

package/lib/orchestrate/prisma/orchestratePrismaCorrect.js

@@ -0,0 +1,2010 @@
+"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.orchestratePrismaCorrect = orchestratePrismaCorrect;
+const __typia_transform__isUniqueItems = __importStar(require("typia/lib/internal/_isUniqueItems.js"));
+const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
+const core_1 = require("@agentica/core");
+const typia_1 = __importDefault(require("typia"));
+const assertSchemaModel_1 = require("../../context/assertSchemaModel");
+const transformPrismaCorrectHistories_1 = require("./transformPrismaCorrectHistories");
+function orchestratePrismaCorrect(ctx, application, retry = 8) {
+    return step(ctx, application, retry);
+}
+function step(ctx, application, life) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const result = yield ctx.compiler.prisma.validate(application);
+        if (result.success)
+            return result; // SUCCESS
+        // VALIDATION FAILED
+        const schemas = yield ctx.compiler.prisma.write(application);
+        ctx.dispatch({
+            type: "prismaValidate",
+            result,
+            schemas,
+            compiled: yield ctx.compiler.prisma.compile({
+                files: schemas,
+            }),
+            step: (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
+            created_at: new Date().toISOString(),
+        });
+        const pointer = {
+            value: null,
+        };
+        const agentica = new core_1.MicroAgentica({
+            model: ctx.model,
+            vendor: ctx.vendor,
+            config: Object.assign({}, ((_c = ctx.config) !== null && _c !== void 0 ? _c : {})),
+            histories: (0, transformPrismaCorrectHistories_1.transformPrismaCorrectHistories)(result),
+            tokenUsage: ctx.usage(),
+            controllers: [
+                createApplication({
+                    model: ctx.model,
+                    build: (next) => {
+                        pointer.value = next;
+                    },
+                }),
+            ],
+        });
+        agentica.on("request", (event) => {
+            if (event.body.tools) {
+                event.body.tool_choice = "required";
+            }
+        });
+        // REQUEST CORRECTION
+        yield agentica.conversate("Resolve the compilation errors in the provided Prisma schema files.");
+        if (pointer.value === null) {
+            console.error("Unreachable error: PrismaCompilerAgent.pointer.value is null");
+            return result; // unreachable
+        }
+        ctx.dispatch({
+            type: "prismaCorrect",
+            failure: result,
+            correction: {
+                files: pointer.value.files,
+            },
+            planning: pointer.value.planning,
+            step: (_e = (_d = ctx.state().analyze) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0,
+            created_at: new Date().toISOString(),
+        });
+        return step(ctx, {
+            files: pointer.value.files,
+        }, life - 1);
+    });
+}
+function createApplication(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Prisma Compiler",
+        application,
+        execute: {
+            correctPrismaSchemaFiles: (next) => {
+                props.build(next);
+            },
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "correctPrismaSchemaFiles",
+            parameters: {
+                description: "Current Type: {@link IModifyPrismaSchemaFilesProps}",
+                type: "object",
+                properties: {
+                    planning: {
+                        title: "Detailed execution plan for fixing AutoBePrisma validation errors",
+                        description: "Detailed execution plan for fixing AutoBePrisma validation errors.\n\n\uD83C\uDFAF Purpose: Enable systematic reasoning and step-by-step error resolution\napproach for structured schema validation issues\n\n\uD83D\uDCCB Required Planning Content:\n\n1. **Error Analysis Summary**\n\n   - List all validation errors from IAutoBePrismaValidation.IError[] array\n   - Categorize errors by type (duplications, references, types, indexes)\n   - Identify root causes and error interdependencies\n2. **Fix Strategy Overview**\n\n   - Prioritize fixes based on dependencies (fix duplications first)\n   - Outline minimal changes needed for each validation error\n   - Identify potential impact on other models/relationships\n3. **Step-by-Step Fix Plan**\n\n   - Model-by-model modification plan with specific changes\n   - Exact field additions, removals, or renames required\n   - Reference updates needed for renamed elements\n   - Index corrections to comply with validation rules\n4. **Preservation Checklist**\n\n   - Confirm which descriptions and business logic must be preserved\n   - List relationships and constraints to maintain unchanged\n   - Identify cross-model dependencies that must remain intact\n5. **Risk Assessment**\n\n   - Potential side effects of each planned fix\n   - Validation points to check after applying corrections\n   - Ensure no new validation errors are introduced\n\n\uD83D\uDCA1 Example Planning Structure:\n\n    ## Error Analysis\n    - Error 1: Duplicate field 'name' in shopping_customers model\n    - Error 2: Invalid targetModel 'shopping_customer' should be 'shopping_customers'\n\n    ## Fix Strategy\n    1. Remove duplicate 'name' field (keep the more detailed one)\n    2. Update foreign key references to use correct plural model name\n\n    ## Detailed Steps\n    1. shopping_customers model: Remove second 'name' field from plainFields\n    2. shopping_orders model: Update targetModel from 'shopping_customer' to 'shopping_customers'\n\n    ## Preservation Notes\n    - Keep business descriptions for remaining 'name' field\n    - Maintain all relationship semantics\n    - Preserve all indexes and constraints",
+                        type: "string"
+                    },
+                    files: {
+                        description: "Original AutoBePrisma.IApplication structure that contains validation\nerrors and needs correction.\n\n\uD83D\uDCE5 Input Structure:\n\n- Complete IApplication with files array containing validation errors\n- Each file contains models with potential structural issues\n- Errors may include duplications, invalid references, or constraint\n  violations\n\n\uD83D\uDD0D Expected Validation Issues:\n\n- Duplicate model names across files\n- Duplicate field/relation names within models\n- Invalid foreign key references to non-existent models\n- Single foreign key fields in index arrays\n- Non-plural model names or invalid naming conventions\n\n\uD83D\uDCDD Application Content Analysis:\n\n- All models with their complete field definitions\n- All relationships with targetModel and targetfield configurations\n- All indexes (unique, plain, GIN) with field references\n- All business descriptions and requirement mappings\n- Cross-file model references and dependencies\n\n\u26A0\uFE0F Processing Notes:\n\n- Structure may contain validation errors that prevent code generation\n- Some models might reference non-existent targets\n- Field names might violate naming conventions\n- Index configurations might include forbidden single foreign keys\n- Business logic and descriptions must be preserved during fixes",
+                        type: "array",
+                        items: {
+                            description: "Description of the current {@link AutoBePrisma.IFile} type:\n\n> Interface representing a single Prisma schema file within the application.\n> \n> Each file focuses on a specific business domain and contains related\n> models. File organization follows domain-driven design principles as seen\n> in the uploaded schemas.",
+                            type: "object",
+                            properties: {
+                                filename: {
+                                    title: "Name of the schema file to be generated",
+                                    description: "Name of the schema file to be generated.\n\nShould follow the naming convention: \"schema-{number}-{domain}.prisma\"\nExamples: \"schema-02-systematic.prisma\", \"schema-03-actors.prisma\" The\nnumber indicates the dependency order for schema generation.",
+                                    type: "string",
+                                    pattern: "^[a-zA-Z0-9._-]+\\.prisma$"
+                                },
+                                namespace: {
+                                    title: "Business domain namespace that groups related models",
+                                    description: "Business domain namespace that groups related models.\n\nUsed in Prisma documentation comments as \"@\\namespace directive\".\nExamples from uploaded schemas: \"Systematic\", \"Actors\", \"Sales\", \"Carts\",\n\"Orders\", \"Coupons\", \"Coins\", \"Inquiries\", \"Favorites\", \"Articles\"",
+                                    type: "string"
+                                },
+                                models: {
+                                    title: "Array of Prisma models (database tables) within this domain",
+                                    description: "Array of Prisma models (database tables) within this domain.\n\nEach model represents a business entity or concept within the namespace.\nModels can reference each other through foreign key relationships.",
+                                    type: "array",
+                                    items: {
+                                        description: "Description of the current {@link AutoBePrisma.IModel} type:\n\n> Interface representing a single Prisma model (database table).\n> \n> Based on the uploaded schemas, models follow specific patterns:\n> \n> - Main business entities (e.g., shopping_sales, shopping_customers)\n> - Snapshot/versioning entities for audit trails (e.g.,\n>   shopping_sale_snapshots)\n> - Junction tables for M:N relationships (e.g.,\n>   shopping_cart_commodity_stocks)\n> - Materialized views for performance (prefixed with mv_)",
+                                        type: "object",
+                                        properties: {
+                                            name: {
+                                                title: "Name of the Prisma model (database table name)",
+                                                description: "Name of the Prisma model (database table name).\n\nShould follow snake_case convention with domain prefix. Examples:\n\"shopping_customers\", \"shopping_sale_snapshots\", \"bbs_articles\"\nMaterialized views use \"mv_\" prefix: \"mv_shopping_sale_last_snapshots\"",
+                                                type: "string",
+                                                pattern: "^[a-z][a-z0-9_]*$"
+                                            },
+                                            description: {
+                                                description: "Detailed description explaining the business purpose and usage of the\nmodel.\n\nShould include:\n\n- Business context and purpose\n- Key relationships with other models\n- Important behavioral notes or constraints\n- References to related entities using \"{@\\link ModelName}\" syntax Example:\n  \"Customer information, but not a person but a **connection** basis...\"",
+                                                type: "string"
+                                            },
+                                            material: {
+                                                description: "Indicates whether this model represents a materialized view for\nperformance optimization.\n\nMaterialized views are read-only computed tables that cache complex query\nresults. They're marked as \"@\\hidden\" in documentation and prefixed with\n\"mv_\" in naming. Examples: mv_shopping_sale_last_snapshots,\nmv_shopping_cart_commodity_prices",
+                                                type: "boolean"
+                                            },
+                                            primaryField: {
+                                                description: "The primary key field of the model.\n\nIn all uploaded schemas, primary keys are always UUID type with \"@\\id\"\ndirective. Usually named \"id\" and marked with \"@\\db.Uuid\" for PostgreSQL\nmapping.\n\n------------------------------\n\nDescription of the current {@link AutoBePrisma.IPrimaryField} type:\n\n> Interface representing the primary key field of a Prisma model.\n> \n> All models in the uploaded schemas use UUID as primary key for better\n> distributed system compatibility and security (no sequential ID exposure).",
+                                                type: "object",
+                                                properties: {
+                                                    name: {
+                                                        title: "Name of the primary key field",
+                                                        description: "Name of the primary key field.\n\nConsistently named \"id\" across all models in the uploaded schemas.\nRepresents the unique identifier for each record in the table.",
+                                                        type: "string",
+                                                        pattern: "^[a-z][a-z0-9_]*$"
+                                                    },
+                                                    type: {
+                                                        title: "Data type of the primary key field",
+                                                        description: "Data type of the primary key field.\n\nAlways \"uuid\" in the uploaded schemas for better distributed system\nsupport and to avoid exposing sequential IDs that could reveal business\ninformation.",
+                                                        "const": "uuid"
+                                                    },
+                                                    description: {
+                                                        title: "Description of the primary key field's purpose",
+                                                        description: "Description of the primary key field's purpose.\n\nStandard description is \"Primary Key.\" across all models. Serves as the\nunique identifier for the model instance.",
+                                                        type: "string"
+                                                    }
+                                                },
+                                                required: [
+                                                    "name",
+                                                    "type",
+                                                    "description"
+                                                ]
+                                            },
+                                            foreignFields: {
+                                                title: "Array of foreign key fields that reference other models",
+                                                description: "Array of foreign key fields that reference other models.\n\nThese establish relationships between models and include Prisma relation\ndirectives. Can be nullable (optional relationships) or required\n(mandatory relationships). May have unique constraints for 1:1\nrelationships.",
+                                                type: "array",
+                                                items: {
+                                                    description: "Description of the current {@link AutoBePrisma.IForeignField} type:\n\n> Interface representing a foreign key field that establishes relationships\n> between models.\n> \n> Foreign keys create associations between models, enabling relational data\n> modeling. They can represent 1:1, 1:N, or participate in M:N relationships\n> through junction tables.",
+                                                    type: "object",
+                                                    properties: {
+                                                        name: {
+                                                            title: "Name of the foreign key field",
+                                                            description: "Name of the foreign key field.\n\nFollows convention: \"{target_model_name_without_prefix}_id\" Examples:\n\"shopping_customer_id\", \"bbs_article_id\", \"attachment_file_id\" For\nself-references: \"parent_id\" (e.g., in hierarchical structures)",
+                                                            type: "string",
+                                                            pattern: "^[a-z][a-z0-9_]*$"
+                                                        },
+                                                        type: {
+                                                            title: "Data type of the foreign key field",
+                                                            description: "Data type of the foreign key field.\n\nAlways \"uuid\" to match the primary key type of referenced models. Ensures\nreferential integrity and consistency across the schema.",
+                                                            "const": "uuid"
+                                                        },
+                                                        description: {
+                                                            description: "Description explaining the purpose and target of this foreign key\nrelationship.\n\nShould reference the target model using format: \"Target model's {@\\link\nModelName.id}\" Examples: \"Belonged customer's {@\\link\nshopping_customers.id}\" May include additional context about the\nrelationship's business meaning.",
+                                                            type: "string"
+                                                        },
+                                                        relation: {
+                                                            title: "Prisma relation configuration defining the association details",
+                                                            description: "Prisma relation configuration defining the association details.\n\nSpecifies how this foreign key connects to the target model, including\nrelation name, target model, and target field.",
+                                                            type: "object",
+                                                            properties: {
+                                                                name: {
+                                                                    title: "Name of the relation property in the Prisma model",
+                                                                    description: "Name of the relation property in the Prisma model.\n\nUsed to access the related model instance. Usually a descriptive name\nof the relationship. Examples: \"customer\", \"channel\", \"parent\",\n\"snapshot\"",
+                                                                    type: "string",
+                                                                    pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$"
+                                                                },
+                                                                targetModel: {
+                                                                    title: "Name of the target model being referenced",
+                                                                    description: "Name of the target model being referenced.\n\nMust match exactly with an existing model name in the schema. Examples:\n\"shopping_customers\", \"shopping_channels\", \"bbs_articles\"",
+                                                                    type: "string"
+                                                                }
+                                                            },
+                                                            required: [
+                                                                "name",
+                                                                "targetModel"
+                                                            ]
+                                                        },
+                                                        unique: {
+                                                            title: "Whether this foreign key has a unique constraint",
+                                                            description: "Whether this foreign key has a unique constraint.\n\nTrue: Creates a 1:1 relationship (e.g., user profile, order publish\ndetails) false: Allows 1:N relationship (e.g., customer to multiple\norders) Used for enforcing business rules about relationship\ncardinality.",
+                                                            type: "boolean"
+                                                        },
+                                                        nullable: {
+                                                            title: "Whether this foreign key can be null (optional relationship)",
+                                                            description: "Whether this foreign key can be null (optional relationship).\n\nTrue: Relationship is optional, foreign key can be null false:\nRelationship is required, foreign key cannot be null Reflects business\nrules about mandatory vs optional associations.",
+                                                            type: "boolean"
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "name",
+                                                        "type",
+                                                        "description",
+                                                        "relation",
+                                                        "unique",
+                                                        "nullable"
+                                                    ]
+                                                }
+                                            },
+                                            plainFields: {
+                                                title: "Array of regular data fields that don't reference other models",
+                                                description: "Array of regular data fields that don't reference other models.\n\nInclude business data like names, descriptions, timestamps, flags,\namounts, etc. Common patterns: created_at, updated_at, deleted_at for\nsoft deletion and auditing.",
+                                                type: "array",
+                                                items: {
+                                                    description: "Description of the current {@link AutoBePrisma.IPlainField} type:\n\n> Interface representing a regular data field that stores business\n> information.\n> \n> These fields contain the actual business data like names, amounts,\n> timestamps, flags, descriptions, and other domain-specific information.",
+                                                    type: "object",
+                                                    properties: {
+                                                        name: {
+                                                            title: "Name of the field in the database table",
+                                                            description: "Name of the field in the database table.\n\nShould use snake_case convention. Common patterns from uploaded schemas:\n\n- Timestamps: created_at, updated_at, deleted_at, opened_at, closed_at\n- Identifiers: code, name, nickname, title\n- Business data: value, quantity, price, volume, balance\n- Flags: primary, required, exclusive, secret, multiplicative",
+                                                            type: "string",
+                                                            pattern: "^[a-z][a-z0-9_]*$"
+                                                        },
+                                                        type: {
+                                                            title: "Data type of the field for Prisma schema generation",
+                                                            description: "Data type of the field for Prisma schema generation.\n\nMaps to appropriate Prisma/PostgreSQL types:\n\n- Boolean: Boolean flags and yes/no values\n- Int: Integer numbers, quantities, sequences\n- Double: Decimal numbers, prices, monetary values, percentages\n- String: Text data, names, descriptions, codes\n- Uri: URL/URI fields for links and references\n- Uuid: UUID fields (for non-foreign-key UUIDs)\n- Date: Date-only values (rare, mostly for business dates)\n- Datetime: Timestamp fields with date and time",
+                                                            oneOf: [
+                                                                {
+                                                                    "const": "string"
+                                                                },
+                                                                {
+                                                                    "const": "boolean"
+                                                                },
+                                                                {
+                                                                    "const": "uuid"
+                                                                },
+                                                                {
+                                                                    "const": "uri"
+                                                                },
+                                                                {
+                                                                    "const": "int"
+                                                                },
+                                                                {
+                                                                    "const": "double"
+                                                                },
+                                                                {
+                                                                    "const": "datetime"
+                                                                }
+                                                            ]
+                                                        },
+                                                        description: {
+                                                            title: "Description explaining the business purpose and usage of this field",
+                                                            description: "Description explaining the business purpose and usage of this field.\n\nShould clearly explain:\n\n- What business concept this field represents\n- Valid values or constraints if applicable\n- How it relates to business processes\n- Any special behavioral notes Example: \"Amount of cash payment.\" or\n  \"Whether the unit is required or not.\"",
+                                                            type: "string"
+                                                        },
+                                                        nullable: {
+                                                            title: "Whether this field can contain null values",
+                                                            description: "Whether this field can contain null values.\n\nTrue: Field is optional and can be null (e.g., middle name, description)\nfalse: Field is required and cannot be null (e.g., creation timestamp,\nname) Reflects business rules about mandatory vs optional data.",
+                                                            type: "boolean"
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "name",
+                                                        "type",
+                                                        "description",
+                                                        "nullable"
+                                                    ]
+                                                }
+                                            },
+                                            uniqueIndexes: {
+                                                title: "Array of unique indexes for enforcing data integrity constraints",
+                                                description: "Array of unique indexes for enforcing data integrity constraints.\n\nEnsure uniqueness across single or multiple columns. Examples: unique\nemail addresses, unique codes within a channel, unique combinations like\n(channel_id, nickname).",
+                                                type: "array",
+                                                items: {
+                                                    description: "Description of the current {@link AutoBePrisma.IUniqueIndex} type:\n\n> Interface representing a unique index constraint on one or more fields.\n> \n> Unique indexes enforce data integrity by ensuring no duplicate values exist\n> for the specified field combination. Essential for business rules that\n> require uniqueness like email addresses, codes, or composite keys.",
+                                                    type: "object",
+                                                    properties: {
+                                                        fieldNames: {
+                                                            title: "Array of field names that together form the unique constraint",
+                                                            description: "Array of field names that together form the unique constraint.\n\nCan be single field (e.g., [\"email\"]) or composite (e.g., [\"channel_id\",\n\"code\"]). All field names must exist in the model. Order matters for\ncomposite indexes. Examples: [\"code\"], [\"shopping_channel_id\",\n\"nickname\"], [\"email\"]",
+                                                            type: "array",
+                                                            items: {
+                                                                type: "string"
+                                                            },
+                                                            minItems: 1,
+                                                            uniqueItems: true
+                                                        },
+                                                        unique: {
+                                                            title: "Explicit marker indicating this is a unique index",
+                                                            description: "Explicit marker indicating this is a unique index.\n\nAlways true to distinguish from regular indexes. Used by code generator\nto emit \"@@unique\" directive in Prisma schema instead of \"@@index\".",
+                                                            "const": true
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "fieldNames",
+                                                        "unique"
+                                                    ]
+                                                }
+                                            },
+                                            plainIndexes: {
+                                                title: "Array of regular indexes for query performance optimization",
+                                                description: "Array of regular indexes for query performance optimization.\n\nSpeed up common query patterns like filtering by foreign keys, date\nranges, or frequently searched fields. Examples: indexes on created_at,\nforeign key fields, search fields.",
+                                                type: "array",
+                                                items: {
+                                                    description: "Description of the current {@link AutoBePrisma.IPlainIndex} type:\n\n> Interface representing a regular (non-unique) index for query performance.\n> \n> Regular indexes speed up database queries by creating optimized data\n> structures for common search patterns. Essential for foreign keys, date\n> ranges, and frequently filtered fields.",
+                                                    type: "object",
+                                                    properties: {
+                                                        fieldNames: {
+                                                            title: "Array of field names to include in the performance index",
+                                                            description: "Array of field names to include in the performance index.\n\nCan be single field (e.g., [\"created_at\"]) or composite (e.g.,\n[\"customer_id\", \"created_at\"]). All field names must exist in the model.\nOrder matters for composite indexes and should match common query\npatterns. Examples: [\"created_at\"], [\"shopping_customer_id\",\n\"created_at\"], [\"ip\"]",
+                                                            type: "array",
+                                                            items: {
+                                                                type: "string"
+                                                            },
+                                                            minItems: 1,
+                                                            uniqueItems: true
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "fieldNames"
+                                                    ]
+                                                }
+                                            },
+                                            ginIndexes: {
+                                                title: "Array of GIN (Generalized Inverted Index) indexes for full-text search",
+                                                description: "Array of GIN (Generalized Inverted Index) indexes for full-text search.\n\nUsed specifically for PostgreSQL text search capabilities using trigram\noperations. Applied to text fields that need fuzzy matching or partial\ntext search. Examples: searching names, nicknames, titles, content\nbodies.",
+                                                type: "array",
+                                                items: {
+                                                    description: "Description of the current {@link AutoBePrisma.IGinIndex} type:\n\n> Interface representing a GIN (Generalized Inverted Index) for full-text\n> search.\n> \n> GIN indexes enable advanced PostgreSQL text search capabilities including\n> fuzzy matching and partial text search using trigram operations. Essential\n> for user-facing search features on text content.",
+                                                    type: "object",
+                                                    properties: {
+                                                        fieldName: {
+                                                            title: "Name of the text field to index for full-text search capabilities",
+                                                            description: "Name of the text field to index for full-text search capabilities.\n\nMust be a string field in the model that contains searchable text.\nExamples from uploaded schemas: \"nickname\", \"title\", \"body\", \"name\" Used\nwith PostgreSQL gin_trgm_ops for trigram-based fuzzy text search.",
+                                                            type: "string"
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "fieldName"
+                                                    ]
+                                                }
+                                            }
+                                        },
+                                        required: [
+                                            "name",
+                                            "description",
+                                            "material",
+                                            "primaryField",
+                                            "foreignFields",
+                                            "plainFields",
+                                            "uniqueIndexes",
+                                            "plainIndexes",
+                                            "ginIndexes"
+                                        ]
+                                    }
+                                }
+                            },
+                            required: [
+                                "filename",
+                                "namespace",
+                                "models"
+                            ]
+                        }
+                    }
+                },
+                required: [
+                    "planning",
+                    "files"
+                ],
+                additionalProperties: false,
+                $defs: {}
+            },
+            description: "Fixes validation errors in AutoBePrisma.IApplication structure while\npreserving ALL existing business logic and model descriptions.\n\n## Core Rules\n\n1. Fix ONLY validation errors - never remove business descriptions\n2. Apply minimal changes - preserve original design intent\n3. Return COMPLETE corrected structure - no data loss allowed\n4. Maintain referential integrity across all models\n\n## Preservation Requirements\n\n- Keep ALL model and field descriptions\n- Keep business logic and architectural patterns\n- Maintain relationship semantics and cardinality\n- Remove descriptions only when removing duplicate elements\n\n## Fix Strategy\n\n- Resolve structural validation errors without changing business intent\n- Remove duplicate fields/relations while preserving most appropriate ones\n- Fix invalid references and type mismatches\n- Ensure naming conventions and index rules compliance",
+            validate: (() => { const _io0 = input => "string" === typeof input.planning && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && (Array.isArray(input.models) && input.models.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "string" === typeof input.description && "boolean" === typeof input.material && ("object" === typeof input.primaryField && null !== input.primaryField && _io3(input.primaryField)) && (Array.isArray(input.foreignFields) && input.foreignFields.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.plainFields) && input.plainFields.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && (Array.isArray(input.uniqueIndexes) && input.uniqueIndexes.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.plainIndexes) && input.plainIndexes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.ginIndexes) && input.ginIndexes.every(elem => "object" === typeof elem && null !== elem && _io9(elem))); const _io3 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "uuid" === input.type && "string" === typeof input.description; const _io4 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "uuid" === input.type && "string" === typeof input.description && ("object" === typeof input.relation && null !== input.relation && _io5(input.relation)) && "boolean" === typeof input.unique && "boolean" === typeof input.nullable; const _io5 = input => "string" === typeof input.name && RegExp("^[a-zA-Z_][a-zA-Z0-9_]*$").test(input.name) && "string" === typeof input.targetModel; const _io6 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && ("string" === input.type || "boolean" === input.type || "uuid" === input.type || "uri" === input.type || "int" === input.type || "double" === input.type || "datetime" === input.type) && "string" === typeof input.description && "boolean" === typeof input.nullable; const _io7 = input => Array.isArray(input.fieldNames) && (1 <= input.fieldNames.length && __typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && true === input.unique; const _io8 = input => Array.isArray(input.fieldNames) && (1 <= input.fieldNames.length && __typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)); const _io9 = input => "string" === typeof input.fieldName; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.planning || _report(_exceptionable, {
+                    path: _path + ".planning",
+                    expected: "string",
+                    value: input.planning
+                }), (Array.isArray(input.files) || _report(_exceptionable, {
+                    path: _path + ".files",
+                    expected: "Array<AutoBePrisma.IFile>",
+                    value: input.files
+                })) && input.files.map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".files[" + _index10 + "]",
+                    expected: "AutoBePrisma.IFile",
+                    value: elem
+                })) && _vo1(elem, _path + ".files[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".files[" + _index10 + "]",
+                    expected: "AutoBePrisma.IFile",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".files",
+                    expected: "Array<AutoBePrisma.IFile>",
+                    value: input.files
+                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
+                    path: _path + ".filename",
+                    expected: "string & Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">",
+                    value: input.filename
+                })) || _report(_exceptionable, {
+                    path: _path + ".filename",
+                    expected: "(string & Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">)",
+                    value: input.filename
+                }), "string" === typeof input.namespace || _report(_exceptionable, {
+                    path: _path + ".namespace",
+                    expected: "string",
+                    value: input.namespace
+                }), (Array.isArray(input.models) || _report(_exceptionable, {
+                    path: _path + ".models",
+                    expected: "Array<AutoBePrisma.IModel>",
+                    value: input.models
+                })) && input.models.map((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".models[" + _index11 + "]",
+                    expected: "AutoBePrisma.IModel",
+                    value: elem
+                })) && _vo2(elem, _path + ".models[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".models[" + _index11 + "]",
+                    expected: "AutoBePrisma.IModel",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".models",
+                    expected: "Array<AutoBePrisma.IModel>",
+                    value: input.models
+                })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    value: input.name
+                }), "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                }), "boolean" === typeof input.material || _report(_exceptionable, {
+                    path: _path + ".material",
+                    expected: "boolean",
+                    value: input.material
+                }), ("object" === typeof input.primaryField && null !== input.primaryField || _report(_exceptionable, {
+                    path: _path + ".primaryField",
+                    expected: "AutoBePrisma.IPrimaryField",
+                    value: input.primaryField
+                })) && _vo3(input.primaryField, _path + ".primaryField", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".primaryField",
+                    expected: "AutoBePrisma.IPrimaryField",
+                    value: input.primaryField
+                }), (Array.isArray(input.foreignFields) || _report(_exceptionable, {
+                    path: _path + ".foreignFields",
+                    expected: "Array<AutoBePrisma.IForeignField>",
+                    value: input.foreignFields
+                })) && input.foreignFields.map((elem, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".foreignFields[" + _index12 + "]",
+                    expected: "AutoBePrisma.IForeignField",
+                    value: elem
+                })) && _vo4(elem, _path + ".foreignFields[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".foreignFields[" + _index12 + "]",
+                    expected: "AutoBePrisma.IForeignField",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".foreignFields",
+                    expected: "Array<AutoBePrisma.IForeignField>",
+                    value: input.foreignFields
+                }), (Array.isArray(input.plainFields) || _report(_exceptionable, {
+                    path: _path + ".plainFields",
+                    expected: "Array<AutoBePrisma.IPlainField>",
+                    value: input.plainFields
+                })) && input.plainFields.map((elem, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".plainFields[" + _index13 + "]",
+                    expected: "AutoBePrisma.IPlainField",
+                    value: elem
+                })) && _vo6(elem, _path + ".plainFields[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".plainFields[" + _index13 + "]",
+                    expected: "AutoBePrisma.IPlainField",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".plainFields",
+                    expected: "Array<AutoBePrisma.IPlainField>",
+                    value: input.plainFields
+                }), (Array.isArray(input.uniqueIndexes) || _report(_exceptionable, {
+                    path: _path + ".uniqueIndexes",
+                    expected: "Array<AutoBePrisma.IUniqueIndex>",
+                    value: input.uniqueIndexes
+                })) && input.uniqueIndexes.map((elem, _index14) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".uniqueIndexes[" + _index14 + "]",
+                    expected: "AutoBePrisma.IUniqueIndex",
+                    value: elem
+                })) && _vo7(elem, _path + ".uniqueIndexes[" + _index14 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".uniqueIndexes[" + _index14 + "]",
+                    expected: "AutoBePrisma.IUniqueIndex",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".uniqueIndexes",
+                    expected: "Array<AutoBePrisma.IUniqueIndex>",
+                    value: input.uniqueIndexes
+                }), (Array.isArray(input.plainIndexes) || _report(_exceptionable, {
+                    path: _path + ".plainIndexes",
+                    expected: "Array<AutoBePrisma.IPlainIndex>",
+                    value: input.plainIndexes
+                })) && input.plainIndexes.map((elem, _index15) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".plainIndexes[" + _index15 + "]",
+                    expected: "AutoBePrisma.IPlainIndex",
+                    value: elem
+                })) && _vo8(elem, _path + ".plainIndexes[" + _index15 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".plainIndexes[" + _index15 + "]",
+                    expected: "AutoBePrisma.IPlainIndex",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".plainIndexes",
+                    expected: "Array<AutoBePrisma.IPlainIndex>",
+                    value: input.plainIndexes
+                }), (Array.isArray(input.ginIndexes) || _report(_exceptionable, {
+                    path: _path + ".ginIndexes",
+                    expected: "Array<AutoBePrisma.IGinIndex>",
+                    value: input.ginIndexes
+                })) && input.ginIndexes.map((elem, _index16) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".ginIndexes[" + _index16 + "]",
+                    expected: "AutoBePrisma.IGinIndex",
+                    value: elem
+                })) && _vo9(elem, _path + ".ginIndexes[" + _index16 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".ginIndexes[" + _index16 + "]",
+                    expected: "AutoBePrisma.IGinIndex",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".ginIndexes",
+                    expected: "Array<AutoBePrisma.IGinIndex>",
+                    value: input.ginIndexes
+                })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    value: input.name
+                }), "uuid" === input.type || _report(_exceptionable, {
+                    path: _path + ".type",
+                    expected: "\"uuid\"",
+                    value: input.type
+                }), "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                })].every(flag => flag); const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    value: input.name
+                }), "uuid" === input.type || _report(_exceptionable, {
+                    path: _path + ".type",
+                    expected: "\"uuid\"",
+                    value: input.type
+                }), "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                }), ("object" === typeof input.relation && null !== input.relation || _report(_exceptionable, {
+                    path: _path + ".relation",
+                    expected: "__type",
+                    value: input.relation
+                })) && _vo5(input.relation, _path + ".relation", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".relation",
+                    expected: "__type",
+                    value: input.relation
+                }), "boolean" === typeof input.unique || _report(_exceptionable, {
+                    path: _path + ".unique",
+                    expected: "boolean",
+                    value: input.unique
+                }), "boolean" === typeof input.nullable || _report(_exceptionable, {
+                    path: _path + ".nullable",
+                    expected: "boolean",
+                    value: input.nullable
+                })].every(flag => flag); const _vo5 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-zA-Z_][a-zA-Z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string & Pattern<\"^[a-zA-Z_][a-zA-Z0-9_]*$\">",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & Pattern<\"^[a-zA-Z_][a-zA-Z0-9_]*$\">)",
+                    value: input.name
+                }), "string" === typeof input.targetModel || _report(_exceptionable, {
+                    path: _path + ".targetModel",
+                    expected: "string",
+                    value: input.targetModel
+                })].every(flag => flag); const _vo6 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    value: input.name
+                }), "string" === input.type || "boolean" === input.type || "uuid" === input.type || "uri" === input.type || "int" === input.type || "double" === input.type || "datetime" === input.type || _report(_exceptionable, {
+                    path: _path + ".type",
+                    expected: "(\"boolean\" | \"datetime\" | \"double\" | \"int\" | \"string\" | \"uri\" | \"uuid\")",
+                    value: input.type
+                }), "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                }), "boolean" === typeof input.nullable || _report(_exceptionable, {
+                    path: _path + ".nullable",
+                    expected: "boolean",
+                    value: input.nullable
+                })].every(flag => flag); const _vo7 = (input, _path, _exceptionable = true) => [(Array.isArray(input.fieldNames) || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                    value: input.fieldNames
+                })) && ((1 <= input.fieldNames.length || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "Array<> & MinItems<1>",
+                    value: input.fieldNames
+                })) && (__typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "Array<> & UniqueItems<true>",
+                    value: input.fieldNames
+                })) && input.fieldNames.map((elem, _index17) => "string" === typeof elem || _report(_exceptionable, {
+                    path: _path + ".fieldNames[" + _index17 + "]",
+                    expected: "string",
+                    value: elem
+                })).every(flag => flag)) || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                    value: input.fieldNames
+                }), true === input.unique || _report(_exceptionable, {
+                    path: _path + ".unique",
+                    expected: "true",
+                    value: input.unique
+                })].every(flag => flag); const _vo8 = (input, _path, _exceptionable = true) => [(Array.isArray(input.fieldNames) || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                    value: input.fieldNames
+                })) && ((1 <= input.fieldNames.length || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "Array<> & MinItems<1>",
+                    value: input.fieldNames
+                })) && (__typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "Array<> & UniqueItems<true>",
+                    value: input.fieldNames
+                })) && input.fieldNames.map((elem, _index18) => "string" === typeof elem || _report(_exceptionable, {
+                    path: _path + ".fieldNames[" + _index18 + "]",
+                    expected: "string",
+                    value: elem
+                })).every(flag => flag)) || _report(_exceptionable, {
+                    path: _path + ".fieldNames",
+                    expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                    value: input.fieldNames
+                })].every(flag => flag); const _vo9 = (input, _path, _exceptionable = true) => ["string" === typeof input.fieldName || _report(_exceptionable, {
+                    path: _path + ".fieldName",
+                    expected: "string",
+                    value: input.fieldName
+                })].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: "IModifyPrismaSchemaFilesProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IModifyPrismaSchemaFilesProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            }; })()
+        }
+    ]
+};
+const collection = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [
+            {
+                name: "correctPrismaSchemaFiles",
+                parameters: {
+                    description: "Current Type: {@link IModifyPrismaSchemaFilesProps}",
+                    type: "object",
+                    properties: {
+                        planning: {
+                            title: "Detailed execution plan for fixing AutoBePrisma validation errors",
+                            description: "Detailed execution plan for fixing AutoBePrisma validation errors.\n\n\uD83C\uDFAF Purpose: Enable systematic reasoning and step-by-step error resolution\napproach for structured schema validation issues\n\n\uD83D\uDCCB Required Planning Content:\n\n1. **Error Analysis Summary**\n\n   - List all validation errors from IAutoBePrismaValidation.IError[] array\n   - Categorize errors by type (duplications, references, types, indexes)\n   - Identify root causes and error interdependencies\n2. **Fix Strategy Overview**\n\n   - Prioritize fixes based on dependencies (fix duplications first)\n   - Outline minimal changes needed for each validation error\n   - Identify potential impact on other models/relationships\n3. **Step-by-Step Fix Plan**\n\n   - Model-by-model modification plan with specific changes\n   - Exact field additions, removals, or renames required\n   - Reference updates needed for renamed elements\n   - Index corrections to comply with validation rules\n4. **Preservation Checklist**\n\n   - Confirm which descriptions and business logic must be preserved\n   - List relationships and constraints to maintain unchanged\n   - Identify cross-model dependencies that must remain intact\n5. **Risk Assessment**\n\n   - Potential side effects of each planned fix\n   - Validation points to check after applying corrections\n   - Ensure no new validation errors are introduced\n\n\uD83D\uDCA1 Example Planning Structure:\n\n    ## Error Analysis\n    - Error 1: Duplicate field 'name' in shopping_customers model\n    - Error 2: Invalid targetModel 'shopping_customer' should be 'shopping_customers'\n\n    ## Fix Strategy\n    1. Remove duplicate 'name' field (keep the more detailed one)\n    2. Update foreign key references to use correct plural model name\n\n    ## Detailed Steps\n    1. shopping_customers model: Remove second 'name' field from plainFields\n    2. shopping_orders model: Update targetModel from 'shopping_customer' to 'shopping_customers'\n\n    ## Preservation Notes\n    - Keep business descriptions for remaining 'name' field\n    - Maintain all relationship semantics\n    - Preserve all indexes and constraints",
+                            type: "string"
+                        },
+                        files: {
+                            description: "Original AutoBePrisma.IApplication structure that contains validation\nerrors and needs correction.\n\n\uD83D\uDCE5 Input Structure:\n\n- Complete IApplication with files array containing validation errors\n- Each file contains models with potential structural issues\n- Errors may include duplications, invalid references, or constraint\n  violations\n\n\uD83D\uDD0D Expected Validation Issues:\n\n- Duplicate model names across files\n- Duplicate field/relation names within models\n- Invalid foreign key references to non-existent models\n- Single foreign key fields in index arrays\n- Non-plural model names or invalid naming conventions\n\n\uD83D\uDCDD Application Content Analysis:\n\n- All models with their complete field definitions\n- All relationships with targetModel and targetfield configurations\n- All indexes (unique, plain, GIN) with field references\n- All business descriptions and requirement mappings\n- Cross-file model references and dependencies\n\n\u26A0\uFE0F Processing Notes:\n\n- Structure may contain validation errors that prevent code generation\n- Some models might reference non-existent targets\n- Field names might violate naming conventions\n- Index configurations might include forbidden single foreign keys\n- Business logic and descriptions must be preserved during fixes",
+                            type: "array",
+                            items: {
+                                description: "Description of the current {@link AutoBePrisma.IFile} type:\n\n> Interface representing a single Prisma schema file within the application.\n> \n> Each file focuses on a specific business domain and contains related\n> models. File organization follows domain-driven design principles as seen\n> in the uploaded schemas.",
+                                type: "object",
+                                properties: {
+                                    filename: {
+                                        title: "Name of the schema file to be generated",
+                                        description: "Name of the schema file to be generated.\n\nShould follow the naming convention: \"schema-{number}-{domain}.prisma\"\nExamples: \"schema-02-systematic.prisma\", \"schema-03-actors.prisma\" The\nnumber indicates the dependency order for schema generation.\n\n\n@pattern ^[a-zA-Z0-9._-]+\\.prisma$",
+                                        type: "string"
+                                    },
+                                    namespace: {
+                                        title: "Business domain namespace that groups related models",
+                                        description: "Business domain namespace that groups related models.\n\nUsed in Prisma documentation comments as \"@\\namespace directive\".\nExamples from uploaded schemas: \"Systematic\", \"Actors\", \"Sales\", \"Carts\",\n\"Orders\", \"Coupons\", \"Coins\", \"Inquiries\", \"Favorites\", \"Articles\"",
+                                        type: "string"
+                                    },
+                                    models: {
+                                        title: "Array of Prisma models (database tables) within this domain",
+                                        description: "Array of Prisma models (database tables) within this domain.\n\nEach model represents a business entity or concept within the namespace.\nModels can reference each other through foreign key relationships.",
+                                        type: "array",
+                                        items: {
+                                            description: "Description of the current {@link AutoBePrisma.IModel} type:\n\n> Interface representing a single Prisma model (database table).\n> \n> Based on the uploaded schemas, models follow specific patterns:\n> \n> - Main business entities (e.g., shopping_sales, shopping_customers)\n> - Snapshot/versioning entities for audit trails (e.g.,\n>   shopping_sale_snapshots)\n> - Junction tables for M:N relationships (e.g.,\n>   shopping_cart_commodity_stocks)\n> - Materialized views for performance (prefixed with mv_)",
+                                            type: "object",
+                                            properties: {
+                                                name: {
+                                                    title: "Name of the Prisma model (database table name)",
+                                                    description: "Name of the Prisma model (database table name).\n\nShould follow snake_case convention with domain prefix. Examples:\n\"shopping_customers\", \"shopping_sale_snapshots\", \"bbs_articles\"\nMaterialized views use \"mv_\" prefix: \"mv_shopping_sale_last_snapshots\"\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                                                    type: "string"
+                                                },
+                                                description: {
+                                                    description: "Detailed description explaining the business purpose and usage of the\nmodel.\n\nShould include:\n\n- Business context and purpose\n- Key relationships with other models\n- Important behavioral notes or constraints\n- References to related entities using \"{@\\link ModelName}\" syntax Example:\n  \"Customer information, but not a person but a **connection** basis...\"",
+                                                    type: "string"
+                                                },
+                                                material: {
+                                                    description: "Indicates whether this model represents a materialized view for\nperformance optimization.\n\nMaterialized views are read-only computed tables that cache complex query\nresults. They're marked as \"@\\hidden\" in documentation and prefixed with\n\"mv_\" in naming. Examples: mv_shopping_sale_last_snapshots,\nmv_shopping_cart_commodity_prices",
+                                                    type: "boolean"
+                                                },
+                                                primaryField: {
+                                                    description: "The primary key field of the model.\n\nIn all uploaded schemas, primary keys are always UUID type with \"@\\id\"\ndirective. Usually named \"id\" and marked with \"@\\db.Uuid\" for PostgreSQL\nmapping.\n\n------------------------------\n\nDescription of the current {@link AutoBePrisma.IPrimaryField} type:\n\n> Interface representing the primary key field of a Prisma model.\n> \n> All models in the uploaded schemas use UUID as primary key for better\n> distributed system compatibility and security (no sequential ID exposure).",
+                                                    type: "object",
+                                                    properties: {
+                                                        name: {
+                                                            title: "Name of the primary key field",
+                                                            description: "Name of the primary key field.\n\nConsistently named \"id\" across all models in the uploaded schemas.\nRepresents the unique identifier for each record in the table.\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                                                            type: "string"
+                                                        },
+                                                        type: {
+                                                            title: "Data type of the primary key field",
+                                                            description: "Data type of the primary key field.\n\nAlways \"uuid\" in the uploaded schemas for better distributed system\nsupport and to avoid exposing sequential IDs that could reveal business\ninformation.",
+                                                            type: "string",
+                                                            "enum": [
+                                                                "uuid"
+                                                            ]
+                                                        },
+                                                        description: {
+                                                            title: "Description of the primary key field's purpose",
+                                                            description: "Description of the primary key field's purpose.\n\nStandard description is \"Primary Key.\" across all models. Serves as the\nunique identifier for the model instance.",
+                                                            type: "string"
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "name",
+                                                        "type",
+                                                        "description"
+                                                    ]
+                                                },
+                                                foreignFields: {
+                                                    title: "Array of foreign key fields that reference other models",
+                                                    description: "Array of foreign key fields that reference other models.\n\nThese establish relationships between models and include Prisma relation\ndirectives. Can be nullable (optional relationships) or required\n(mandatory relationships). May have unique constraints for 1:1\nrelationships.",
+                                                    type: "array",
+                                                    items: {
+                                                        description: "Description of the current {@link AutoBePrisma.IForeignField} type:\n\n> Interface representing a foreign key field that establishes relationships\n> between models.\n> \n> Foreign keys create associations between models, enabling relational data\n> modeling. They can represent 1:1, 1:N, or participate in M:N relationships\n> through junction tables.",
+                                                        type: "object",
+                                                        properties: {
+                                                            name: {
+                                                                title: "Name of the foreign key field",
+                                                                description: "Name of the foreign key field.\n\nFollows convention: \"{target_model_name_without_prefix}_id\" Examples:\n\"shopping_customer_id\", \"bbs_article_id\", \"attachment_file_id\" For\nself-references: \"parent_id\" (e.g., in hierarchical structures)\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                                                                type: "string"
+                                                            },
+                                                            type: {
+                                                                title: "Data type of the foreign key field",
+                                                                description: "Data type of the foreign key field.\n\nAlways \"uuid\" to match the primary key type of referenced models. Ensures\nreferential integrity and consistency across the schema.",
+                                                                type: "string",
+                                                                "enum": [
+                                                                    "uuid"
+                                                                ]
+                                                            },
+                                                            description: {
+                                                                description: "Description explaining the purpose and target of this foreign key\nrelationship.\n\nShould reference the target model using format: \"Target model's {@\\link\nModelName.id}\" Examples: \"Belonged customer's {@\\link\nshopping_customers.id}\" May include additional context about the\nrelationship's business meaning.",
+                                                                type: "string"
+                                                            },
+                                                            relation: {
+                                                                title: "Prisma relation configuration defining the association details",
+                                                                description: "Prisma relation configuration defining the association details.\n\nSpecifies how this foreign key connects to the target model, including\nrelation name, target model, and target field.",
+                                                                type: "object",
+                                                                properties: {
+                                                                    name: {
+                                                                        title: "Name of the relation property in the Prisma model",
+                                                                        description: "Name of the relation property in the Prisma model.\n\nUsed to access the related model instance. Usually a descriptive name\nof the relationship. Examples: \"customer\", \"channel\", \"parent\",\n\"snapshot\"\n\n\n@pattern ^[a-zA-Z_][a-zA-Z0-9_]*$",
+                                                                        type: "string"
+                                                                    },
+                                                                    targetModel: {
+                                                                        title: "Name of the target model being referenced",
+                                                                        description: "Name of the target model being referenced.\n\nMust match exactly with an existing model name in the schema. Examples:\n\"shopping_customers\", \"shopping_channels\", \"bbs_articles\"",
+                                                                        type: "string"
+                                                                    }
+                                                                },
+                                                                required: [
+                                                                    "name",
+                                                                    "targetModel"
+                                                                ]
+                                                            },
+                                                            unique: {
+                                                                title: "Whether this foreign key has a unique constraint",
+                                                                description: "Whether this foreign key has a unique constraint.\n\nTrue: Creates a 1:1 relationship (e.g., user profile, order publish\ndetails) false: Allows 1:N relationship (e.g., customer to multiple\norders) Used for enforcing business rules about relationship\ncardinality.",
+                                                                type: "boolean"
+                                                            },
+                                                            nullable: {
+                                                                title: "Whether this foreign key can be null (optional relationship)",
+                                                                description: "Whether this foreign key can be null (optional relationship).\n\nTrue: Relationship is optional, foreign key can be null false:\nRelationship is required, foreign key cannot be null Reflects business\nrules about mandatory vs optional associations.",
+                                                                type: "boolean"
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "name",
+                                                            "type",
+                                                            "description",
+                                                            "relation",
+                                                            "unique",
+                                                            "nullable"
+                                                        ]
+                                                    }
+                                                },
+                                                plainFields: {
+                                                    title: "Array of regular data fields that don't reference other models",
+                                                    description: "Array of regular data fields that don't reference other models.\n\nInclude business data like names, descriptions, timestamps, flags,\namounts, etc. Common patterns: created_at, updated_at, deleted_at for\nsoft deletion and auditing.",
+                                                    type: "array",
+                                                    items: {
+                                                        description: "Description of the current {@link AutoBePrisma.IPlainField} type:\n\n> Interface representing a regular data field that stores business\n> information.\n> \n> These fields contain the actual business data like names, amounts,\n> timestamps, flags, descriptions, and other domain-specific information.",
+                                                        type: "object",
+                                                        properties: {
+                                                            name: {
+                                                                title: "Name of the field in the database table",
+                                                                description: "Name of the field in the database table.\n\nShould use snake_case convention. Common patterns from uploaded schemas:\n\n- Timestamps: created_at, updated_at, deleted_at, opened_at, closed_at\n- Identifiers: code, name, nickname, title\n- Business data: value, quantity, price, volume, balance\n- Flags: primary, required, exclusive, secret, multiplicative\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                                                                type: "string"
+                                                            },
+                                                            type: {
+                                                                title: "Data type of the field for Prisma schema generation",
+                                                                description: "Data type of the field for Prisma schema generation.\n\nMaps to appropriate Prisma/PostgreSQL types:\n\n- Boolean: Boolean flags and yes/no values\n- Int: Integer numbers, quantities, sequences\n- Double: Decimal numbers, prices, monetary values, percentages\n- String: Text data, names, descriptions, codes\n- Uri: URL/URI fields for links and references\n- Uuid: UUID fields (for non-foreign-key UUIDs)\n- Date: Date-only values (rare, mostly for business dates)\n- Datetime: Timestamp fields with date and time",
+                                                                type: "string",
+                                                                "enum": [
+                                                                    "string",
+                                                                    "boolean",
+                                                                    "uuid",
+                                                                    "uri",
+                                                                    "int",
+                                                                    "double",
+                                                                    "datetime"
+                                                                ]
+                                                            },
+                                                            description: {
+                                                                title: "Description explaining the business purpose and usage of this field",
+                                                                description: "Description explaining the business purpose and usage of this field.\n\nShould clearly explain:\n\n- What business concept this field represents\n- Valid values or constraints if applicable\n- How it relates to business processes\n- Any special behavioral notes Example: \"Amount of cash payment.\" or\n  \"Whether the unit is required or not.\"",
+                                                                type: "string"
+                                                            },
+                                                            nullable: {
+                                                                title: "Whether this field can contain null values",
+                                                                description: "Whether this field can contain null values.\n\nTrue: Field is optional and can be null (e.g., middle name, description)\nfalse: Field is required and cannot be null (e.g., creation timestamp,\nname) Reflects business rules about mandatory vs optional data.",
+                                                                type: "boolean"
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "name",
+                                                            "type",
+                                                            "description",
+                                                            "nullable"
+                                                        ]
+                                                    }
+                                                },
+                                                uniqueIndexes: {
+                                                    title: "Array of unique indexes for enforcing data integrity constraints",
+                                                    description: "Array of unique indexes for enforcing data integrity constraints.\n\nEnsure uniqueness across single or multiple columns. Examples: unique\nemail addresses, unique codes within a channel, unique combinations like\n(channel_id, nickname).",
+                                                    type: "array",
+                                                    items: {
+                                                        description: "Description of the current {@link AutoBePrisma.IUniqueIndex} type:\n\n> Interface representing a unique index constraint on one or more fields.\n> \n> Unique indexes enforce data integrity by ensuring no duplicate values exist\n> for the specified field combination. Essential for business rules that\n> require uniqueness like email addresses, codes, or composite keys.",
+                                                        type: "object",
+                                                        properties: {
+                                                            fieldNames: {
+                                                                title: "Array of field names that together form the unique constraint",
+                                                                description: "Array of field names that together form the unique constraint.\n\nCan be single field (e.g., [\"email\"]) or composite (e.g., [\"channel_id\",\n\"code\"]). All field names must exist in the model. Order matters for\ncomposite indexes. Examples: [\"code\"], [\"shopping_channel_id\",\n\"nickname\"], [\"email\"]\n\n\n@minItems 1\n@uniqueItems",
+                                                                type: "array",
+                                                                items: {
+                                                                    type: "string"
+                                                                }
+                                                            },
+                                                            unique: {
+                                                                title: "Explicit marker indicating this is a unique index",
+                                                                description: "Explicit marker indicating this is a unique index.\n\nAlways true to distinguish from regular indexes. Used by code generator\nto emit \"@@unique\" directive in Prisma schema instead of \"@@index\".",
+                                                                type: "boolean",
+                                                                "enum": [
+                                                                    true
+                                                                ]
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "fieldNames",
+                                                            "unique"
+                                                        ]
+                                                    }
+                                                },
+                                                plainIndexes: {
+                                                    title: "Array of regular indexes for query performance optimization",
+                                                    description: "Array of regular indexes for query performance optimization.\n\nSpeed up common query patterns like filtering by foreign keys, date\nranges, or frequently searched fields. Examples: indexes on created_at,\nforeign key fields, search fields.",
+                                                    type: "array",
+                                                    items: {
+                                                        description: "Description of the current {@link AutoBePrisma.IPlainIndex} type:\n\n> Interface representing a regular (non-unique) index for query performance.\n> \n> Regular indexes speed up database queries by creating optimized data\n> structures for common search patterns. Essential for foreign keys, date\n> ranges, and frequently filtered fields.",
+                                                        type: "object",
+                                                        properties: {
+                                                            fieldNames: {
+                                                                title: "Array of field names to include in the performance index",
+                                                                description: "Array of field names to include in the performance index.\n\nCan be single field (e.g., [\"created_at\"]) or composite (e.g.,\n[\"customer_id\", \"created_at\"]). All field names must exist in the model.\nOrder matters for composite indexes and should match common query\npatterns. Examples: [\"created_at\"], [\"shopping_customer_id\",\n\"created_at\"], [\"ip\"]\n\n\n@minItems 1\n@uniqueItems",
+                                                                type: "array",
+                                                                items: {
+                                                                    type: "string"
+                                                                }
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "fieldNames"
+                                                        ]
+                                                    }
+                                                },
+                                                ginIndexes: {
+                                                    title: "Array of GIN (Generalized Inverted Index) indexes for full-text search",
+                                                    description: "Array of GIN (Generalized Inverted Index) indexes for full-text search.\n\nUsed specifically for PostgreSQL text search capabilities using trigram\noperations. Applied to text fields that need fuzzy matching or partial\ntext search. Examples: searching names, nicknames, titles, content\nbodies.",
+                                                    type: "array",
+                                                    items: {
+                                                        description: "Description of the current {@link AutoBePrisma.IGinIndex} type:\n\n> Interface representing a GIN (Generalized Inverted Index) for full-text\n> search.\n> \n> GIN indexes enable advanced PostgreSQL text search capabilities including\n> fuzzy matching and partial text search using trigram operations. Essential\n> for user-facing search features on text content.",
+                                                        type: "object",
+                                                        properties: {
+                                                            fieldName: {
+                                                                title: "Name of the text field to index for full-text search capabilities",
+                                                                description: "Name of the text field to index for full-text search capabilities.\n\nMust be a string field in the model that contains searchable text.\nExamples from uploaded schemas: \"nickname\", \"title\", \"body\", \"name\" Used\nwith PostgreSQL gin_trgm_ops for trigram-based fuzzy text search.",
+                                                                type: "string"
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "fieldName"
+                                                        ]
+                                                    }
+                                                }
+                                            },
+                                            required: [
+                                                "name",
+                                                "description",
+                                                "material",
+                                                "primaryField",
+                                                "foreignFields",
+                                                "plainFields",
+                                                "uniqueIndexes",
+                                                "plainIndexes",
+                                                "ginIndexes"
+                                            ]
+                                        }
+                                    }
+                                },
+                                required: [
+                                    "filename",
+                                    "namespace",
+                                    "models"
+                                ]
+                            }
+                        }
+                    },
+                    required: [
+                        "planning",
+                        "files"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
+                },
+                description: "Fixes validation errors in AutoBePrisma.IApplication structure while\npreserving ALL existing business logic and model descriptions.\n\n## Core Rules\n\n1. Fix ONLY validation errors - never remove business descriptions\n2. Apply minimal changes - preserve original design intent\n3. Return COMPLETE corrected structure - no data loss allowed\n4. Maintain referential integrity across all models\n\n## Preservation Requirements\n\n- Keep ALL model and field descriptions\n- Keep business logic and architectural patterns\n- Maintain relationship semantics and cardinality\n- Remove descriptions only when removing duplicate elements\n\n## Fix Strategy\n\n- Resolve structural validation errors without changing business intent\n- Remove duplicate fields/relations while preserving most appropriate ones\n- Fix invalid references and type mismatches\n- Ensure naming conventions and index rules compliance",
+                validate: (() => { const _io0 = input => "string" === typeof input.planning && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && (Array.isArray(input.models) && input.models.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "string" === typeof input.description && "boolean" === typeof input.material && ("object" === typeof input.primaryField && null !== input.primaryField && _io3(input.primaryField)) && (Array.isArray(input.foreignFields) && input.foreignFields.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.plainFields) && input.plainFields.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && (Array.isArray(input.uniqueIndexes) && input.uniqueIndexes.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.plainIndexes) && input.plainIndexes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.ginIndexes) && input.ginIndexes.every(elem => "object" === typeof elem && null !== elem && _io9(elem))); const _io3 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "uuid" === input.type && "string" === typeof input.description; const _io4 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "uuid" === input.type && "string" === typeof input.description && ("object" === typeof input.relation && null !== input.relation && _io5(input.relation)) && "boolean" === typeof input.unique && "boolean" === typeof input.nullable; const _io5 = input => "string" === typeof input.name && RegExp("^[a-zA-Z_][a-zA-Z0-9_]*$").test(input.name) && "string" === typeof input.targetModel; const _io6 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && ("string" === input.type || "boolean" === input.type || "uuid" === input.type || "uri" === input.type || "int" === input.type || "double" === input.type || "datetime" === input.type) && "string" === typeof input.description && "boolean" === typeof input.nullable; const _io7 = input => Array.isArray(input.fieldNames) && (1 <= input.fieldNames.length && __typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && true === input.unique; const _io8 = input => Array.isArray(input.fieldNames) && (1 <= input.fieldNames.length && __typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)); const _io9 = input => "string" === typeof input.fieldName; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.planning || _report(_exceptionable, {
+                        path: _path + ".planning",
+                        expected: "string",
+                        value: input.planning
+                    }), (Array.isArray(input.files) || _report(_exceptionable, {
+                        path: _path + ".files",
+                        expected: "Array<AutoBePrisma.IFile>",
+                        value: input.files
+                    })) && input.files.map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".files[" + _index10 + "]",
+                        expected: "AutoBePrisma.IFile",
+                        value: elem
+                    })) && _vo1(elem, _path + ".files[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".files[" + _index10 + "]",
+                        expected: "AutoBePrisma.IFile",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".files",
+                        expected: "Array<AutoBePrisma.IFile>",
+                        value: input.files
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "string & Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">",
+                        value: input.filename
+                    })) || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "(string & Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">)",
+                        value: input.filename
+                    }), "string" === typeof input.namespace || _report(_exceptionable, {
+                        path: _path + ".namespace",
+                        expected: "string",
+                        value: input.namespace
+                    }), (Array.isArray(input.models) || _report(_exceptionable, {
+                        path: _path + ".models",
+                        expected: "Array<AutoBePrisma.IModel>",
+                        value: input.models
+                    })) && input.models.map((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".models[" + _index11 + "]",
+                        expected: "AutoBePrisma.IModel",
+                        value: elem
+                    })) && _vo2(elem, _path + ".models[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".models[" + _index11 + "]",
+                        expected: "AutoBePrisma.IModel",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".models",
+                        expected: "Array<AutoBePrisma.IModel>",
+                        value: input.models
+                    })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    }), "boolean" === typeof input.material || _report(_exceptionable, {
+                        path: _path + ".material",
+                        expected: "boolean",
+                        value: input.material
+                    }), ("object" === typeof input.primaryField && null !== input.primaryField || _report(_exceptionable, {
+                        path: _path + ".primaryField",
+                        expected: "AutoBePrisma.IPrimaryField",
+                        value: input.primaryField
+                    })) && _vo3(input.primaryField, _path + ".primaryField", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".primaryField",
+                        expected: "AutoBePrisma.IPrimaryField",
+                        value: input.primaryField
+                    }), (Array.isArray(input.foreignFields) || _report(_exceptionable, {
+                        path: _path + ".foreignFields",
+                        expected: "Array<AutoBePrisma.IForeignField>",
+                        value: input.foreignFields
+                    })) && input.foreignFields.map((elem, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index12 + "]",
+                        expected: "AutoBePrisma.IForeignField",
+                        value: elem
+                    })) && _vo4(elem, _path + ".foreignFields[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index12 + "]",
+                        expected: "AutoBePrisma.IForeignField",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".foreignFields",
+                        expected: "Array<AutoBePrisma.IForeignField>",
+                        value: input.foreignFields
+                    }), (Array.isArray(input.plainFields) || _report(_exceptionable, {
+                        path: _path + ".plainFields",
+                        expected: "Array<AutoBePrisma.IPlainField>",
+                        value: input.plainFields
+                    })) && input.plainFields.map((elem, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index13 + "]",
+                        expected: "AutoBePrisma.IPlainField",
+                        value: elem
+                    })) && _vo6(elem, _path + ".plainFields[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index13 + "]",
+                        expected: "AutoBePrisma.IPlainField",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".plainFields",
+                        expected: "Array<AutoBePrisma.IPlainField>",
+                        value: input.plainFields
+                    }), (Array.isArray(input.uniqueIndexes) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes",
+                        expected: "Array<AutoBePrisma.IUniqueIndex>",
+                        value: input.uniqueIndexes
+                    })) && input.uniqueIndexes.map((elem, _index14) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index14 + "]",
+                        expected: "AutoBePrisma.IUniqueIndex",
+                        value: elem
+                    })) && _vo7(elem, _path + ".uniqueIndexes[" + _index14 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index14 + "]",
+                        expected: "AutoBePrisma.IUniqueIndex",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes",
+                        expected: "Array<AutoBePrisma.IUniqueIndex>",
+                        value: input.uniqueIndexes
+                    }), (Array.isArray(input.plainIndexes) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes",
+                        expected: "Array<AutoBePrisma.IPlainIndex>",
+                        value: input.plainIndexes
+                    })) && input.plainIndexes.map((elem, _index15) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index15 + "]",
+                        expected: "AutoBePrisma.IPlainIndex",
+                        value: elem
+                    })) && _vo8(elem, _path + ".plainIndexes[" + _index15 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index15 + "]",
+                        expected: "AutoBePrisma.IPlainIndex",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes",
+                        expected: "Array<AutoBePrisma.IPlainIndex>",
+                        value: input.plainIndexes
+                    }), (Array.isArray(input.ginIndexes) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes",
+                        expected: "Array<AutoBePrisma.IGinIndex>",
+                        value: input.ginIndexes
+                    })) && input.ginIndexes.map((elem, _index16) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index16 + "]",
+                        expected: "AutoBePrisma.IGinIndex",
+                        value: elem
+                    })) && _vo9(elem, _path + ".ginIndexes[" + _index16 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index16 + "]",
+                        expected: "AutoBePrisma.IGinIndex",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes",
+                        expected: "Array<AutoBePrisma.IGinIndex>",
+                        value: input.ginIndexes
+                    })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "uuid" === input.type || _report(_exceptionable, {
+                        path: _path + ".type",
+                        expected: "\"uuid\"",
+                        value: input.type
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    })].every(flag => flag); const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "uuid" === input.type || _report(_exceptionable, {
+                        path: _path + ".type",
+                        expected: "\"uuid\"",
+                        value: input.type
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    }), ("object" === typeof input.relation && null !== input.relation || _report(_exceptionable, {
+                        path: _path + ".relation",
+                        expected: "__type",
+                        value: input.relation
+                    })) && _vo5(input.relation, _path + ".relation", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".relation",
+                        expected: "__type",
+                        value: input.relation
+                    }), "boolean" === typeof input.unique || _report(_exceptionable, {
+                        path: _path + ".unique",
+                        expected: "boolean",
+                        value: input.unique
+                    }), "boolean" === typeof input.nullable || _report(_exceptionable, {
+                        path: _path + ".nullable",
+                        expected: "boolean",
+                        value: input.nullable
+                    })].every(flag => flag); const _vo5 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-zA-Z_][a-zA-Z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-zA-Z_][a-zA-Z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-zA-Z_][a-zA-Z0-9_]*$\">)",
+                        value: input.name
+                    }), "string" === typeof input.targetModel || _report(_exceptionable, {
+                        path: _path + ".targetModel",
+                        expected: "string",
+                        value: input.targetModel
+                    })].every(flag => flag); const _vo6 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "string" === input.type || "boolean" === input.type || "uuid" === input.type || "uri" === input.type || "int" === input.type || "double" === input.type || "datetime" === input.type || _report(_exceptionable, {
+                        path: _path + ".type",
+                        expected: "(\"boolean\" | \"datetime\" | \"double\" | \"int\" | \"string\" | \"uri\" | \"uuid\")",
+                        value: input.type
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    }), "boolean" === typeof input.nullable || _report(_exceptionable, {
+                        path: _path + ".nullable",
+                        expected: "boolean",
+                        value: input.nullable
+                    })].every(flag => flag); const _vo7 = (input, _path, _exceptionable = true) => [(Array.isArray(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    })) && ((1 <= input.fieldNames.length || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.fieldNames
+                    })) && (__typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & UniqueItems<true>",
+                        value: input.fieldNames
+                    })) && input.fieldNames.map((elem, _index17) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index17 + "]",
+                        expected: "string",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    }), true === input.unique || _report(_exceptionable, {
+                        path: _path + ".unique",
+                        expected: "true",
+                        value: input.unique
+                    })].every(flag => flag); const _vo8 = (input, _path, _exceptionable = true) => [(Array.isArray(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    })) && ((1 <= input.fieldNames.length || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.fieldNames
+                    })) && (__typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & UniqueItems<true>",
+                        value: input.fieldNames
+                    })) && input.fieldNames.map((elem, _index18) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index18 + "]",
+                        expected: "string",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    })].every(flag => flag); const _vo9 = (input, _path, _exceptionable = true) => ["string" === typeof input.fieldName || _report(_exceptionable, {
+                        path: _path + ".fieldName",
+                        expected: "string",
+                        value: input.fieldName
+                    })].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: "IModifyPrismaSchemaFilesProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IModifyPrismaSchemaFilesProps",
+                            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,
+    llama: claude,
+    deepseek: claude,
+    "3.1": claude,
+    "3.0": {
+        model: "3.0",
+        options: {
+            constraint: true,
+            recursive: 3,
+            separate: null
+        },
+        functions: [
+            {
+                name: "correctPrismaSchemaFiles",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        planning: {
+                            type: "string",
+                            title: "Detailed execution plan for fixing AutoBePrisma validation errors",
+                            description: "Detailed execution plan for fixing AutoBePrisma validation errors.\n\n\uD83C\uDFAF Purpose: Enable systematic reasoning and step-by-step error resolution\napproach for structured schema validation issues\n\n\uD83D\uDCCB Required Planning Content:\n\n1. **Error Analysis Summary**\n\n   - List all validation errors from IAutoBePrismaValidation.IError[] array\n   - Categorize errors by type (duplications, references, types, indexes)\n   - Identify root causes and error interdependencies\n2. **Fix Strategy Overview**\n\n   - Prioritize fixes based on dependencies (fix duplications first)\n   - Outline minimal changes needed for each validation error\n   - Identify potential impact on other models/relationships\n3. **Step-by-Step Fix Plan**\n\n   - Model-by-model modification plan with specific changes\n   - Exact field additions, removals, or renames required\n   - Reference updates needed for renamed elements\n   - Index corrections to comply with validation rules\n4. **Preservation Checklist**\n\n   - Confirm which descriptions and business logic must be preserved\n   - List relationships and constraints to maintain unchanged\n   - Identify cross-model dependencies that must remain intact\n5. **Risk Assessment**\n\n   - Potential side effects of each planned fix\n   - Validation points to check after applying corrections\n   - Ensure no new validation errors are introduced\n\n\uD83D\uDCA1 Example Planning Structure:\n\n    ## Error Analysis\n    - Error 1: Duplicate field 'name' in shopping_customers model\n    - Error 2: Invalid targetModel 'shopping_customer' should be 'shopping_customers'\n\n    ## Fix Strategy\n    1. Remove duplicate 'name' field (keep the more detailed one)\n    2. Update foreign key references to use correct plural model name\n\n    ## Detailed Steps\n    1. shopping_customers model: Remove second 'name' field from plainFields\n    2. shopping_orders model: Update targetModel from 'shopping_customer' to 'shopping_customers'\n\n    ## Preservation Notes\n    - Keep business descriptions for remaining 'name' field\n    - Maintain all relationship semantics\n    - Preserve all indexes and constraints"
+                        },
+                        files: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    filename: {
+                                        type: "string",
+                                        pattern: "^[a-zA-Z0-9._-]+\\.prisma$",
+                                        title: "Name of the schema file to be generated",
+                                        description: "Name of the schema file to be generated.\n\nShould follow the naming convention: \"schema-{number}-{domain}.prisma\"\nExamples: \"schema-02-systematic.prisma\", \"schema-03-actors.prisma\" The\nnumber indicates the dependency order for schema generation."
+                                    },
+                                    namespace: {
+                                        type: "string",
+                                        title: "Business domain namespace that groups related models",
+                                        description: "Business domain namespace that groups related models.\n\nUsed in Prisma documentation comments as \"@\\namespace directive\".\nExamples from uploaded schemas: \"Systematic\", \"Actors\", \"Sales\", \"Carts\",\n\"Orders\", \"Coupons\", \"Coins\", \"Inquiries\", \"Favorites\", \"Articles\""
+                                    },
+                                    models: {
+                                        type: "array",
+                                        items: {
+                                            type: "object",
+                                            properties: {
+                                                name: {
+                                                    type: "string",
+                                                    pattern: "^[a-z][a-z0-9_]*$",
+                                                    title: "Name of the Prisma model (database table name)",
+                                                    description: "Name of the Prisma model (database table name).\n\nShould follow snake_case convention with domain prefix. Examples:\n\"shopping_customers\", \"shopping_sale_snapshots\", \"bbs_articles\"\nMaterialized views use \"mv_\" prefix: \"mv_shopping_sale_last_snapshots\""
+                                                },
+                                                description: {
+                                                    type: "string",
+                                                    description: "Detailed description explaining the business purpose and usage of the\nmodel.\n\nShould include:\n\n- Business context and purpose\n- Key relationships with other models\n- Important behavioral notes or constraints\n- References to related entities using \"{@\\link ModelName}\" syntax Example:\n  \"Customer information, but not a person but a **connection** basis...\""
+                                                },
+                                                material: {
+                                                    type: "boolean",
+                                                    description: "Indicates whether this model represents a materialized view for\nperformance optimization.\n\nMaterialized views are read-only computed tables that cache complex query\nresults. They're marked as \"@\\hidden\" in documentation and prefixed with\n\"mv_\" in naming. Examples: mv_shopping_sale_last_snapshots,\nmv_shopping_cart_commodity_prices"
+                                                },
+                                                primaryField: {
+                                                    type: "object",
+                                                    properties: {
+                                                        name: {
+                                                            type: "string",
+                                                            pattern: "^[a-z][a-z0-9_]*$",
+                                                            title: "Name of the primary key field",
+                                                            description: "Name of the primary key field.\n\nConsistently named \"id\" across all models in the uploaded schemas.\nRepresents the unique identifier for each record in the table."
+                                                        },
+                                                        type: {
+                                                            type: "string",
+                                                            "enum": [
+                                                                "uuid"
+                                                            ],
+                                                            title: "Data type of the primary key field",
+                                                            description: "Data type of the primary key field.\n\nAlways \"uuid\" in the uploaded schemas for better distributed system\nsupport and to avoid exposing sequential IDs that could reveal business\ninformation."
+                                                        },
+                                                        description: {
+                                                            type: "string",
+                                                            title: "Description of the primary key field's purpose",
+                                                            description: "Description of the primary key field's purpose.\n\nStandard description is \"Primary Key.\" across all models. Serves as the\nunique identifier for the model instance."
+                                                        }
+                                                    },
+                                                    required: [
+                                                        "name",
+                                                        "type",
+                                                        "description"
+                                                    ],
+                                                    description: "The primary key field of the model.\n\nIn all uploaded schemas, primary keys are always UUID type with \"@\\id\"\ndirective. Usually named \"id\" and marked with \"@\\db.Uuid\" for PostgreSQL\nmapping.\n\n------------------------------\n\nDescription of the current {@link AutoBePrisma.IPrimaryField} type:\n\n> Interface representing the primary key field of a Prisma model.\n> \n> All models in the uploaded schemas use UUID as primary key for better\n> distributed system compatibility and security (no sequential ID exposure).",
+                                                    additionalProperties: false
+                                                },
+                                                foreignFields: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "object",
+                                                        properties: {
+                                                            name: {
+                                                                type: "string",
+                                                                pattern: "^[a-z][a-z0-9_]*$",
+                                                                title: "Name of the foreign key field",
+                                                                description: "Name of the foreign key field.\n\nFollows convention: \"{target_model_name_without_prefix}_id\" Examples:\n\"shopping_customer_id\", \"bbs_article_id\", \"attachment_file_id\" For\nself-references: \"parent_id\" (e.g., in hierarchical structures)"
+                                                            },
+                                                            type: {
+                                                                type: "string",
+                                                                "enum": [
+                                                                    "uuid"
+                                                                ],
+                                                                title: "Data type of the foreign key field",
+                                                                description: "Data type of the foreign key field.\n\nAlways \"uuid\" to match the primary key type of referenced models. Ensures\nreferential integrity and consistency across the schema."
+                                                            },
+                                                            description: {
+                                                                type: "string",
+                                                                description: "Description explaining the purpose and target of this foreign key\nrelationship.\n\nShould reference the target model using format: \"Target model's {@\\link\nModelName.id}\" Examples: \"Belonged customer's {@\\link\nshopping_customers.id}\" May include additional context about the\nrelationship's business meaning."
+                                                            },
+                                                            relation: {
+                                                                type: "object",
+                                                                properties: {
+                                                                    name: {
+                                                                        type: "string",
+                                                                        pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$",
+                                                                        title: "Name of the relation property in the Prisma model",
+                                                                        description: "Name of the relation property in the Prisma model.\n\nUsed to access the related model instance. Usually a descriptive name\nof the relationship. Examples: \"customer\", \"channel\", \"parent\",\n\"snapshot\""
+                                                                    },
+                                                                    targetModel: {
+                                                                        type: "string",
+                                                                        title: "Name of the target model being referenced",
+                                                                        description: "Name of the target model being referenced.\n\nMust match exactly with an existing model name in the schema. Examples:\n\"shopping_customers\", \"shopping_channels\", \"bbs_articles\""
+                                                                    }
+                                                                },
+                                                                required: [
+                                                                    "name",
+                                                                    "targetModel"
+                                                                ],
+                                                                title: "Prisma relation configuration defining the association details",
+                                                                description: "Prisma relation configuration defining the association details.\n\nSpecifies how this foreign key connects to the target model, including\nrelation name, target model, and target field.",
+                                                                additionalProperties: false
+                                                            },
+                                                            unique: {
+                                                                type: "boolean",
+                                                                title: "Whether this foreign key has a unique constraint",
+                                                                description: "Whether this foreign key has a unique constraint.\n\nTrue: Creates a 1:1 relationship (e.g., user profile, order publish\ndetails) false: Allows 1:N relationship (e.g., customer to multiple\norders) Used for enforcing business rules about relationship\ncardinality."
+                                                            },
+                                                            nullable: {
+                                                                type: "boolean",
+                                                                title: "Whether this foreign key can be null (optional relationship)",
+                                                                description: "Whether this foreign key can be null (optional relationship).\n\nTrue: Relationship is optional, foreign key can be null false:\nRelationship is required, foreign key cannot be null Reflects business\nrules about mandatory vs optional associations."
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "name",
+                                                            "type",
+                                                            "description",
+                                                            "relation",
+                                                            "unique",
+                                                            "nullable"
+                                                        ],
+                                                        description: "Description of the current {@link AutoBePrisma.IForeignField} type:\n\n> Interface representing a foreign key field that establishes relationships\n> between models.\n> \n> Foreign keys create associations between models, enabling relational data\n> modeling. They can represent 1:1, 1:N, or participate in M:N relationships\n> through junction tables.",
+                                                        additionalProperties: false
+                                                    },
+                                                    title: "Array of foreign key fields that reference other models",
+                                                    description: "Array of foreign key fields that reference other models.\n\nThese establish relationships between models and include Prisma relation\ndirectives. Can be nullable (optional relationships) or required\n(mandatory relationships). May have unique constraints for 1:1\nrelationships."
+                                                },
+                                                plainFields: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "object",
+                                                        properties: {
+                                                            name: {
+                                                                type: "string",
+                                                                pattern: "^[a-z][a-z0-9_]*$",
+                                                                title: "Name of the field in the database table",
+                                                                description: "Name of the field in the database table.\n\nShould use snake_case convention. Common patterns from uploaded schemas:\n\n- Timestamps: created_at, updated_at, deleted_at, opened_at, closed_at\n- Identifiers: code, name, nickname, title\n- Business data: value, quantity, price, volume, balance\n- Flags: primary, required, exclusive, secret, multiplicative"
+                                                            },
+                                                            type: {
+                                                                type: "string",
+                                                                "enum": [
+                                                                    "string",
+                                                                    "boolean",
+                                                                    "uuid",
+                                                                    "uri",
+                                                                    "int",
+                                                                    "double",
+                                                                    "datetime"
+                                                                ],
+                                                                title: "Data type of the field for Prisma schema generation",
+                                                                description: "Data type of the field for Prisma schema generation.\n\nMaps to appropriate Prisma/PostgreSQL types:\n\n- Boolean: Boolean flags and yes/no values\n- Int: Integer numbers, quantities, sequences\n- Double: Decimal numbers, prices, monetary values, percentages\n- String: Text data, names, descriptions, codes\n- Uri: URL/URI fields for links and references\n- Uuid: UUID fields (for non-foreign-key UUIDs)\n- Date: Date-only values (rare, mostly for business dates)\n- Datetime: Timestamp fields with date and time"
+                                                            },
+                                                            description: {
+                                                                type: "string",
+                                                                title: "Description explaining the business purpose and usage of this field",
+                                                                description: "Description explaining the business purpose and usage of this field.\n\nShould clearly explain:\n\n- What business concept this field represents\n- Valid values or constraints if applicable\n- How it relates to business processes\n- Any special behavioral notes Example: \"Amount of cash payment.\" or\n  \"Whether the unit is required or not.\""
+                                                            },
+                                                            nullable: {
+                                                                type: "boolean",
+                                                                title: "Whether this field can contain null values",
+                                                                description: "Whether this field can contain null values.\n\nTrue: Field is optional and can be null (e.g., middle name, description)\nfalse: Field is required and cannot be null (e.g., creation timestamp,\nname) Reflects business rules about mandatory vs optional data."
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "name",
+                                                            "type",
+                                                            "description",
+                                                            "nullable"
+                                                        ],
+                                                        description: "Description of the current {@link AutoBePrisma.IPlainField} type:\n\n> Interface representing a regular data field that stores business\n> information.\n> \n> These fields contain the actual business data like names, amounts,\n> timestamps, flags, descriptions, and other domain-specific information.",
+                                                        additionalProperties: false
+                                                    },
+                                                    title: "Array of regular data fields that don't reference other models",
+                                                    description: "Array of regular data fields that don't reference other models.\n\nInclude business data like names, descriptions, timestamps, flags,\namounts, etc. Common patterns: created_at, updated_at, deleted_at for\nsoft deletion and auditing."
+                                                },
+                                                uniqueIndexes: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "object",
+                                                        properties: {
+                                                            fieldNames: {
+                                                                type: "array",
+                                                                items: {
+                                                                    type: "string"
+                                                                },
+                                                                minItems: 1,
+                                                                uniqueItems: true,
+                                                                title: "Array of field names that together form the unique constraint",
+                                                                description: "Array of field names that together form the unique constraint.\n\nCan be single field (e.g., [\"email\"]) or composite (e.g., [\"channel_id\",\n\"code\"]). All field names must exist in the model. Order matters for\ncomposite indexes. Examples: [\"code\"], [\"shopping_channel_id\",\n\"nickname\"], [\"email\"]"
+                                                            },
+                                                            unique: {
+                                                                type: "boolean",
+                                                                "enum": [
+                                                                    true
+                                                                ],
+                                                                title: "Explicit marker indicating this is a unique index",
+                                                                description: "Explicit marker indicating this is a unique index.\n\nAlways true to distinguish from regular indexes. Used by code generator\nto emit \"@@unique\" directive in Prisma schema instead of \"@@index\"."
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "fieldNames",
+                                                            "unique"
+                                                        ],
+                                                        description: "Description of the current {@link AutoBePrisma.IUniqueIndex} type:\n\n> Interface representing a unique index constraint on one or more fields.\n> \n> Unique indexes enforce data integrity by ensuring no duplicate values exist\n> for the specified field combination. Essential for business rules that\n> require uniqueness like email addresses, codes, or composite keys.",
+                                                        additionalProperties: false
+                                                    },
+                                                    title: "Array of unique indexes for enforcing data integrity constraints",
+                                                    description: "Array of unique indexes for enforcing data integrity constraints.\n\nEnsure uniqueness across single or multiple columns. Examples: unique\nemail addresses, unique codes within a channel, unique combinations like\n(channel_id, nickname)."
+                                                },
+                                                plainIndexes: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "object",
+                                                        properties: {
+                                                            fieldNames: {
+                                                                type: "array",
+                                                                items: {
+                                                                    type: "string"
+                                                                },
+                                                                minItems: 1,
+                                                                uniqueItems: true,
+                                                                title: "Array of field names to include in the performance index",
+                                                                description: "Array of field names to include in the performance index.\n\nCan be single field (e.g., [\"created_at\"]) or composite (e.g.,\n[\"customer_id\", \"created_at\"]). All field names must exist in the model.\nOrder matters for composite indexes and should match common query\npatterns. Examples: [\"created_at\"], [\"shopping_customer_id\",\n\"created_at\"], [\"ip\"]"
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "fieldNames"
+                                                        ],
+                                                        description: "Description of the current {@link AutoBePrisma.IPlainIndex} type:\n\n> Interface representing a regular (non-unique) index for query performance.\n> \n> Regular indexes speed up database queries by creating optimized data\n> structures for common search patterns. Essential for foreign keys, date\n> ranges, and frequently filtered fields.",
+                                                        additionalProperties: false
+                                                    },
+                                                    title: "Array of regular indexes for query performance optimization",
+                                                    description: "Array of regular indexes for query performance optimization.\n\nSpeed up common query patterns like filtering by foreign keys, date\nranges, or frequently searched fields. Examples: indexes on created_at,\nforeign key fields, search fields."
+                                                },
+                                                ginIndexes: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "object",
+                                                        properties: {
+                                                            fieldName: {
+                                                                type: "string",
+                                                                title: "Name of the text field to index for full-text search capabilities",
+                                                                description: "Name of the text field to index for full-text search capabilities.\n\nMust be a string field in the model that contains searchable text.\nExamples from uploaded schemas: \"nickname\", \"title\", \"body\", \"name\" Used\nwith PostgreSQL gin_trgm_ops for trigram-based fuzzy text search."
+                                                            }
+                                                        },
+                                                        required: [
+                                                            "fieldName"
+                                                        ],
+                                                        description: "Description of the current {@link AutoBePrisma.IGinIndex} type:\n\n> Interface representing a GIN (Generalized Inverted Index) for full-text\n> search.\n> \n> GIN indexes enable advanced PostgreSQL text search capabilities including\n> fuzzy matching and partial text search using trigram operations. Essential\n> for user-facing search features on text content.",
+                                                        additionalProperties: false
+                                                    },
+                                                    title: "Array of GIN (Generalized Inverted Index) indexes for full-text search",
+                                                    description: "Array of GIN (Generalized Inverted Index) indexes for full-text search.\n\nUsed specifically for PostgreSQL text search capabilities using trigram\noperations. Applied to text fields that need fuzzy matching or partial\ntext search. Examples: searching names, nicknames, titles, content\nbodies."
+                                                }
+                                            },
+                                            required: [
+                                                "name",
+                                                "description",
+                                                "material",
+                                                "primaryField",
+                                                "foreignFields",
+                                                "plainFields",
+                                                "uniqueIndexes",
+                                                "plainIndexes",
+                                                "ginIndexes"
+                                            ],
+                                            description: "Description of the current {@link AutoBePrisma.IModel} type:\n\n> Interface representing a single Prisma model (database table).\n> \n> Based on the uploaded schemas, models follow specific patterns:\n> \n> - Main business entities (e.g., shopping_sales, shopping_customers)\n> - Snapshot/versioning entities for audit trails (e.g.,\n>   shopping_sale_snapshots)\n> - Junction tables for M:N relationships (e.g.,\n>   shopping_cart_commodity_stocks)\n> - Materialized views for performance (prefixed with mv_)",
+                                            additionalProperties: false
+                                        },
+                                        title: "Array of Prisma models (database tables) within this domain",
+                                        description: "Array of Prisma models (database tables) within this domain.\n\nEach model represents a business entity or concept within the namespace.\nModels can reference each other through foreign key relationships."
+                                    }
+                                },
+                                required: [
+                                    "filename",
+                                    "namespace",
+                                    "models"
+                                ],
+                                description: "Description of the current {@link AutoBePrisma.IFile} type:\n\n> Interface representing a single Prisma schema file within the application.\n> \n> Each file focuses on a specific business domain and contains related\n> models. File organization follows domain-driven design principles as seen\n> in the uploaded schemas.",
+                                additionalProperties: false
+                            },
+                            description: "Original AutoBePrisma.IApplication structure that contains validation\nerrors and needs correction.\n\n\uD83D\uDCE5 Input Structure:\n\n- Complete IApplication with files array containing validation errors\n- Each file contains models with potential structural issues\n- Errors may include duplications, invalid references, or constraint\n  violations\n\n\uD83D\uDD0D Expected Validation Issues:\n\n- Duplicate model names across files\n- Duplicate field/relation names within models\n- Invalid foreign key references to non-existent models\n- Single foreign key fields in index arrays\n- Non-plural model names or invalid naming conventions\n\n\uD83D\uDCDD Application Content Analysis:\n\n- All models with their complete field definitions\n- All relationships with targetModel and targetfield configurations\n- All indexes (unique, plain, GIN) with field references\n- All business descriptions and requirement mappings\n- Cross-file model references and dependencies\n\n\u26A0\uFE0F Processing Notes:\n\n- Structure may contain validation errors that prevent code generation\n- Some models might reference non-existent targets\n- Field names might violate naming conventions\n- Index configurations might include forbidden single foreign keys\n- Business logic and descriptions must be preserved during fixes"
+                        }
+                    },
+                    required: [
+                        "planning",
+                        "files"
+                    ],
+                    description: "Current Type: {@link IModifyPrismaSchemaFilesProps}",
+                    additionalProperties: false
+                },
+                description: "Fixes validation errors in AutoBePrisma.IApplication structure while\npreserving ALL existing business logic and model descriptions.\n\n## Core Rules\n\n1. Fix ONLY validation errors - never remove business descriptions\n2. Apply minimal changes - preserve original design intent\n3. Return COMPLETE corrected structure - no data loss allowed\n4. Maintain referential integrity across all models\n\n## Preservation Requirements\n\n- Keep ALL model and field descriptions\n- Keep business logic and architectural patterns\n- Maintain relationship semantics and cardinality\n- Remove descriptions only when removing duplicate elements\n\n## Fix Strategy\n\n- Resolve structural validation errors without changing business intent\n- Remove duplicate fields/relations while preserving most appropriate ones\n- Fix invalid references and type mismatches\n- Ensure naming conventions and index rules compliance",
+                validate: (() => { const _io0 = input => "string" === typeof input.planning && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && (Array.isArray(input.models) && input.models.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io2 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "string" === typeof input.description && "boolean" === typeof input.material && ("object" === typeof input.primaryField && null !== input.primaryField && _io3(input.primaryField)) && (Array.isArray(input.foreignFields) && input.foreignFields.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.plainFields) && input.plainFields.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && (Array.isArray(input.uniqueIndexes) && input.uniqueIndexes.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.plainIndexes) && input.plainIndexes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.ginIndexes) && input.ginIndexes.every(elem => "object" === typeof elem && null !== elem && _io9(elem))); const _io3 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "uuid" === input.type && "string" === typeof input.description; const _io4 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && "uuid" === input.type && "string" === typeof input.description && ("object" === typeof input.relation && null !== input.relation && _io5(input.relation)) && "boolean" === typeof input.unique && "boolean" === typeof input.nullable; const _io5 = input => "string" === typeof input.name && RegExp("^[a-zA-Z_][a-zA-Z0-9_]*$").test(input.name) && "string" === typeof input.targetModel; const _io6 = input => "string" === typeof input.name && RegExp("^[a-z][a-z0-9_]*$").test(input.name) && ("string" === input.type || "boolean" === input.type || "uuid" === input.type || "uri" === input.type || "int" === input.type || "double" === input.type || "datetime" === input.type) && "string" === typeof input.description && "boolean" === typeof input.nullable; const _io7 = input => Array.isArray(input.fieldNames) && (1 <= input.fieldNames.length && __typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && true === input.unique; const _io8 = input => Array.isArray(input.fieldNames) && (1 <= input.fieldNames.length && __typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)); const _io9 = input => "string" === typeof input.fieldName; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.planning || _report(_exceptionable, {
+                        path: _path + ".planning",
+                        expected: "string",
+                        value: input.planning
+                    }), (Array.isArray(input.files) || _report(_exceptionable, {
+                        path: _path + ".files",
+                        expected: "Array<AutoBePrisma.IFile>",
+                        value: input.files
+                    })) && input.files.map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".files[" + _index10 + "]",
+                        expected: "AutoBePrisma.IFile",
+                        value: elem
+                    })) && _vo1(elem, _path + ".files[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".files[" + _index10 + "]",
+                        expected: "AutoBePrisma.IFile",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".files",
+                        expected: "Array<AutoBePrisma.IFile>",
+                        value: input.files
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "string & Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">",
+                        value: input.filename
+                    })) || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "(string & Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">)",
+                        value: input.filename
+                    }), "string" === typeof input.namespace || _report(_exceptionable, {
+                        path: _path + ".namespace",
+                        expected: "string",
+                        value: input.namespace
+                    }), (Array.isArray(input.models) || _report(_exceptionable, {
+                        path: _path + ".models",
+                        expected: "Array<AutoBePrisma.IModel>",
+                        value: input.models
+                    })) && input.models.map((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".models[" + _index11 + "]",
+                        expected: "AutoBePrisma.IModel",
+                        value: elem
+                    })) && _vo2(elem, _path + ".models[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".models[" + _index11 + "]",
+                        expected: "AutoBePrisma.IModel",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".models",
+                        expected: "Array<AutoBePrisma.IModel>",
+                        value: input.models
+                    })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    }), "boolean" === typeof input.material || _report(_exceptionable, {
+                        path: _path + ".material",
+                        expected: "boolean",
+                        value: input.material
+                    }), ("object" === typeof input.primaryField && null !== input.primaryField || _report(_exceptionable, {
+                        path: _path + ".primaryField",
+                        expected: "AutoBePrisma.IPrimaryField",
+                        value: input.primaryField
+                    })) && _vo3(input.primaryField, _path + ".primaryField", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".primaryField",
+                        expected: "AutoBePrisma.IPrimaryField",
+                        value: input.primaryField
+                    }), (Array.isArray(input.foreignFields) || _report(_exceptionable, {
+                        path: _path + ".foreignFields",
+                        expected: "Array<AutoBePrisma.IForeignField>",
+                        value: input.foreignFields
+                    })) && input.foreignFields.map((elem, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index12 + "]",
+                        expected: "AutoBePrisma.IForeignField",
+                        value: elem
+                    })) && _vo4(elem, _path + ".foreignFields[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index12 + "]",
+                        expected: "AutoBePrisma.IForeignField",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".foreignFields",
+                        expected: "Array<AutoBePrisma.IForeignField>",
+                        value: input.foreignFields
+                    }), (Array.isArray(input.plainFields) || _report(_exceptionable, {
+                        path: _path + ".plainFields",
+                        expected: "Array<AutoBePrisma.IPlainField>",
+                        value: input.plainFields
+                    })) && input.plainFields.map((elem, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index13 + "]",
+                        expected: "AutoBePrisma.IPlainField",
+                        value: elem
+                    })) && _vo6(elem, _path + ".plainFields[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index13 + "]",
+                        expected: "AutoBePrisma.IPlainField",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".plainFields",
+                        expected: "Array<AutoBePrisma.IPlainField>",
+                        value: input.plainFields
+                    }), (Array.isArray(input.uniqueIndexes) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes",
+                        expected: "Array<AutoBePrisma.IUniqueIndex>",
+                        value: input.uniqueIndexes
+                    })) && input.uniqueIndexes.map((elem, _index14) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index14 + "]",
+                        expected: "AutoBePrisma.IUniqueIndex",
+                        value: elem
+                    })) && _vo7(elem, _path + ".uniqueIndexes[" + _index14 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index14 + "]",
+                        expected: "AutoBePrisma.IUniqueIndex",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes",
+                        expected: "Array<AutoBePrisma.IUniqueIndex>",
+                        value: input.uniqueIndexes
+                    }), (Array.isArray(input.plainIndexes) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes",
+                        expected: "Array<AutoBePrisma.IPlainIndex>",
+                        value: input.plainIndexes
+                    })) && input.plainIndexes.map((elem, _index15) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index15 + "]",
+                        expected: "AutoBePrisma.IPlainIndex",
+                        value: elem
+                    })) && _vo8(elem, _path + ".plainIndexes[" + _index15 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index15 + "]",
+                        expected: "AutoBePrisma.IPlainIndex",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes",
+                        expected: "Array<AutoBePrisma.IPlainIndex>",
+                        value: input.plainIndexes
+                    }), (Array.isArray(input.ginIndexes) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes",
+                        expected: "Array<AutoBePrisma.IGinIndex>",
+                        value: input.ginIndexes
+                    })) && input.ginIndexes.map((elem, _index16) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index16 + "]",
+                        expected: "AutoBePrisma.IGinIndex",
+                        value: elem
+                    })) && _vo9(elem, _path + ".ginIndexes[" + _index16 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index16 + "]",
+                        expected: "AutoBePrisma.IGinIndex",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes",
+                        expected: "Array<AutoBePrisma.IGinIndex>",
+                        value: input.ginIndexes
+                    })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "uuid" === input.type || _report(_exceptionable, {
+                        path: _path + ".type",
+                        expected: "\"uuid\"",
+                        value: input.type
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    })].every(flag => flag); const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "uuid" === input.type || _report(_exceptionable, {
+                        path: _path + ".type",
+                        expected: "\"uuid\"",
+                        value: input.type
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    }), ("object" === typeof input.relation && null !== input.relation || _report(_exceptionable, {
+                        path: _path + ".relation",
+                        expected: "__type",
+                        value: input.relation
+                    })) && _vo5(input.relation, _path + ".relation", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".relation",
+                        expected: "__type",
+                        value: input.relation
+                    }), "boolean" === typeof input.unique || _report(_exceptionable, {
+                        path: _path + ".unique",
+                        expected: "boolean",
+                        value: input.unique
+                    }), "boolean" === typeof input.nullable || _report(_exceptionable, {
+                        path: _path + ".nullable",
+                        expected: "boolean",
+                        value: input.nullable
+                    })].every(flag => flag); const _vo5 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-zA-Z_][a-zA-Z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-zA-Z_][a-zA-Z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-zA-Z_][a-zA-Z0-9_]*$\">)",
+                        value: input.name
+                    }), "string" === typeof input.targetModel || _report(_exceptionable, {
+                        path: _path + ".targetModel",
+                        expected: "string",
+                        value: input.targetModel
+                    })].every(flag => flag); const _vo6 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-z0-9_]*$").test(input.name) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        value: input.name
+                    }), "string" === input.type || "boolean" === input.type || "uuid" === input.type || "uri" === input.type || "int" === input.type || "double" === input.type || "datetime" === input.type || _report(_exceptionable, {
+                        path: _path + ".type",
+                        expected: "(\"boolean\" | \"datetime\" | \"double\" | \"int\" | \"string\" | \"uri\" | \"uuid\")",
+                        value: input.type
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    }), "boolean" === typeof input.nullable || _report(_exceptionable, {
+                        path: _path + ".nullable",
+                        expected: "boolean",
+                        value: input.nullable
+                    })].every(flag => flag); const _vo7 = (input, _path, _exceptionable = true) => [(Array.isArray(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    })) && ((1 <= input.fieldNames.length || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.fieldNames
+                    })) && (__typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & UniqueItems<true>",
+                        value: input.fieldNames
+                    })) && input.fieldNames.map((elem, _index17) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index17 + "]",
+                        expected: "string",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    }), true === input.unique || _report(_exceptionable, {
+                        path: _path + ".unique",
+                        expected: "true",
+                        value: input.unique
+                    })].every(flag => flag); const _vo8 = (input, _path, _exceptionable = true) => [(Array.isArray(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    })) && ((1 <= input.fieldNames.length || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.fieldNames
+                    })) && (__typia_transform__isUniqueItems._isUniqueItems(input.fieldNames) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "Array<> & UniqueItems<true>",
+                        value: input.fieldNames
+                    })) && input.fieldNames.map((elem, _index18) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index18 + "]",
+                        expected: "string",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".fieldNames",
+                        expected: "(Array<string> & MinItems<1> & UniqueItems<true>)",
+                        value: input.fieldNames
+                    })].every(flag => flag); const _vo9 = (input, _path, _exceptionable = true) => ["string" === typeof input.fieldName || _report(_exceptionable, {
+                        path: _path + ".fieldName",
+                        expected: "string",
+                        value: input.fieldName
+                    })].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: "IModifyPrismaSchemaFilesProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IModifyPrismaSchemaFilesProps",
+                            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=orchestratePrismaCorrect.js.map