@famgia/omnify-typescript 0.0.68 → 0.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@famgia/omnify-typescript",
-  "version": "0.0.68",
+  "version": "0.0.70",
   "description": "TypeScript type definitions generator for Omnify schemas",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -31,7 +31,6 @@
   "files": [
     "dist",
     "scripts",
-    "ai-guides",
     "stubs"
   ],
   "keywords": [
@@ -49,7 +48,7 @@
     "directory": "packages/typescript-generator"
   },
   "dependencies": {
-    "@famgia/omnify-types": "0.0.78"
+    "@famgia/omnify-types": "0.0.80"
   },
   "peerDependencies": {
     "zod": "^3.0.0"

package/stubs/ai-guides/cursor/react.mdc.stub

@@ -71,82 +71,31 @@ export interface UserCreateInput { ... }  // WRONG
 
 ## Form Pattern (Omnify)
 
-### Imports
+> **Detailed Guide:** See `react-form.mdc` for complete form development guide.
+
+**Quick Reference:**
 
 ```typescript
-import { Form, Input, Button, Space, Card, Divider } from 'antd';
-import type { FormInstance } from 'antd';
+// 1. Imports
 import { zodRule, setZodLocale } from '@/omnify/lib';
 import { OmnifyForm } from '@/omnify/components';
-import {
-  type Customer,
-  type CustomerCreate,
-  customerSchemas,
-  customerI18n,
-  getCustomerFieldLabel,
-  getCustomerFieldPlaceholder,
-} from '@/omnify/schemas';
-```
+import { customerSchemas, customerI18n, getCustomerFieldLabel } from '@/omnify/schemas';
 
-### Helper Functions (MUST define)
-
-```typescript
+// 2. Helper functions (MUST define in every form)
 const LOCALE = 'ja';
-setZodLocale(LOCALE);
-
 const label = (key: string) => getCustomerFieldLabel(key, LOCALE);
-const placeholder = (key: string) => getCustomerFieldPlaceholder(key, LOCALE);
-const rule = (key: keyof typeof customerSchemas) =>
-  zodRule(customerSchemas[key], label(key));
-```
+const rule = (key: keyof typeof customerSchemas) => zodRule(customerSchemas[key], label(key));
 
-### Form.Item Pattern
-
-```typescript
-<Form.Item
-  name="email"
-  label={label('email')}
-  rules={[rule('email')]}
->
-  <Input type="email" placeholder={placeholder('email')} />
+// 3. Form.Item pattern
+<Form.Item name="email" label={label('email')} rules={[rule('email')]}>
+  <Input />
 </Form.Item>
-```
-
-### Compound Fields (Japan Plugin)
 
-```typescript
-// Japanese Name (4 fields)
-<OmnifyForm.JapaneseName
-  schemas={customerSchemas}
-  i18n={customerI18n}
-  prefix="name"
-  required
-/>
-
-// Japanese Address (5 fields)
-<OmnifyForm.JapaneseAddress
-  form={form}
-  schemas={customerSchemas}
-  i18n={customerI18n}
-  prefix="address"
-/>
+// 4. Japanese compound fields
+<OmnifyForm.JapaneseName schemas={customerSchemas} i18n={customerI18n} prefix="name" />
+<OmnifyForm.JapaneseAddress form={form} schemas={customerSchemas} i18n={customerI18n} prefix="address" />
 ```
 
-### Key Files
-
-| File                     | Purpose                       |
-| ------------------------ | ----------------------------- |
-| `@/omnify/schemas`       | Types, schemas, i18n (generated) |
-| `@/omnify/lib`           | `zodRule()`, `setZodLocale()` |
-| `@/omnify/components`    | `OmnifyForm.*` components     |
-
-### Rules
-
-1. **Import from `@/omnify/*`** - All Omnify utilities
-2. **Define helpers** - `label()`, `placeholder()`, `rule()`
-3. **Use `Divider`** - For form sections
-4. **Use `label()` helper** - Get from `getUserPropertyDisplayName()`
-
 ## File Location
 
 | What                    | Where                                       |

package/ai-guides/antdesign-guide.md

@@ -1,401 +0,0 @@
-# Omnify + Ant Design Integration Guide
-
-This guide shows how to use Omnify-generated validation rules with Ant Design Forms.
-
-## Generated Files
-
-Omnify generates validation rules in `rules/` directory:
-- `rules/{Model}.rules.ts` - Validation rules for each model
-
-## File Structure
-
-```typescript
-// rules/User.rules.ts
-
-// Display name for model (multi-locale)
-export const UserDisplayName: LocaleMap = {
-  ja: 'ユーザー',
-  en: 'User',
-};
-
-// Display names for properties (multi-locale)
-export const UserPropertyDisplayNames: Record<string, LocaleMap> = {
-  name: { ja: '名前', en: 'Name' },
-  email: { ja: 'メールアドレス', en: 'Email' },
-};
-
-// Validation rules with multi-locale messages
-export const UserRules: Record<string, ValidationRule[]> = {
-  name: [
-    { required: true, message: { ja: '名前は必須です', en: 'Name is required' } },
-    { max: 100, message: { ja: '名前は100文字以内で入力してください', en: 'Name must be at most 100 characters' } },
-  ],
-  email: [
-    { required: true, message: { ja: 'メールアドレスは必須です', en: 'Email is required' } },
-    { type: 'email', message: { ja: 'メールアドレスの形式が正しくありません', en: 'Email is not a valid email address' } },
-  ],
-};
-
-// Helper functions
-export function getUserRules(locale: string): Record<string, Rule[]>;
-export function getUserDisplayName(locale: string): string;
-export function getUserPropertyDisplayName(property: string, locale: string): string;
-```
-
-## Basic Usage
-
-```tsx
-import { Form, Input, Button } from 'antd';
-import {
-  getUserRules,
-  getUserDisplayName,
-  getUserPropertyDisplayName
-} from '@/types/model/rules/User.rules';
-
-interface UserFormProps {
-  locale?: string;
-  onSubmit: (values: User) => void;
-}
-
-export function UserForm({ locale = 'ja', onSubmit }: UserFormProps) {
-  const [form] = Form.useForm();
-  const rules = getUserRules(locale);
-
-  return (
-    <Form
-      form={form}
-      layout="vertical"
-      onFinish={onSubmit}
-    >
-      <Form.Item
-        name="name"
-        label={getUserPropertyDisplayName('name', locale)}
-        rules={rules.name}
-      >
-        <Input placeholder={getUserPropertyDisplayName('name', locale)} />
-      </Form.Item>
-
-      <Form.Item
-        name="email"
-        label={getUserPropertyDisplayName('email', locale)}
-        rules={rules.email}
-      >
-        <Input type="email" />
-      </Form.Item>
-
-      <Form.Item>
-        <Button type="primary" htmlType="submit">
-          {locale === 'ja' ? '送信' : 'Submit'}
-        </Button>
-      </Form.Item>
-    </Form>
-  );
-}
-```
-
-## With Edit Mode (Initial Values)
-
-```tsx
-import { Form, Input, Button, Spin } from 'antd';
-import { getUserRules, getUserPropertyDisplayName } from '@/types/model/rules/User.rules';
-import { User } from '@/types/model';
-
-interface UserEditFormProps {
-  user: User;
-  locale?: string;
-  onSubmit: (values: Partial<User>) => void;
-  loading?: boolean;
-}
-
-export function UserEditForm({ user, locale = 'ja', onSubmit, loading }: UserEditFormProps) {
-  const [form] = Form.useForm();
-  const rules = getUserRules(locale);
-
-  // Set initial values when user data changes
-  React.useEffect(() => {
-    form.setFieldsValue(user);
-  }, [user, form]);
-
-  return (
-    <Spin spinning={loading}>
-      <Form
-        form={form}
-        layout="vertical"
-        initialValues={user}
-        onFinish={onSubmit}
-      >
-        <Form.Item
-          name="name"
-          label={getUserPropertyDisplayName('name', locale)}
-          rules={rules.name}
-        >
-          <Input />
-        </Form.Item>
-
-        <Form.Item
-          name="email"
-          label={getUserPropertyDisplayName('email', locale)}
-          rules={rules.email}
-        >
-          <Input type="email" />
-        </Form.Item>
-
-        <Form.Item>
-          <Button type="primary" htmlType="submit" loading={loading}>
-            {locale === 'ja' ? '更新' : 'Update'}
-          </Button>
-        </Form.Item>
-      </Form>
-    </Spin>
-  );
-}
-```
-
-## Dynamic Locale Switching
-
-```tsx
-import { Form, Input, Select } from 'antd';
-import { useState, useMemo } from 'react';
-import { getUserRules, getUserPropertyDisplayName, getUserDisplayName } from '@/types/model/rules/User.rules';
-
-export function UserFormWithLocale() {
-  const [locale, setLocale] = useState('ja');
-  const [form] = Form.useForm();
-
-  // Memoize rules to avoid recalculation
-  const rules = useMemo(() => getUserRules(locale), [locale]);
-
-  return (
-    <>
-      <Select value={locale} onChange={setLocale} style={{ marginBottom: 16 }}>
-        <Select.Option value="ja">日本語</Select.Option>
-        <Select.Option value="en">English</Select.Option>
-        <Select.Option value="vi">Tiếng Việt</Select.Option>
-      </Select>
-
-      <h2>{getUserDisplayName(locale)}</h2>
-
-      <Form form={form} layout="vertical">
-        <Form.Item
-          name="name"
-          label={getUserPropertyDisplayName('name', locale)}
-          rules={rules.name}
-        >
-          <Input />
-        </Form.Item>
-
-        <Form.Item
-          name="email"
-          label={getUserPropertyDisplayName('email', locale)}
-          rules={rules.email}
-        >
-          <Input type="email" />
-        </Form.Item>
-      </Form>
-    </>
-  );
-}
-```
-
-## With Table Columns
-
-```tsx
-import { Table, TableColumnsType } from 'antd';
-import { getUserPropertyDisplayName } from '@/types/model/rules/User.rules';
-import { User } from '@/types/model';
-
-interface UserTableProps {
-  users: User[];
-  locale?: string;
-  loading?: boolean;
-}
-
-export function UserTable({ users, locale = 'ja', loading }: UserTableProps) {
-  const columns: TableColumnsType<User> = [
-    {
-      title: getUserPropertyDisplayName('name', locale),
-      dataIndex: 'name',
-      key: 'name',
-    },
-    {
-      title: getUserPropertyDisplayName('email', locale),
-      dataIndex: 'email',
-      key: 'email',
-    },
-  ];
-
-  return (
-    <Table
-      columns={columns}
-      dataSource={users}
-      rowKey="id"
-      loading={loading}
-    />
-  );
-}
-```
-
-## Custom Form Hook
-
-```tsx
-import { Form, FormInstance } from 'antd';
-import { useMemo } from 'react';
-
-// Generic hook for any model's rules
-export function useModelForm<T>(
-  getRules: (locale: string) => Record<string, any[]>,
-  locale: string = 'ja'
-): {
-  form: FormInstance<T>;
-  rules: Record<string, any[]>;
-} {
-  const [form] = Form.useForm<T>();
-  const rules = useMemo(() => getRules(locale), [getRules, locale]);
-
-  return { form, rules };
-}
-
-// Usage
-import { getUserRules } from '@/types/model/rules/User.rules';
-
-function MyComponent() {
-  const { form, rules } = useModelForm(getUserRules, 'ja');
-
-  return (
-    <Form form={form}>
-      <Form.Item name="name" rules={rules.name}>
-        <Input />
-      </Form.Item>
-    </Form>
-  );
-}
-```
-
-## Modal Form
-
-```tsx
-import { Modal, Form, Input, message } from 'antd';
-import { getUserRules, getUserDisplayName, getUserPropertyDisplayName } from '@/types/model/rules/User.rules';
-import { User } from '@/types/model';
-
-interface UserModalFormProps {
-  open: boolean;
-  onClose: () => void;
-  onSubmit: (values: Partial<User>) => Promise<void>;
-  initialValues?: Partial<User>;
-  locale?: string;
-}
-
-export function UserModalForm({
-  open,
-  onClose,
-  onSubmit,
-  initialValues,
-  locale = 'ja'
-}: UserModalFormProps) {
-  const [form] = Form.useForm();
-  const [loading, setLoading] = useState(false);
-  const rules = getUserRules(locale);
-
-  const handleSubmit = async () => {
-    try {
-      const values = await form.validateFields();
-      setLoading(true);
-      await onSubmit(values);
-      message.success(locale === 'ja' ? '保存しました' : 'Saved successfully');
-      form.resetFields();
-      onClose();
-    } catch (error) {
-      if (error instanceof Error) {
-        message.error(error.message);
-      }
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <Modal
-      title={getUserDisplayName(locale)}
-      open={open}
-      onCancel={onClose}
-      onOk={handleSubmit}
-      confirmLoading={loading}
-      okText={locale === 'ja' ? '保存' : 'Save'}
-      cancelText={locale === 'ja' ? 'キャンセル' : 'Cancel'}
-    >
-      <Form
-        form={form}
-        layout="vertical"
-        initialValues={initialValues}
-      >
-        <Form.Item
-          name="name"
-          label={getUserPropertyDisplayName('name', locale)}
-          rules={rules.name}
-        >
-          <Input />
-        </Form.Item>
-
-        <Form.Item
-          name="email"
-          label={getUserPropertyDisplayName('email', locale)}
-          rules={rules.email}
-        >
-          <Input type="email" />
-        </Form.Item>
-      </Form>
-    </Modal>
-  );
-}
-```
-
-## Validation Rule Types
-
-Omnify generates these rule types based on schema:
-
-| Schema | Generated Rule |
-|--------|---------------|
-| `required: true` | `{ required: true, message: {...} }` |
-| `type: Email` | `{ type: 'email', message: {...} }` |
-| `maxLength: N` | `{ max: N, message: {...} }` |
-| `minLength: N` | `{ min: N, message: {...} }` |
-| `max: N` (numeric) | `{ max: N, type: 'number', message: {...} }` |
-| `min: N` (numeric) | `{ min: N, type: 'number', message: {...} }` |
-| `pattern: regex` | `{ pattern: /regex/, message: {...} }` |
-
-## Built-in Validation Messages
-
-Omnify includes templates for 5 languages:
-- Japanese (ja)
-- English (en)
-- Vietnamese (vi)
-- Korean (ko)
-- Chinese (zh)
-
-Custom templates can be configured in `omnify.config.ts`:
-
-```typescript
-export default defineConfig({
-  output: {
-    typescript: {
-      validationTemplates: {
-        required: {
-          ja: '${displayName}を入力してください',
-          en: '${displayName} is required',
-          vi: '${displayName} là bắt buộc',
-        },
-        maxLength: {
-          ja: '${displayName}は${max}文字以内です',
-          en: '${displayName} must be at most ${max} characters',
-        },
-      },
-    },
-  },
-});
-```
-
-Available placeholders:
-- `${displayName}` - Property display name
-- `${min}` - Minimum value/length
-- `${max}` - Maximum value/length

package/ai-guides/react-form-guide.md

@@ -1,259 +0,0 @@
-# Omnify React Form Guide
-
-This guide explains how to build forms using Omnify generated schemas with **Ant Design** and **TanStack Query**.
-
-## Quick Start
-
-```tsx
-import { Form } from 'antd';
-import { useFormMutation } from '@/omnify/hooks';
-import { type CustomerCreate } from '@/omnify/schemas';
-import { CustomerForm } from '@/features/customers';
-import { api } from '@/lib/api';
-
-function CreateCustomerPage() {
-  const [form] = Form.useForm<CustomerCreate>();
-
-  const mutation = useFormMutation<CustomerCreate>({
-    form,
-    mutationFn: (data) => api.post('/customers', data),
-    invalidateKeys: [['customers']],
-    successMessage: '顧客を登録しました',
-    onSuccess: () => form.resetFields(),
-  });
-
-  return (
-    <CustomerForm
-      form={form}
-      onSubmit={mutation.mutate}
-      loading={mutation.isPending}
-    />
-  );
-}
-```
-
-## useFormMutation Hook
-
-Location: `resources/ts/omnify/hooks/use-form-mutation.ts`
-
-### Usage with Types
-
-```tsx
-import { useFormMutation } from '@/omnify/hooks';
-import { type CustomerCreate } from '@/omnify/schemas';
-
-// With type parameter for type safety
-const mutation = useFormMutation<CustomerCreate>({
-  form,
-  mutationFn: (data) => api.post('/customers', data),
-  invalidateKeys: [['customers']],
-  successMessage: '保存しました',
-  onSuccess: () => form.resetFields(),
-});
-```
-
-### Options
-
-| Option | Type | Description |
-|--------|------|-------------|
-| `form` | `FormInstance<T>` | Ant Design form instance (required) |
-| `mutationFn` | `(data: T) => Promise` | API call function (required) |
-| `invalidateKeys` | `string[][]` | Query keys to invalidate on success |
-| `successMessage` | `string` | Toast message on success |
-| `onSuccess` | `(data) => void` | Callback after success |
-| `onError` | `(error) => void` | Callback after error |
-
-### Laravel Error Handling
-
-The hook automatically handles Laravel validation errors (422):
-
-```json
-{
-  "message": "The given data was invalid.",
-  "errors": {
-    "email": ["The email has already been taken."]
-  }
-}
-```
-
-## Japanese Form Components
-
-Omnify provides specialized components for Japanese data input.
-
-### JapaneseNameField
-
-```tsx
-import { JapaneseNameField } from '@/omnify/components';
-
-<JapaneseNameField
-  schemas={customerSchemas}
-  i18n={customerI18n}
-  prefix="name"        // name_lastname, name_firstname, etc.
-  required             // Show required asterisk
-  showKana={true}      // Show kana fields (default)
-/>
-```
-
-**Fields:** `{prefix}_lastname`, `{prefix}_firstname`, `{prefix}_kana_lastname`, `{prefix}_kana_firstname`
-
-### JapaneseAddressField
-
-```tsx
-import { JapaneseAddressField } from '@/omnify/components';
-
-<JapaneseAddressField
-  form={form}
-  schemas={customerSchemas}
-  i18n={customerI18n}
-  prefix="address"
-  enablePostalLookup={true}  // Postal code → address lookup
-/>
-```
-
-**Fields:** `{prefix}_postal_code`, `{prefix}_prefecture`, `{prefix}_address1`, `{prefix}_address2`, `{prefix}_address3`
-
-**Options:**
-- `enablePostalLookup` - Enable postal code search
-- `autoSearch` - Auto-search when 7 digits entered
-- `usePrefectureId` - Use numeric ID instead of string enum
-
-### JapaneseBankField
-
-```tsx
-import { JapaneseBankField } from '@/omnify/components';
-
-<JapaneseBankField
-  schemas={customerSchemas}
-  i18n={customerI18n}
-  prefix="bank"
-/>
-```
-
-**Fields:** `{prefix}_bank_code`, `{prefix}_branch_code`, `{prefix}_account_type`, `{prefix}_account_number`, `{prefix}_account_holder`
-
-Account type options auto-loaded from `BankAccountType` enum with i18n.
-
-## Complete Form Example
-
-```tsx
-import { Form, Input, Button, Card, Space, Divider } from 'antd';
-import type { FormInstance } from 'antd';
-import { zodRule, setZodLocale } from '@/omnify/lib';
-import { JapaneseNameField, JapaneseAddressField, JapaneseBankField } from '@/omnify/components';
-import {
-  type Customer, type CustomerCreate,
-  customerSchemas, customerI18n,
-  getCustomerFieldLabel, getCustomerFieldPlaceholder,
-} from '@/omnify/schemas';
-
-const LOCALE = 'ja';
-
-interface CustomerFormProps {
-  form: FormInstance<CustomerCreate>;
-  initialValues?: Partial<Customer>;
-  onSubmit: (values: CustomerCreate) => void;
-  loading?: boolean;
-  isEdit?: boolean;
-}
-
-export function CustomerForm({ form, initialValues, onSubmit, loading, isEdit }: CustomerFormProps) {
-  setZodLocale(LOCALE);
-
-  const label = (key: string) => getCustomerFieldLabel(key, LOCALE);
-  const placeholder = (key: string) => getCustomerFieldPlaceholder(key, LOCALE);
-  const rule = (key: keyof typeof customerSchemas) => zodRule(customerSchemas[key], label(key));
-
-  return (
-    <Card>
-      <Form form={form} layout="horizontal" labelCol={{ span: 6 }} wrapperCol={{ span: 18 }}
-            initialValues={initialValues} onFinish={onSubmit} style={{ maxWidth: 800 }}>
-        
-        <Divider orientation="left">氏名</Divider>
-        <JapaneseNameField schemas={customerSchemas} i18n={customerI18n} prefix="name" required />
-
-        <Divider orientation="left">連絡先</Divider>
-        <Form.Item name="phone" label={label('phone')} rules={[rule('phone')]}>
-          <Input placeholder={placeholder('phone')} />
-        </Form.Item>
-        <Form.Item name="email" label={label('email')} rules={[rule('email')]}>
-          <Input type="email" placeholder={placeholder('email')} />
-        </Form.Item>
-
-        <Divider orientation="left">住所</Divider>
-        <JapaneseAddressField form={form} schemas={customerSchemas} i18n={customerI18n}
-                              prefix="address" enablePostalLookup={true} />
-
-        <Divider orientation="left">銀行口座</Divider>
-        <JapaneseBankField schemas={customerSchemas} i18n={customerI18n} prefix="bank" />
-
-        <Form.Item wrapperCol={{ offset: 6, span: 18 }}>
-          <Space>
-            <Button type="primary" htmlType="submit" loading={loading}>
-              {isEdit ? '更新' : '登録'}
-            </Button>
-          </Space>
-        </Form.Item>
-      </Form>
-    </Card>
-  );
-}
-```
-
-## Zod Validation with i18n
-
-```tsx
-import { zodRule, setZodLocale } from '@/omnify/lib';
-
-// Set locale once at component level
-setZodLocale('ja');
-
-// Use zodRule for field validation
-<Form.Item name="email" label={label('email')} rules={[zodRule(customerSchemas.email, label('email'))]}>
-  <Input />
-</Form.Item>
-```
-
-## Kana Validation Rules
-
-```tsx
-import { kanaString, KATAKANA_PATTERN } from '@/omnify/lib/rules';
-
-// Full-width katakana (default)
-const kanaSchema = kanaString();
-
-// Custom options
-const kanaSchema = kanaString({
-  fullWidthKatakana: true,
-  hiragana: true,
-  allowNumbers: true,
-});
-```
-
-## File Structure
-
-```
-resources/ts/omnify/
-├── components/
-│   ├── JapaneseNameField.tsx
-│   ├── JapaneseAddressField.tsx
-│   └── JapaneseBankField.tsx
-├── enum/
-│   └── plugin/
-│       ├── Prefecture.ts
-│       └── BankAccountType.ts
-├── hooks/
-│   └── use-form-mutation.ts
-├── lib/
-│   ├── form-validation.ts
-│   ├── zod-i18n.ts
-│   └── rules/kana.ts
-└── schemas/
-```
-
-## Tips
-
-1. **Use type generics** - `useFormMutation<CustomerCreate>` for type safety
-2. **Use `setZodLocale`** - Call once for localized validation messages
-3. **Use Japanese* components** - Built-in i18n, validation, postal lookup
-4. **Set `invalidateKeys`** - Auto-refresh lists after mutations
-5. **Don't pass `form` to Name/Bank components** - Only Address needs it for postal lookup

package/ai-guides/typescript-guide.md

@@ -1,363 +0,0 @@
-# Omnify TypeScript Generator Guide
-
-This guide covers TypeScript-specific features and generated code patterns for Omnify.
-
-## Quick Start
-
-```bash
-# Create new project (recommended)
-npx @famgia/omnify create-laravel-project my-app
-cd my-app
-
-# Or initialize in existing project
-npx @famgia/omnify init
-
-# Generate TypeScript types
-npx @famgia/omnify generate
-```
-
-## Generated Files
-
-When you run `npx @famgia/omnify generate`, the following TypeScript files are generated:
-
-- `base/*.ts` - Base model interfaces
-- `enum/*.ts` - Enum types with multi-locale labels
-- `rules/*.ts` - Ant Design compatible validation rules
-
-## Type Generation
-
-### Object Schema → Interface
-
-```yaml
-# yaml-language-server: $schema=./node_modules/.omnify/combined-schema.json
-name: User
-properties:
-  id:
-    type: BigInt
-    required: true
-  name:
-    type: String
-    required: true
-    maxLength: 255
-  email:
-    type: String
-    required: true
-    unique: true
-  profile:
-    type: Json
-  createdAt:
-    type: DateTime
-```
-
-Generated:
-```typescript
-export interface User {
-  id: number;
-  name: string;
-  email: string;
-  profile: Record<string, unknown> | null;
-  createdAt: Date | null;
-}
-```
-
-## Type Mapping
-
-| Schema Type | TypeScript Type |
-|-------------|-----------------|
-| `String` | `string` |
-| `Text` | `string` |
-| `MediumText` | `string` |
-| `LongText` | `string` |
-| `TinyInt` | `number` |
-| `Int` | `number` |
-| `BigInt` | `number` |
-| `Float` | `number` |
-| `Decimal` | `number` |
-| `Boolean` | `boolean` |
-| `Date` | `Date` |
-| `DateTime` | `Date` |
-| `Timestamp` | `Date` |
-| `Json` | `Record<string, unknown>` |
-| `EnumRef` | Generated enum type |
-| `Association` | Related model type / array |
-
-## Hidden Schemas
-
-Schemas with `options.hidden: true` are skipped for TypeScript generation:
-
-```yaml
-name: AppCache
-options:
-  hidden: true    # No TypeScript interface generated
-```
-
-Use cases:
-- System tables (cache, sessions, jobs)
-- Tables that don't need frontend types
-
-## Enum Generation (Multi-locale)
-
-```yaml
-# schemas/PostStatus.yaml
-name: PostStatus
-kind: enum
-displayName:
-  ja: 投稿ステータス
-  en: Post Status
-values:
-  draft:
-    ja: 下書き
-    en: Draft
-  published:
-    ja: 公開済み
-    en: Published
-  archived:
-    ja: アーカイブ
-    en: Archived
-```
-
-Generated:
-```typescript
-export const PostStatus = {
-  draft: 'draft',
-  published: 'published',
-  archived: 'archived',
-} as const;
-
-export type PostStatus = typeof PostStatus[keyof typeof PostStatus];
-
-// Multi-locale labels
-export const PostStatusLabels: Record<PostStatus, Record<string, string>> = {
-  draft: { ja: '下書き', en: 'Draft' },
-  published: { ja: '公開済み', en: 'Published' },
-  archived: { ja: 'アーカイブ', en: 'Archived' },
-};
-
-// Get label for specific locale
-export function getPostStatusLabel(value: PostStatus, locale: string = 'en'): string {
-  return PostStatusLabels[value]?.[locale] ?? PostStatusLabels[value]?.['en'] ?? value;
-}
-
-// Helper functions
-export const PostStatusValues = Object.values(PostStatus);
-export function isPostStatus(value: unknown): value is PostStatus {
-  return PostStatusValues.includes(value as PostStatus);
-}
-```
-
-## Display Names and Placeholders
-
-Omnify generates multi-locale display names and placeholders for form inputs.
-
-```typescript
-import {
-  UserDisplayName,
-  UserPropertyDisplayNames,
-  UserPropertyPlaceholders,
-  getUserDisplayName,
-  getUserPropertyDisplayName,
-  getUserPropertyPlaceholder,
-} from './types/models/User';
-
-// Get model display name
-getUserDisplayName('ja');  // "ユーザー"
-getUserDisplayName('en');  // "User"
-
-// Get property display name
-getUserPropertyDisplayName('email', 'ja');  // "メールアドレス"
-getUserPropertyDisplayName('email', 'en');  // "Email"
-
-// Get property placeholder
-getUserPropertyPlaceholder('email', 'ja');  // "メールアドレスを入力"
-getUserPropertyPlaceholder('email', 'en');  // "Enter your email"
-```
-
-### Using Placeholders in Forms
-
-```tsx
-import { Form, Input } from 'antd';
-import {
-  getUserRules,
-  getUserPropertyDisplayName,
-  getUserPropertyPlaceholder,
-} from './types/models/User';
-
-function UserForm({ locale = 'ja' }) {
-  const rules = getUserRules(locale);
-  return (
-    <Form>
-      <Form.Item
-        name="email"
-        label={getUserPropertyDisplayName('email', locale)}
-        rules={rules.email}
-      >
-        <Input placeholder={getUserPropertyPlaceholder('email', locale)} />
-      </Form.Item>
-    </Form>
-  );
-}
-```
-
-## Validation Rules (Ant Design)
-
-Omnify generates Ant Design compatible validation rules in `rules/` directory.
-
-**See detailed guide:** `.claude/omnify/antdesign-guide.md`
-
-Quick example:
-```tsx
-import { Form, Input } from 'antd';
-import { getUserRules, getUserPropertyDisplayName } from './types/model/rules/User.rules';
-
-function UserForm({ locale = 'ja' }) {
-  const rules = getUserRules(locale);
-  return (
-    <Form>
-      <Form.Item name="name" label={getUserPropertyDisplayName('name', locale)} rules={rules.name}>
-        <Input />
-      </Form.Item>
-    </Form>
-  );
-}
-```
-
-## Association Types
-
-### ManyToOne
-```yaml
-author:
-  type: Association
-  relation: ManyToOne
-  target: User
-```
-
-Generated:
-```typescript
-export interface Post {
-  authorId: number;
-  author?: User;  // Optional: loaded relation
-}
-```
-
-### OneToMany
-```yaml
-posts:
-  type: Association
-  relation: OneToMany
-  target: Post
-```
-
-Generated:
-```typescript
-export interface User {
-  posts?: Post[];  // Optional: loaded relation array
-}
-```
-
-### ManyToMany
-```yaml
-tags:
-  type: Association
-  relation: ManyToMany
-  target: Tag
-```
-
-Generated:
-```typescript
-export interface Post {
-  tags?: Tag[];  // Optional: loaded relation array
-}
-```
-
-## Nullable Fields
-
-Fields without `required: true` are nullable:
-
-```yaml
-description:
-  type: LongText  # No required: true
-```
-
-Generated:
-```typescript
-description: string | null;
-```
-
-## Using Generated Types
-
-```typescript
-import { User, Post, PostStatus, isPostStatus } from './types/omnify-types';
-
-// Type-safe object creation
-const user: User = {
-  id: 1,
-  name: 'John',
-  email: 'john@example.com',
-  profile: null,
-  createdAt: new Date(),
-};
-
-// Enum usage
-const status: PostStatus = PostStatus.draft;
-
-// Type guard
-function handleStatus(value: unknown) {
-  if (isPostStatus(value)) {
-    console.log('Valid status:', value);
-  }
-}
-```
-
-## Commands
-
-```bash
-# Create new project
-npx @famgia/omnify create-laravel-project my-app
-
-# Generate TypeScript types
-npx @famgia/omnify generate
-
-# Force regenerate all files
-npx @famgia/omnify generate --force
-
-# Only generate TypeScript types
-npx @famgia/omnify generate --types-only
-
-# Validate schemas
-npx @famgia/omnify validate
-```
-
-## Configuration
-
-```typescript
-// omnify.config.ts
-import { defineConfig } from '@famgia/omnify';
-import typescript from '@famgia/omnify-typescript/plugin';
-
-export default defineConfig({
-  schemasDir: './schemas',
-  lockFilePath: './.omnify.lock',
-
-  plugins: [
-    typescript({
-      // Output path for TypeScript files
-      path: './resources/ts/types/models',
-
-      // Generate Ant Design validation rules
-      generateRules: true,
-    }),
-  ],
-
-  locale: {
-    locales: ['ja', 'en'],
-    defaultLocale: 'ja',
-  },
-});
-```
-
-### Configuration Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `path` | `string` | `./src/types/model` | TypeScript output directory |
-| `generateRules` | `boolean` | `true` | Generate Ant Design validation rules |