@famgia/omnify-typescript 0.0.66 → 0.0.68

package/dist/plugin.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/plugin.ts
@@ -108,6 +118,10 @@ function getPropertyType(property, _allSchemas) {
         return "unknown";
     }
   }
+  if (property.type === "EnumRef") {
+    const enumRefProp = property;
+    return enumRefProp.enum;
+  }
   if (property.type === "Enum") {
     const enumProp = property;
     if (typeof enumProp.enum === "string") {
@@ -136,7 +150,7 @@ function propertyToTSProperties(propertyName, property, allSchemas, options = {}
       for (const field of customType.expand) {
         const fieldName = `${propertyName}_${toSnakeCase(field.suffix)}`;
         const fieldOverride = baseProp.fields?.[field.suffix];
-        const isNullable = fieldOverride?.nullable ?? baseProp.nullable ?? false;
+        const isNullable = fieldOverride?.nullable ?? field.sql?.nullable ?? baseProp.nullable ?? false;
         const tsType = field.typescript?.type ?? "string";
         expandedProps.push({
           name: fieldName,
@@ -278,12 +292,24 @@ function schemaToInterface(schema, allSchemas, options = {}) {
       }
     }
   }
+  const enumDependencySet = /* @__PURE__ */ new Set();
+  if (schema.properties) {
+    for (const property of Object.values(schema.properties)) {
+      if (property.type === "EnumRef") {
+        const enumRefProp = property;
+        if (enumRefProp.enum) {
+          enumDependencySet.add(enumRefProp.enum);
+        }
+      }
+    }
+  }
   const schemaDisplayName = resolveDisplayName(schema.displayName, options);
   return {
     name: toInterfaceName(schema.name),
     properties,
     comment: schemaDisplayName ?? schema.name,
-    dependencies: dependencySet.size > 0 ? Array.from(dependencySet).sort() : void 0
+    dependencies: dependencySet.size > 0 ? Array.from(dependencySet).sort() : void 0,
+    enumDependencies: enumDependencySet.size > 0 ? Array.from(enumDependencySet).sort() : void 0
   };
 }
 function formatProperty(property) {
@@ -330,7 +356,11 @@ function resolveDisplayName2(value, options = {}) {
   });
 }
 function toEnumMemberName(value) {
-  return value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
+  let result = value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
+  if (/^\d/.test(result)) {
+    result = "_" + result;
+  }
+  return result;
 }
 function toEnumName(schemaName) {
   return schemaName;
@@ -384,6 +414,46 @@ function generateEnums(schemas, options = {}) {
   }
   return enums;
 }
+function pluginEnumToTSEnum(enumDef, options = {}) {
+  const values = enumDef.values.map((v) => {
+    let label;
+    if (v.label !== void 0) {
+      if (typeof v.label === "string") {
+        label = v.label;
+      } else if (options.multiLocale) {
+        label = v.label;
+      } else {
+        label = resolveDisplayName2(v.label, options);
+      }
+    }
+    return {
+      name: toEnumMemberName(v.value),
+      value: v.value,
+      label,
+      extra: v.extra
+    };
+  });
+  let comment;
+  if (enumDef.displayName !== void 0) {
+    if (typeof enumDef.displayName === "string") {
+      comment = enumDef.displayName;
+    } else {
+      comment = resolveDisplayName2(enumDef.displayName, options);
+    }
+  }
+  return {
+    name: enumDef.name,
+    values,
+    comment: comment ?? enumDef.name
+  };
+}
+function generatePluginEnums(pluginEnums, options = {}) {
+  const enums = [];
+  for (const enumDef of pluginEnums.values()) {
+    enums.push(pluginEnumToTSEnum(enumDef, options));
+  }
+  return enums;
+}
 function isMultiLocaleLabel(label) {
   return label !== void 0 && typeof label === "object";
 }
@@ -404,7 +474,7 @@ ${enumValues}
 `);
   parts.push(`/** All ${name} values */
 `);
-  parts.push(`export const ${name}Values = Object.values(${name});
+  parts.push(`export const ${name}Values = Object.values(${name}) as ${name}[];
 
 `);
   parts.push(`/** Type guard for ${name} */
@@ -422,10 +492,10 @@ ${enumValues}
     if (hasMultiLocale) {
       const labelEntries = values.filter((v) => v.label !== void 0).map((v) => {
         if (isMultiLocaleLabel(v.label)) {
-          const locales = Object.entries(v.label).map(([locale, text]) => `${locale}: '${text}'`).join(", ");
+          const locales = Object.entries(v.label).map(([locale, text]) => `'${locale}': '${escapeString(text)}'`).join(", ");
           return `  [${name}.${v.name}]: { ${locales} },`;
         }
-        return `  [${name}.${v.name}]: { default: '${v.label}' },`;
+        return `  [${name}.${v.name}]: { default: '${escapeString(String(v.label))}' },`;
       }).join("\n");
       parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, Record<string, string>>> = {
 ${labelEntries}
@@ -442,13 +512,15 @@ ${labelEntries}
 `);
       parts.push(`  if (locale && labels[locale]) return labels[locale];
 `);
-      parts.push(`  return Object.values(labels)[0] ?? value;
+      parts.push(`  // Fallback: ja \u2192 en \u2192 first available
+`);
+      parts.push(`  return labels['ja'] ?? labels['en'] ?? Object.values(labels)[0] ?? value;
 `);
       parts.push(`}
 
 `);
     } else {
-      const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${v.label}',`).join("\n");
+      const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${escapeString(String(v.label))}',`).join("\n");
       parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, string>> = {
 ${labelEntries}
 };
@@ -504,6 +576,9 @@ ${extraEntries}
 function lowerFirst(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
 }
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
 function formatTypeAlias(alias) {
   const { name, type, comment } = alias;
   const parts = [];
@@ -1017,6 +1092,13 @@ function getZodSchemaForType(propDef, fieldName, customTypes) {
     case "Json":
       schema = "z.unknown()";
       break;
+    case "EnumRef":
+      if (typeof def.enum === "string") {
+        schema = `z.nativeEnum(${def.enum})`;
+      } else {
+        schema = "z.string()";
+      }
+      break;
     case "Enum":
       if (typeof def.enum === "string") {
         schema = `${def.enum}Schema`;
@@ -1062,15 +1144,35 @@ function generateCompoundTypeSchemas(propName, propDef, customType, options) {
   for (const field of customType.expand) {
     const fieldName = `${toSnakeCase(propName)}_${toSnakeCase(field.suffix)}`;
     const fieldOverride = propFields?.[field.suffix];
-    const isNullable = fieldOverride?.nullable ?? propDef.nullable ?? false;
-    const length = fieldOverride?.length ?? field.sql?.length;
+    const isNullable = fieldOverride?.nullable ?? field.sql?.nullable ?? propDef.nullable ?? false;
+    const pluginRules = field.rules;
+    const overrideRules = fieldOverride?.rules;
+    const length = fieldOverride?.length ?? overrideRules?.maxLength ?? pluginRules?.maxLength ?? field.sql?.length;
+    const minLength = overrideRules?.minLength ?? pluginRules?.minLength;
+    const pattern = overrideRules?.pattern ?? pluginRules?.pattern;
+    const format = overrideRules?.format ?? pluginRules?.format;
     let schema = "z.string()";
+    if (format === "email") {
+      schema = "z.string().email()";
+    } else if (format === "url") {
+      schema = "z.string().url()";
+    } else if (format === "phone") {
+      schema = "z.string()";
+    } else if (format === "postal_code") {
+      schema = `z.string().regex(/^\\d{3}-?\\d{4}$/)`;
+    }
     if (!isNullable) {
-      schema += ".min(1)";
+      const min = minLength ?? 1;
+      schema += `.min(${min})`;
+    } else if (minLength) {
+      schema += `.min(${minLength})`;
     }
     if (length) {
       schema += `.max(${length})`;
     }
+    if (pattern && !format) {
+      schema += `.regex(/${pattern}/)`;
+    }
     if (isNullable) {
       schema += ".optional().nullable()";
     }
@@ -1126,6 +1228,7 @@ function generateDisplayNames(schema, options) {
     schema.name
   );
   const propertyDisplayNames = {};
+  const propertyPlaceholders = {};
   if (schema.properties) {
     for (const [propName, propDef] of Object.entries(schema.properties)) {
       const prop = propDef;
@@ -1133,19 +1236,47 @@ function generateDisplayNames(schema, options) {
       if (customTypes) {
         const customType = customTypes.get(propDef.type);
         if (customType?.compound && customType.expand) {
-          for (const field of customType.expand) {
-            const expandedFieldName = `${fieldName}_${toSnakeCase(field.suffix)}`;
-            propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+          if (prop.displayName) {
+            propertyDisplayNames[fieldName] = getMultiLocaleDisplayName2(
               prop.displayName,
               locales,
               fallbackLocale,
               propName
             );
-            for (const locale of locales) {
-              propertyDisplayNames[expandedFieldName] = {
-                ...propertyDisplayNames[expandedFieldName],
-                [locale]: `${propertyDisplayNames[expandedFieldName][locale]} (${field.suffix})`
-              };
+          }
+          for (const field of customType.expand) {
+            const expandedFieldName = `${fieldName}_${toSnakeCase(field.suffix)}`;
+            const fieldOverride = prop.fields?.[field.suffix];
+            const labelSource = fieldOverride?.displayName ?? field.label;
+            if (labelSource) {
+              propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+                labelSource,
+                locales,
+                fallbackLocale,
+                field.suffix
+              );
+            } else {
+              propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+                prop.displayName,
+                locales,
+                fallbackLocale,
+                propName
+              );
+              for (const locale of locales) {
+                propertyDisplayNames[expandedFieldName] = {
+                  ...propertyDisplayNames[expandedFieldName],
+                  [locale]: `${propertyDisplayNames[expandedFieldName][locale]} (${field.suffix})`
+                };
+              }
+            }
+            const placeholderSource = fieldOverride?.placeholder ?? field.placeholder;
+            if (placeholderSource) {
+              propertyPlaceholders[expandedFieldName] = getMultiLocaleDisplayName2(
+                placeholderSource,
+                locales,
+                fallbackLocale,
+                ""
+              );
             }
           }
           continue;
@@ -1157,9 +1288,17 @@ function generateDisplayNames(schema, options) {
         fallbackLocale,
         propName
       );
+      if (prop.placeholder) {
+        propertyPlaceholders[fieldName] = getMultiLocaleDisplayName2(
+          prop.placeholder,
+          locales,
+          fallbackLocale,
+          ""
+        );
+      }
     }
   }
-  return { displayName, propertyDisplayNames };
+  return { displayName, propertyDisplayNames, propertyPlaceholders };
 }
 function getExcludedFields(schema, customTypes) {
   const createExclude = /* @__PURE__ */ new Set();
@@ -1203,24 +1342,44 @@ function formatZodSchemasSection(schemaName, zodSchemas, displayNames, excludedF
   const lowerName = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
   parts.push(`// ============================================================================
 `);
-  parts.push(`// Display Names
+  parts.push(`// I18n (Internationalization)
 `);
   parts.push(`// ============================================================================
 
 `);
-  parts.push(`/** Display name for ${schemaName} */
+  parts.push(`/**
 `);
-  parts.push(`export const ${schemaName}DisplayName = ${JSON.stringify(displayNames.displayName, null, 2)} as const;
-
+  parts.push(` * Unified i18n object for ${schemaName}
 `);
-  parts.push(`/** Property display names for ${schemaName} */
+  parts.push(` * Contains model label and all field labels/placeholders
+`);
+  parts.push(` */
+`);
+  parts.push(`export const ${lowerName}I18n = {
+`);
+  parts.push(`  /** Model display name */
+`);
+  parts.push(`  label: ${JSON.stringify(displayNames.displayName)},
+`);
+  parts.push(`  /** Field labels and placeholders */
+`);
+  parts.push(`  fields: {
+`);
+  for (const [propName, labelMap] of Object.entries(displayNames.propertyDisplayNames)) {
+    const placeholderMap = displayNames.propertyPlaceholders[propName];
+    parts.push(`    ${propName}: {
+`);
+    parts.push(`      label: ${JSON.stringify(labelMap)},
 `);
-  parts.push(`export const ${schemaName}PropertyDisplayNames = {
+    if (placeholderMap) {
+      parts.push(`      placeholder: ${JSON.stringify(placeholderMap)},
 `);
-  for (const [propName, localeMap] of Object.entries(displayNames.propertyDisplayNames)) {
-    parts.push(`  ${propName}: ${JSON.stringify(localeMap)},
+    }
+    parts.push(`    },
 `);
   }
+  parts.push(`  },
+`);
   parts.push(`} as const;
 
 `);
@@ -1277,35 +1436,50 @@ function formatZodSchemasSection(schemaName, zodSchemas, displayNames, excludedF
 `);
   parts.push(`// ============================================================================
 `);
-  parts.push(`// Helper Functions
+  parts.push(`// I18n Helper Functions
 `);
   parts.push(`// ============================================================================
 
 `);
-  parts.push(`/** Get display name for a specific locale */
+  parts.push(`/** Get model label for a specific locale */
 `);
-  parts.push(`export function get${schemaName}DisplayName(locale: string): string {
+  parts.push(`export function get${schemaName}Label(locale: string): string {
 `);
-  parts.push(`  return ${schemaName}DisplayName[locale as keyof typeof ${schemaName}DisplayName] ?? ${schemaName}DisplayName['en'] ?? '${schemaName}';
+  parts.push(`  return ${lowerName}I18n.label[locale as keyof typeof ${lowerName}I18n.label] ?? ${lowerName}I18n.label['en'] ?? '${schemaName}';
 `);
   parts.push(`}
 
 `);
-  parts.push(`/** Get property display name for a specific locale */
+  parts.push(`/** Get field label for a specific locale */
 `);
-  parts.push(`export function get${schemaName}PropertyDisplayName(property: string, locale: string): string {
+  parts.push(`export function get${schemaName}FieldLabel(field: string, locale: string): string {
+`);
+  parts.push(`  const fieldI18n = ${lowerName}I18n.fields[field as keyof typeof ${lowerName}I18n.fields];
+`);
+  parts.push(`  if (!fieldI18n) return field;
+`);
+  parts.push(`  return fieldI18n.label[locale as keyof typeof fieldI18n.label] ?? fieldI18n.label['en'] ?? field;
+`);
+  parts.push(`}
+
+`);
+  parts.push(`/** Get field placeholder for a specific locale */
+`);
+  parts.push(`export function get${schemaName}FieldPlaceholder(field: string, locale: string): string {
 `);
-  parts.push(`  const names = ${schemaName}PropertyDisplayNames[property as keyof typeof ${schemaName}PropertyDisplayNames];
+  parts.push(`  const fieldI18n = ${lowerName}I18n.fields[field as keyof typeof ${lowerName}I18n.fields];
 `);
-  parts.push(`  if (!names) return property;
+  parts.push(`  if (!fieldI18n || !('placeholder' in fieldI18n)) return '';
 `);
-  parts.push(`  return names[locale as keyof typeof names] ?? names['en'] ?? property;
+  parts.push(`  const placeholder = fieldI18n.placeholder as Record<string, string>;
+`);
+  parts.push(`  return placeholder[locale] ?? placeholder['en'] ?? '';
 `);
   parts.push(`}
 `);
   return parts.join("");
 }
-function formatZodModelFile(schemaName) {
+function formatZodModelFile(schemaName, _hasPlaceholders = false) {
   const lowerName = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
   return `/**
  * ${schemaName} Model
@@ -1321,10 +1495,10 @@ import {
   base${schemaName}Schemas,
   base${schemaName}CreateSchema,
   base${schemaName}UpdateSchema,
-  ${schemaName}DisplayName,
-  ${schemaName}PropertyDisplayNames,
-  get${schemaName}DisplayName,
-  get${schemaName}PropertyDisplayName,
+  ${lowerName}I18n,
+  get${schemaName}Label,
+  get${schemaName}FieldLabel,
+  get${schemaName}FieldPlaceholder,
 } from './base/${schemaName}.js';
 
 // ============================================================================
@@ -1350,12 +1524,12 @@ export const ${lowerName}UpdateSchema = base${schemaName}UpdateSchema;
 export type ${schemaName}Create = z.infer<typeof ${lowerName}CreateSchema>;
 export type ${schemaName}Update = z.infer<typeof ${lowerName}UpdateSchema>;
 
-// Re-export display names and helpers
+// Re-export i18n and helpers
 export {
-  ${schemaName}DisplayName,
-  ${schemaName}PropertyDisplayNames,
-  get${schemaName}DisplayName,
-  get${schemaName}PropertyDisplayName,
+  ${lowerName}I18n,
+  get${schemaName}Label,
+  get${schemaName}FieldLabel,
+  get${schemaName}FieldPlaceholder,
 };
 
 // Re-export base type for internal use
@@ -1471,13 +1645,24 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     parts.push(`import type { ${commonImports.join(", ")} } from '../common.js';
 `);
   }
+  if (iface.enumDependencies && iface.enumDependencies.length > 0) {
+    const enumPrefix = options.enumImportPrefix ? `../${options.enumImportPrefix}` : "../enum";
+    const pluginEnumNames = new Set(
+      options.pluginEnums ? Array.from(options.pluginEnums.keys()) : []
+    );
+    for (const enumName of iface.enumDependencies) {
+      const enumPath = pluginEnumNames.has(enumName) ? `${enumPrefix}/plugin/${enumName}.js` : `${enumPrefix}/${enumName}.js`;
+      parts.push(`import { ${enumName} } from '${enumPath}';
+`);
+    }
+  }
   if (iface.dependencies && iface.dependencies.length > 0) {
     for (const dep of iface.dependencies) {
       parts.push(`import type { ${dep} } from './${dep}.js';
 `);
     }
     parts.push("\n");
-  } else if (commonImports.length > 0 || options.generateZodSchemas) {
+  } else if (commonImports.length > 0 || options.generateZodSchemas || iface.enumDependencies && iface.enumDependencies.length > 0) {
     parts.push("\n");
   }
   parts.push(formatInterface(iface));
@@ -1498,15 +1683,17 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     overwrite: true
   };
 }
-function generateEnumFile(enumDef) {
+function generateEnumFile(enumDef, isPluginEnum = false) {
   const parts = [generateBaseHeader()];
   parts.push(formatEnum(enumDef));
   parts.push("\n");
+  const filePath = isPluginEnum ? `plugin/${enumDef.name}.ts` : `${enumDef.name}.ts`;
   return {
-    filePath: `enum/${enumDef.name}.ts`,
+    filePath,
     content: parts.join(""),
     types: [enumDef.name],
-    overwrite: true
+    overwrite: true,
+    category: "enum"
   };
 }
 function generateTypeAliasFile(alias) {
@@ -1514,10 +1701,11 @@ function generateTypeAliasFile(alias) {
   parts.push(formatTypeAlias(alias));
   parts.push("\n");
   return {
-    filePath: `enum/${alias.name}.ts`,
+    filePath: `${alias.name}.ts`,
     content: parts.join(""),
     types: [alias.name],
-    overwrite: true
+    overwrite: true,
+    category: "enum"
   };
 }
 function generateModelFile(schemaName, options) {
@@ -1558,6 +1746,88 @@ function generateModelFile(schemaName, options) {
     // Never overwrite user models
   };
 }
+var DEFAULT_VALIDATION_MESSAGES = {
+  required: {
+    en: "${displayName} is required",
+    ja: "${displayName}\u306F\u5FC5\u9808\u3067\u3059",
+    vi: "${displayName} l\xE0 b\u1EAFt bu\u1ED9c",
+    ko: "${displayName}\uC740(\uB294) \uD544\uC218\uC785\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u662F\u5FC5\u586B\u9879",
+    "zh-TW": "${displayName}\u70BA\u5FC5\u586B\u6B04\u4F4D",
+    th: "${displayName} \u0E08\u0E33\u0E40\u0E1B\u0E47\u0E19\u0E15\u0E49\u0E2D\u0E07\u0E01\u0E23\u0E2D\u0E01",
+    es: "${displayName} es obligatorio"
+  },
+  minLength: {
+    en: "${displayName} must be at least ${min} characters",
+    ja: "${displayName}\u306F${min}\u6587\u5B57\u4EE5\u4E0A\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} ph\u1EA3i c\xF3 \xEDt nh\u1EA5t ${min} k\xFD t\u1EF1",
+    ko: "${displayName}\uC740(\uB294) ${min}\uC790 \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u81F3\u5C11\u9700\u8981${min}\u4E2A\u5B57\u7B26",
+    "zh-TW": "${displayName}\u81F3\u5C11\u9700\u8981${min}\u500B\u5B57\u5143",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22 ${min} \u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23",
+    es: "${displayName} debe tener al menos ${min} caracteres"
+  },
+  maxLength: {
+    en: "${displayName} must be at most ${max} characters",
+    ja: "${displayName}\u306F${max}\u6587\u5B57\u4EE5\u5185\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} kh\xF4ng \u0111\u01B0\u1EE3c qu\xE1 ${max} k\xFD t\u1EF1",
+    ko: "${displayName}\uC740(\uB294) ${max}\uC790 \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u6700\u591A${max}\u4E2A\u5B57\u7B26",
+    "zh-TW": "${displayName}\u6700\u591A${max}\u500B\u5B57\u5143",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19 ${max} \u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23",
+    es: "${displayName} debe tener como m\xE1ximo ${max} caracteres"
+  },
+  min: {
+    en: "${displayName} must be at least ${min}",
+    ja: "${displayName}\u306F${min}\u4EE5\u4E0A\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} ph\u1EA3i l\u1EDBn h\u01A1n ho\u1EB7c b\u1EB1ng ${min}",
+    ko: "${displayName}\uC740(\uB294) ${min} \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u5FC5\u987B\u5927\u4E8E\u7B49\u4E8E${min}",
+    "zh-TW": "${displayName}\u5FC5\u9808\u5927\u65BC\u7B49\u65BC${min}",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32\u0E2B\u0E23\u0E37\u0E2D\u0E40\u0E17\u0E48\u0E32\u0E01\u0E31\u0E1A ${min}",
+    es: "${displayName} debe ser al menos ${min}"
+  },
+  max: {
+    en: "${displayName} must be at most ${max}",
+    ja: "${displayName}\u306F${max}\u4EE5\u4E0B\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} ph\u1EA3i nh\u1ECF h\u01A1n ho\u1EB7c b\u1EB1ng ${max}",
+    ko: "${displayName}\uC740(\uB294) ${max} \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u5FC5\u987B\u5C0F\u4E8E\u7B49\u4E8E${max}",
+    "zh-TW": "${displayName}\u5FC5\u9808\u5C0F\u65BC\u7B49\u65BC${max}",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E2B\u0E23\u0E37\u0E2D\u0E40\u0E17\u0E48\u0E32\u0E01\u0E31\u0E1A ${max}",
+    es: "${displayName} debe ser como m\xE1ximo ${max}"
+  },
+  email: {
+    en: "Please enter a valid email address",
+    ja: "\u6709\u52B9\u306A\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "Vui l\xF2ng nh\u1EADp \u0111\u1ECBa ch\u1EC9 email h\u1EE3p l\u1EC7",
+    ko: "\uC720\uD6A8\uD55C \uC774\uBA54\uC77C \uC8FC\uC18C\uB97C \uC785\uB825\uD558\uC138\uC694",
+    "zh-CN": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u7535\u5B50\u90AE\u4EF6\u5730\u5740",
+    "zh-TW": "\u8ACB\u8F38\u5165\u6709\u6548\u7684\u96FB\u5B50\u90F5\u4EF6\u5730\u5740",
+    th: "\u0E01\u0E23\u0E38\u0E13\u0E32\u0E01\u0E23\u0E2D\u0E01\u0E2D\u0E35\u0E40\u0E21\u0E25\u0E17\u0E35\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+    es: "Por favor, introduce una direcci\xF3n de correo electr\xF3nico v\xE1lida"
+  },
+  url: {
+    en: "Please enter a valid URL",
+    ja: "\u6709\u52B9\u306AURL\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "Vui l\xF2ng nh\u1EADp URL h\u1EE3p l\u1EC7",
+    ko: "\uC720\uD6A8\uD55C URL\uC744 \uC785\uB825\uD558\uC138\uC694",
+    "zh-CN": "\u8BF7\u8F93\u5165\u6709\u6548\u7684URL",
+    "zh-TW": "\u8ACB\u8F38\u5165\u6709\u6548\u7684\u7DB2\u5740",
+    th: "\u0E01\u0E23\u0E38\u0E13\u0E32\u0E01\u0E23\u0E2D\u0E01 URL \u0E17\u0E35\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+    es: "Por favor, introduce una URL v\xE1lida"
+  },
+  pattern: {
+    en: "${displayName} format is invalid",
+    ja: "${displayName}\u306E\u5F62\u5F0F\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093",
+    vi: "${displayName} kh\xF4ng \u0111\xFAng \u0111\u1ECBnh d\u1EA1ng",
+    ko: "${displayName} \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u683C\u5F0F\u4E0D\u6B63\u786E",
+    "zh-TW": "${displayName}\u683C\u5F0F\u4E0D\u6B63\u78BA",
+    th: "\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A${displayName}\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+    es: "El formato de ${displayName} no es v\xE1lido"
+  }
+};
 function generateCommonFile(options) {
   const locales = options.localeConfig?.locales ?? ["ja", "en"];
   const localeUnion = locales.map((l) => `'${l}'`).join(" | ");
@@ -1605,15 +1875,142 @@ export type DateString = string;
     overwrite: true
   };
 }
-function generateIndexFile(schemas, enums, typeAliases, options) {
+function generateI18nFile(options) {
+  const locales = options.localeConfig?.locales ?? ["ja", "en"];
+  const defaultLocale = options.localeConfig?.defaultLocale ?? "ja";
+  const fallbackLocale = options.localeConfig?.fallbackLocale ?? "en";
+  const userMessages = options.localeConfig?.messages ?? {};
+  const mergedMessages = {};
+  for (const [key, defaultMsgs] of Object.entries(DEFAULT_VALIDATION_MESSAGES)) {
+    mergedMessages[key] = {};
+    for (const locale of locales) {
+      if (defaultMsgs[locale]) {
+        mergedMessages[key][locale] = defaultMsgs[locale];
+      }
+    }
+  }
+  for (const [key, userMsgs] of Object.entries(userMessages)) {
+    if (userMsgs) {
+      if (!mergedMessages[key]) {
+        mergedMessages[key] = {};
+      }
+      for (const [locale, msg] of Object.entries(userMsgs)) {
+        mergedMessages[key][locale] = msg;
+      }
+    }
+  }
+  const messagesJson = JSON.stringify(mergedMessages, null, 2);
+  const content = `${generateBaseHeader()}
+import type { LocaleMap } from './common.js';
+
+/**
+ * Default locale for this project.
+ */
+export const defaultLocale = '${defaultLocale}' as const;
+
+/**
+ * Fallback locale when requested locale is not found.
+ */
+export const fallbackLocale = '${fallbackLocale}' as const;
+
+/**
+ * Supported locales in this project.
+ */
+export const supportedLocales = ${JSON.stringify(locales)} as const;
+
+/**
+ * Validation messages for all supported locales.
+ * Use getMessage(key, locale, params) to get formatted message.
+ */
+export const validationMessages = ${messagesJson} as const;
+
+/**
+ * Get validation message for a specific key and locale.
+ * Supports template placeholders: \${displayName}, \${min}, \${max}, etc.
+ *
+ * @param key - Message key (e.g., 'required', 'minLength')
+ * @param locale - Locale code (e.g., 'ja', 'en')
+ * @param params - Template parameters to replace
+ * @returns Formatted message string
+ *
+ * @example
+ * getMessage('required', 'ja', { displayName: '\u6C0F\u540D' })
+ * // => '\u6C0F\u540D\u306F\u5FC5\u9808\u3067\u3059'
+ */
+export function getMessage(
+  key: string,
+  locale: string,
+  params: Record<string, string | number> = {}
+): string {
+  const messages = validationMessages[key as keyof typeof validationMessages];
+  if (!messages) return key;
+
+  let message = (messages as LocaleMap)[locale]
+    ?? (messages as LocaleMap)[fallbackLocale]
+    ?? (messages as LocaleMap)[defaultLocale]
+    ?? key;
+
+  // Replace template placeholders
+  for (const [param, value] of Object.entries(params)) {
+    message = message.replace(new RegExp(\`\\\\$\\{\${param}\\}\`, 'g'), String(value));
+  }
+
+  return message;
+}
+
+/**
+ * Get all validation messages for a specific locale.
+ *
+ * @param locale - Locale code
+ * @returns Object with all messages for the locale
+ */
+export function getMessages(locale: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [key, messages] of Object.entries(validationMessages)) {
+    result[key] = (messages as LocaleMap)[locale]
+      ?? (messages as LocaleMap)[fallbackLocale]
+      ?? (messages as LocaleMap)[defaultLocale]
+      ?? key;
+  }
+  return result;
+}
+`;
+  return {
+    filePath: "i18n.ts",
+    content,
+    types: ["validationMessages", "getMessage", "getMessages"],
+    overwrite: true
+  };
+}
+function generateIndexFile(schemas, enums, pluginEnums, typeAliases, options) {
   const parts = [generateBaseHeader()];
   parts.push(`// Common Types
 `);
   parts.push(`export type { LocaleMap, Locale, ValidationRule, DateTimeString, DateString } from './common.js';
 
 `);
-  if (enums.length > 0 || typeAliases.length > 0) {
-    parts.push(`// Enums
+  parts.push(`// i18n (Internationalization)
+`);
+  parts.push(`export {
+`);
+  parts.push(`  defaultLocale,
+`);
+  parts.push(`  fallbackLocale,
+`);
+  parts.push(`  supportedLocales,
+`);
+  parts.push(`  validationMessages,
+`);
+  parts.push(`  getMessage,
+`);
+  parts.push(`  getMessages,
+`);
+  parts.push(`} from './i18n.js';
+
+`);
+  const enumPrefix = options.enumImportPrefix ?? "./enum";
+  if (enums.length > 0) {
+    parts.push(`// Schema Enums
 `);
     for (const enumDef of enums) {
       parts.push(`export {
@@ -1628,9 +2025,35 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 `);
       parts.push(`  get${enumDef.name}Extra,
 `);
-      parts.push(`} from './enum/${enumDef.name}.js';
+      parts.push(`} from '${enumPrefix}/${enumDef.name}.js';
 `);
     }
+    parts.push("\n");
+  }
+  if (pluginEnums.length > 0) {
+    parts.push(`// Plugin Enums
+`);
+    for (const enumDef of pluginEnums) {
+      parts.push(`export {
+`);
+      parts.push(`  ${enumDef.name},
+`);
+      parts.push(`  ${enumDef.name}Values,
+`);
+      parts.push(`  is${enumDef.name},
+`);
+      parts.push(`  get${enumDef.name}Label,
+`);
+      parts.push(`  get${enumDef.name}Extra,
+`);
+      parts.push(`} from '${enumPrefix}/plugin/${enumDef.name}.js';
+`);
+    }
+    parts.push("\n");
+  }
+  if (typeAliases.length > 0) {
+    parts.push(`// Inline Enums (Type Aliases)
+`);
     for (const alias of typeAliases) {
       parts.push(`export {
 `);
@@ -1644,13 +2067,13 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 `);
       parts.push(`  get${alias.name}Extra,
 `);
-      parts.push(`} from './enum/${alias.name}.js';
+      parts.push(`} from '${enumPrefix}/${alias.name}.js';
 `);
     }
     parts.push("\n");
   }
   if (options.generateZodSchemas) {
-    parts.push(`// Models (with Zod schemas and Create/Update types)
+    parts.push(`// Models (with Zod schemas, i18n, and Create/Update types)
 `);
     for (const schema of Object.values(schemas)) {
       if (schema.kind === "enum") continue;
@@ -1666,13 +2089,13 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 `);
       parts.push(`  ${lowerName}UpdateSchema,
 `);
-      parts.push(`  ${schema.name}DisplayName,
+      parts.push(`  ${lowerName}I18n,
 `);
-      parts.push(`  ${schema.name}PropertyDisplayNames,
+      parts.push(`  get${schema.name}Label,
 `);
-      parts.push(`  get${schema.name}DisplayName,
+      parts.push(`  get${schema.name}FieldLabel,
 `);
-      parts.push(`  get${schema.name}PropertyDisplayName,
+      parts.push(`  get${schema.name}FieldPlaceholder,
 `);
       parts.push(`} from './${schema.name}.js';
 `);
@@ -1718,9 +2141,47 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 function generateTypeScript(schemas, options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const files = [];
+  const schemasByName = /* @__PURE__ */ new Map();
+  for (const schema of Object.values(schemas)) {
+    const paths = schemasByName.get(schema.name) ?? [];
+    paths.push(schema.relativePath ?? schema.filePath);
+    schemasByName.set(schema.name, paths);
+  }
+  const duplicateSchemas = Array.from(schemasByName.entries()).filter(([, paths]) => paths.length > 1);
+  if (duplicateSchemas.length > 0) {
+    const errors = duplicateSchemas.map(
+      ([name, paths]) => `  - "${name}" defined in: ${paths.join(", ")}`
+    ).join("\n");
+    throw new Error(
+      `Duplicate schema/enum names detected. Names must be globally unique:
+${errors}
+Hint: Rename to unique names like "Blog${duplicateSchemas[0][0]}" or "Shop${duplicateSchemas[0][0]}"`
+    );
+  }
+  if (opts.pluginEnums && opts.pluginEnums.size > 0) {
+    const conflicts = [];
+    for (const schema of Object.values(schemas)) {
+      if (schema.kind === "enum" && opts.pluginEnums.has(schema.name)) {
+        conflicts.push(`"${schema.name}" (schema: ${schema.relativePath ?? schema.filePath}, plugin enum)`);
+      }
+    }
+    if (conflicts.length > 0) {
+      throw new Error(
+        `Schema enum conflicts with plugin enum:
+  - ${conflicts.join("\n  - ")}
+Hint: Rename your schema enum to avoid conflict with plugin-provided enums`
+      );
+    }
+  }
   const enums = generateEnums(schemas, opts);
   for (const enumDef of enums) {
-    files.push(generateEnumFile(enumDef));
+    files.push(generateEnumFile(enumDef, false));
+  }
+  if (opts.pluginEnums && opts.pluginEnums.size > 0) {
+    const pluginEnums = generatePluginEnums(opts.pluginEnums, opts);
+    for (const enumDef of pluginEnums) {
+      files.push(generateEnumFile(enumDef, true));
+    }
   }
   const typeAliases = extractInlineEnums(schemas, opts);
   for (const alias of typeAliases) {
@@ -1741,11 +2202,19 @@ function generateTypeScript(schemas, options = {}) {
     files.push(...rulesFiles);
   }
   files.push(generateCommonFile(opts));
-  files.push(generateIndexFile(schemas, enums, typeAliases, opts));
+  files.push(generateI18nFile(opts));
+  const pluginEnumsList = opts.pluginEnums ? generatePluginEnums(opts.pluginEnums, opts) : [];
+  files.push(generateIndexFile(schemas, enums, pluginEnumsList, typeAliases, opts));
   return files;
 }
 
 // src/plugin.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_meta = {};
+var __filename = (0, import_url.fileURLToPath)(import_meta.url);
+var __dirname = import_path.default.dirname(__filename);
 var TYPESCRIPT_CONFIG_SCHEMA = {
   fields: [
     {
@@ -1763,15 +2232,38 @@ var TYPESCRIPT_CONFIG_SCHEMA = {
       description: "Generate Zod schemas alongside TypeScript types for form validation",
       default: true,
       group: "output"
+    },
+    {
+      key: "stubsPath",
+      type: "path",
+      label: "React Stubs Path",
+      description: "Directory for React utility stubs (hooks, components). Leave empty to disable.",
+      default: "omnify",
+      group: "output"
     }
   ]
 };
 function resolveOptions(options) {
   return {
     modelsPath: options?.modelsPath ?? "types/schemas",
-    generateZodSchemas: options?.generateZodSchemas ?? true
+    generateZodSchemas: options?.generateZodSchemas ?? true,
+    stubsPath: options?.stubsPath ?? "omnify"
   };
 }
+var STUB_FILES = [
+  {
+    stub: "CompoundField.tsx.stub",
+    output: "components/CompoundField.tsx"
+  },
+  {
+    stub: "use-form-mutation.ts.stub",
+    output: "hooks/use-form-mutation.ts"
+  },
+  {
+    stub: "form-validation.ts.stub",
+    output: "lib/form-validation.ts"
+  }
+];
 function typescriptPlugin(options) {
   const resolved = resolveOptions(options);
   return {
@@ -1786,17 +2278,74 @@ function typescriptPlugin(options) {
           const files = generateTypeScript(ctx.schemas, {
             generateZodSchemas: resolved.generateZodSchemas,
             localeConfig: ctx.localeConfig,
-            customTypes: ctx.customTypes
+            customTypes: ctx.customTypes,
+            pluginEnums: ctx.pluginEnums
           });
-          return files.map((file) => ({
-            path: `${resolved.modelsPath}/${file.filePath}`,
-            content: file.content,
-            type: "type",
-            overwrite: file.overwrite,
-            metadata: {
-              types: file.types
+          return files.map((file) => {
+            let outputPath;
+            if (file.category === "enum") {
+              const enumPath = resolved.modelsPath.replace(/\/schemas\/?$/, "/enum");
+              outputPath = `${enumPath}/${file.filePath}`;
+            } else {
+              outputPath = `${resolved.modelsPath}/${file.filePath}`;
             }
-          }));
+            return {
+              path: outputPath,
+              content: file.content,
+              type: "type",
+              skipIfExists: !file.overwrite,
+              // Invert: overwrite=true means skipIfExists=false
+              metadata: {
+                types: file.types
+              }
+            };
+          });
+        }
+      },
+      {
+        name: "typescript-stubs",
+        description: "Generate React utility stubs (hooks, components)",
+        generate: async () => {
+          if (resolved.stubsPath === false) {
+            return [];
+          }
+          const outputs = [];
+          const stubsDir = import_path.default.join(__dirname, "..", "stubs");
+          for (const { stub, output } of STUB_FILES) {
+            const stubPath = import_path.default.join(stubsDir, stub);
+            if (import_fs.default.existsSync(stubPath)) {
+              const content = import_fs.default.readFileSync(stubPath, "utf-8");
+              outputs.push({
+                path: `${resolved.stubsPath}/${output}`,
+                content,
+                type: "other",
+                skipIfExists: true
+                // Never overwrite - user can customize
+              });
+            }
+          }
+          outputs.push({
+            path: `${resolved.stubsPath}/components/index.ts`,
+            content: `export { CompoundField, type FieldConfig } from './CompoundField';
+`,
+            type: "other",
+            skipIfExists: true
+          });
+          outputs.push({
+            path: `${resolved.stubsPath}/hooks/index.ts`,
+            content: `export { useFormMutation } from './use-form-mutation';
+`,
+            type: "other",
+            skipIfExists: true
+          });
+          outputs.push({
+            path: `${resolved.stubsPath}/lib/index.ts`,
+            content: `export { zodRule, requiredRule } from './form-validation';
+`,
+            type: "other",
+            skipIfExists: true
+          });
+          return outputs;
         }
       }
     ]