@autobe/agent 0.3.23 → 0.4.0

package/lib/orchestrate/prisma/orchestratePrismaSchema.js

@@ -46,6 +46,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratePrismaSchemas = orchestratePrismaSchemas;
+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"));
@@ -67,8 +68,7 @@ function orchestratePrismaSchemas(ctx, components) {
             const event = {
                 type: "prismaSchemas",
                 created_at: start.toISOString(),
-                filename: c.filename,
-                content: result.content,
+                file: result.file,
                 completed: (i += c.tables.length),
                 total,
                 step: (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
@@ -95,6 +95,7 @@ function process(ctx, component) {
                     model: ctx.model,
                     build: (next) => {
                         pointer.value = next;
+                        pointer.value.file.filename = component.filename;
                     },
                 }),
             ],
@@ -104,29 +105,7 @@ function process(ctx, component) {
                 event.body.tool_choice = "required";
             }
         }));
-        yield agentica.conversate([
-            "Please generate Prisma schema files based on the previous requirement analysis report.",
-            "",
-            "**Context:**",
-            `- Target filename: \`${component.filename}\``,
-            `- Tables to implement in this file: \`${component.tables.join("`, `")}\``,
-            `- All available tables in the system: \`${component.entireTables.join("`, `")}\``,
-            "",
-            "**Instructions:**",
-            "1. Create comprehensive Prisma schema content for the specified tables",
-            "2. Reference the previous requirement analysis to understand business logic and data structures",
-            "3. Establish appropriate relationships between tables using the entireTables list as reference",
-            "4. Include proper field types, constraints, indexes, and documentation",
-            "5. Follow enterprise-level schema design patterns and best practices",
-            "6. Ensure cross-table relationships are accurately modeled based on business requirements",
-            "",
-            "**Key Requirements:**",
-            "- Implement only the tables specified for this file",
-            "- Create foreign key relationships to tables from entireTables when business logic requires it",
-            "- Add comprehensive field documentation and model descriptions",
-            "- Include appropriate indexes for performance optimization",
-            "- Follow consistent naming conventions and data types",
-        ].join("\n"));
+        yield agentica.conversate("Make prisma schema file please");
         if (pointer.value === null)
             throw new Error("Unreachable code: Prisma Schema not generated");
         return pointer.value;
@@ -140,7 +119,7 @@ function createApplication(props) {
         name: "Prisma Generator",
         application,
         execute: {
-            makePrismaSchemaFiles: (next) => {
+            makePrismaSchemaFile: (next) => {
                 props.build(next);
             },
         },
@@ -154,49 +133,582 @@ const claude = {
     },
     functions: [
         {
-            name: "makePrismaSchemaFiles",
+            name: "makePrismaSchemaFile",
             parameters: {
-                description: " Properties containing the complete set of Prisma schema files\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFilesProps}",
+                description: " Properties containing the file\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFileProps}",
                 type: "object",
                 properties: {
-                    content: {
-                        title: "Complete Prisma schema content as a single concatenated string",
-                        description: "Complete Prisma schema content as a single concatenated string.\n\nContains all schema files organized by domain/functionality with clear file\nseparators. Each file section includes models, relationships, indexes, and\ncomprehensive documentation following enterprise patterns.\n\nContent should be organized following enterprise patterns:\n\n- Main.prisma: Configuration, datasource, and generators\n- Schema-XX-domain.prisma: Domain-specific entity definitions\n- Proper cross-file relationships and dependencies",
-                        type: "string"
-                    },
-                    description: {
-                        title: "Summary description of the application requirements and business context",
-                        description: "Summary description of the application requirements and business context.",
-                        type: "string"
+                    file: {
+                        description: "Complete definition of a single Prisma schema file.\n\nRepresents one business domain containing related models, organized for\nmodular schema management and following domain-driven design principles.\n\n------------------------------\n\nDescription 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: [
-                    "content",
-                    "description"
+                    "file"
                 ],
                 additionalProperties: false,
                 $defs: {}
             },
             description: "Generates comprehensive Prisma schema files based on detailed requirements\nanalysis.\n\nCreates multiple organized schema files following enterprise patterns\nincluding proper domain separation, relationship modeling, snapshot\npatterns, inheritance, materialized views, and comprehensive documentation.\nThe generated schemas implement best practices for scalability,\nmaintainability, and data integrity.",
-            validate: (() => { const _io0 = input => "string" === typeof input.content && "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.content || _report(_exceptionable, {
-                    path: _path + ".content",
+            validate: (() => { const _io0 = input => "object" === typeof input.file && null !== input.file && _io1(input.file); 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) => [("object" === typeof input.file && null !== input.file || _report(_exceptionable, {
+                    path: _path + ".file",
+                    expected: "AutoBePrisma.IFile",
+                    value: input.file
+                })) && _vo1(input.file, _path + ".file", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".file",
+                    expected: "AutoBePrisma.IFile",
+                    value: input.file
+                })].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, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".models[" + _index9 + "]",
+                    expected: "AutoBePrisma.IModel",
+                    value: elem
+                })) && _vo2(elem, _path + ".models[" + _index9 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".models[" + _index9 + "]",
+                    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, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".foreignFields[" + _index10 + "]",
+                    expected: "AutoBePrisma.IForeignField",
+                    value: elem
+                })) && _vo4(elem, _path + ".foreignFields[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".foreignFields[" + _index10 + "]",
+                    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, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".plainFields[" + _index11 + "]",
+                    expected: "AutoBePrisma.IPlainField",
+                    value: elem
+                })) && _vo6(elem, _path + ".plainFields[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".plainFields[" + _index11 + "]",
+                    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, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".uniqueIndexes[" + _index12 + "]",
+                    expected: "AutoBePrisma.IUniqueIndex",
+                    value: elem
+                })) && _vo7(elem, _path + ".uniqueIndexes[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".uniqueIndexes[" + _index12 + "]",
+                    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, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".plainIndexes[" + _index13 + "]",
+                    expected: "AutoBePrisma.IPlainIndex",
+                    value: elem
+                })) && _vo8(elem, _path + ".plainIndexes[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".plainIndexes[" + _index13 + "]",
+                    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, _index14) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".ginIndexes[" + _index14 + "]",
+                    expected: "AutoBePrisma.IGinIndex",
+                    value: elem
+                })) && _vo9(elem, _path + ".ginIndexes[" + _index14 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".ginIndexes[" + _index14 + "]",
+                    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.content
+                    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, _index15) => "string" === typeof elem || _report(_exceptionable, {
+                    path: _path + ".fieldNames[" + _index15 + "]",
+                    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, _index16) => "string" === typeof elem || _report(_exceptionable, {
+                    path: _path + ".fieldNames[" + _index16 + "]",
+                    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: "IMakePrismaSchemaFilesProps",
+                        expected: "IMakePrismaSchemaFileProps",
                         value: input
                     })) && _vo0(input, _path + "", true) || _report(true, {
                         path: _path + "",
-                        expected: "IMakePrismaSchemaFilesProps",
+                        expected: "IMakePrismaSchemaFileProps",
                         value: input
                     }))(input, "$input", true);
                     const success = 0 === errors.length;
@@ -227,49 +739,568 @@ const collection = {
         },
         functions: [
             {
-                name: "makePrismaSchemaFiles",
+                name: "makePrismaSchemaFile",
                 parameters: {
-                    description: " Properties containing the complete set of Prisma schema files\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFilesProps}",
+                    description: " Properties containing the file\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFileProps}",
                     type: "object",
                     properties: {
-                        content: {
-                            title: "Complete Prisma schema content as a single concatenated string",
-                            description: "Complete Prisma schema content as a single concatenated string.\n\nContains all schema files organized by domain/functionality with clear file\nseparators. Each file section includes models, relationships, indexes, and\ncomprehensive documentation following enterprise patterns.\n\nContent should be organized following enterprise patterns:\n\n- Main.prisma: Configuration, datasource, and generators\n- Schema-XX-domain.prisma: Domain-specific entity definitions\n- Proper cross-file relationships and dependencies",
-                            type: "string"
-                        },
-                        description: {
-                            title: "Summary description of the application requirements and business context",
-                            description: "Summary description of the application requirements and business context.",
-                            type: "string"
+                        file: {
+                            description: "Complete definition of a single Prisma schema file.\n\nRepresents one business domain containing related models, organized for\nmodular schema management and following domain-driven design principles.\n\n------------------------------\n\nDescription 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: [
-                        "content",
-                        "description"
+                        "file"
                     ],
                     additionalProperties: false,
                     $defs: {}
                 },
                 description: "Generates comprehensive Prisma schema files based on detailed requirements\nanalysis.\n\nCreates multiple organized schema files following enterprise patterns\nincluding proper domain separation, relationship modeling, snapshot\npatterns, inheritance, materialized views, and comprehensive documentation.\nThe generated schemas implement best practices for scalability,\nmaintainability, and data integrity.",
-                validate: (() => { const _io0 = input => "string" === typeof input.content && "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.content || _report(_exceptionable, {
-                        path: _path + ".content",
+                validate: (() => { const _io0 = input => "object" === typeof input.file && null !== input.file && _io1(input.file); 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) => [("object" === typeof input.file && null !== input.file || _report(_exceptionable, {
+                        path: _path + ".file",
+                        expected: "AutoBePrisma.IFile",
+                        value: input.file
+                    })) && _vo1(input.file, _path + ".file", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".file",
+                        expected: "AutoBePrisma.IFile",
+                        value: input.file
+                    })].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.content
+                        value: input.namespace
+                    }), (Array.isArray(input.models) || _report(_exceptionable, {
+                        path: _path + ".models",
+                        expected: "Array<AutoBePrisma.IModel>",
+                        value: input.models
+                    })) && input.models.map((elem, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".models[" + _index9 + "]",
+                        expected: "AutoBePrisma.IModel",
+                        value: elem
+                    })) && _vo2(elem, _path + ".models[" + _index9 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".models[" + _index9 + "]",
+                        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, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index10 + "]",
+                        expected: "AutoBePrisma.IForeignField",
+                        value: elem
+                    })) && _vo4(elem, _path + ".foreignFields[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index10 + "]",
+                        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, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index11 + "]",
+                        expected: "AutoBePrisma.IPlainField",
+                        value: elem
+                    })) && _vo6(elem, _path + ".plainFields[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index11 + "]",
+                        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, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index12 + "]",
+                        expected: "AutoBePrisma.IUniqueIndex",
+                        value: elem
+                    })) && _vo7(elem, _path + ".uniqueIndexes[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index12 + "]",
+                        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, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index13 + "]",
+                        expected: "AutoBePrisma.IPlainIndex",
+                        value: elem
+                    })) && _vo8(elem, _path + ".plainIndexes[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index13 + "]",
+                        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, _index14) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index14 + "]",
+                        expected: "AutoBePrisma.IGinIndex",
+                        value: elem
+                    })) && _vo9(elem, _path + ".ginIndexes[" + _index14 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index14 + "]",
+                        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, _index15) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index15 + "]",
+                        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, _index16) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index16 + "]",
+                        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: "IMakePrismaSchemaFilesProps",
+                            expected: "IMakePrismaSchemaFileProps",
                             value: input
                         })) && _vo0(input, _path + "", true) || _report(true, {
                             path: _path + "",
-                            expected: "IMakePrismaSchemaFilesProps",
+                            expected: "IMakePrismaSchemaFileProps",
                             value: input
                         }))(input, "$input", true);
                         const success = 0 === errors.length;
@@ -303,48 +1334,586 @@ const collection = {
         },
         functions: [
             {
-                name: "makePrismaSchemaFiles",
+                name: "makePrismaSchemaFile",
                 parameters: {
                     type: "object",
                     properties: {
-                        content: {
-                            type: "string",
-                            title: "Complete Prisma schema content as a single concatenated string",
-                            description: "Complete Prisma schema content as a single concatenated string.\n\nContains all schema files organized by domain/functionality with clear file\nseparators. Each file section includes models, relationships, indexes, and\ncomprehensive documentation following enterprise patterns.\n\nContent should be organized following enterprise patterns:\n\n- Main.prisma: Configuration, datasource, and generators\n- Schema-XX-domain.prisma: Domain-specific entity definitions\n- Proper cross-file relationships and dependencies"
-                        },
-                        description: {
-                            type: "string",
-                            title: "Summary description of the application requirements and business context",
-                            description: "Summary description of the application requirements and business context."
+                        file: {
+                            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: "Complete definition of a single Prisma schema file.\n\nRepresents one business domain containing related models, organized for\nmodular schema management and following domain-driven design principles.\n\n------------------------------\n\nDescription 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
                         }
                     },
                     required: [
-                        "content",
-                        "description"
+                        "file"
                     ],
-                    description: " Properties containing the complete set of Prisma schema files\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFilesProps}",
+                    description: " Properties containing the file\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFileProps}",
                     additionalProperties: false
                 },
                 description: "Generates comprehensive Prisma schema files based on detailed requirements\nanalysis.\n\nCreates multiple organized schema files following enterprise patterns\nincluding proper domain separation, relationship modeling, snapshot\npatterns, inheritance, materialized views, and comprehensive documentation.\nThe generated schemas implement best practices for scalability,\nmaintainability, and data integrity.",
-                validate: (() => { const _io0 = input => "string" === typeof input.content && "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.content || _report(_exceptionable, {
-                        path: _path + ".content",
+                validate: (() => { const _io0 = input => "object" === typeof input.file && null !== input.file && _io1(input.file); 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) => [("object" === typeof input.file && null !== input.file || _report(_exceptionable, {
+                        path: _path + ".file",
+                        expected: "AutoBePrisma.IFile",
+                        value: input.file
+                    })) && _vo1(input.file, _path + ".file", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".file",
+                        expected: "AutoBePrisma.IFile",
+                        value: input.file
+                    })].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, _index9) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".models[" + _index9 + "]",
+                        expected: "AutoBePrisma.IModel",
+                        value: elem
+                    })) && _vo2(elem, _path + ".models[" + _index9 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".models[" + _index9 + "]",
+                        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.content
+                        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, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index10 + "]",
+                        expected: "AutoBePrisma.IForeignField",
+                        value: elem
+                    })) && _vo4(elem, _path + ".foreignFields[" + _index10 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".foreignFields[" + _index10 + "]",
+                        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, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index11 + "]",
+                        expected: "AutoBePrisma.IPlainField",
+                        value: elem
+                    })) && _vo6(elem, _path + ".plainFields[" + _index11 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainFields[" + _index11 + "]",
+                        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, _index12) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index12 + "]",
+                        expected: "AutoBePrisma.IUniqueIndex",
+                        value: elem
+                    })) && _vo7(elem, _path + ".uniqueIndexes[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".uniqueIndexes[" + _index12 + "]",
+                        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, _index13) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index13 + "]",
+                        expected: "AutoBePrisma.IPlainIndex",
+                        value: elem
+                    })) && _vo8(elem, _path + ".plainIndexes[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".plainIndexes[" + _index13 + "]",
+                        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, _index14) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index14 + "]",
+                        expected: "AutoBePrisma.IGinIndex",
+                        value: elem
+                    })) && _vo9(elem, _path + ".ginIndexes[" + _index14 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".ginIndexes[" + _index14 + "]",
+                        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, _index15) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index15 + "]",
+                        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, _index16) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".fieldNames[" + _index16 + "]",
+                        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: "IMakePrismaSchemaFilesProps",
+                            expected: "IMakePrismaSchemaFileProps",
                             value: input
                         })) && _vo0(input, _path + "", true) || _report(true, {
                             path: _path + "",
-                            expected: "IMakePrismaSchemaFilesProps",
+                            expected: "IMakePrismaSchemaFileProps",
                             value: input
                         }))(input, "$input", true);
                         const success = 0 === errors.length;