sonamu 0.7.53 → 0.8.0

package/dist/types/types.js

@@ -7,6 +7,51 @@ import { z } from "zod";
         shape.array()
     ]);
 }
+/**
+ * 하위 호환성을 위한 헬퍼 함수
+ *
+ * desc 필드와 cone.desc 둘 다 지원합니다.
+ * cone.desc가 있으면 우선적으로 사용하고, 없으면 desc를 사용합니다.
+ */ export function getDescription(item) {
+    return item.cone?.desc || item.desc;
+}
+/**
+ * Zod 4 String Format 타입
+ * entity.json에서 string 타입의 prop에 zodFormat 옵션을 지정하여
+ * BaseSchema 생성 시 Zod의 string format validation을 적용합니다.
+ */ export const ZodStringFormat = z.enum([
+    // 기본 포맷
+    "email",
+    "uuid",
+    "url",
+    "httpUrl",
+    "hostname",
+    "emoji",
+    "base64",
+    "base64url",
+    "hex",
+    "jwt",
+    "nanoid",
+    "cuid",
+    "cuid2",
+    "ulid",
+    "ipv4",
+    "ipv6",
+    "mac",
+    "cidrv4",
+    "cidrv6",
+    // hash 포맷 (알고리즘별)
+    "hashMd5",
+    "hashSha1",
+    "hashSha256",
+    "hashSha384",
+    "hashSha512",
+    // ISO 포맷
+    "isoDate",
+    "isoTime",
+    "isoDatetime",
+    "isoDuration"
+]);
 export const SonamuFileSchema = z.object({
     name: z.string(),
     url: z.string(),
@@ -27,6 +72,26 @@ export function normalizeSubsetField(f) {
 export function isInternalSubsetField(f) {
     return typeof f !== "string" && f.internal === true;
 }
+/**
+ * SubsetDef가 새로운 객체 형태인지 확인
+ */ export function isSubsetDefWithCone(def) {
+    return !Array.isArray(def) && "fields" in def;
+}
+/**
+ * EnumDef가 새로운 객체 형태인지 확인
+ */ export function isEnumDefWithCone(def) {
+    return "values" in def && !("cone" in def && def.cone === undefined && Object.keys(def).length > 1);
+}
+/**
+ * SubsetDef에서 fields 추출
+ */ export function getSubsetFields(def) {
+    return Array.isArray(def) ? def : def.fields;
+}
+/**
+ * EnumDef에서 values 추출
+ */ export function getEnumDefValues(def) {
+    return isEnumDefWithCone(def) ? def.values : def;
+}
 /*
   Prop Type Guards
 */ export function isIntegerSingleProp(p) {
@@ -267,6 +332,29 @@ const GeneratedColumnSchema = z.object({
     ]),
     expression: z.string()
 });
+/**
+ * Cone 스키마 검증
+ *
+ * cone 메타데이터의 유효성을 검증합니다.
+ */ const ConeSchema = z.object({
+    desc: z.string().optional(),
+    note: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    fixtureHint: z.string().optional(),
+    fixtureGenerator: z.string().optional(),
+    fixtureDefault: z.unknown().optional(),
+    dataSource: z.object({
+        strategy: z.enum([
+            "sample",
+            "ids",
+            "query",
+            "file",
+            "recent",
+            "random"
+        ]),
+        config: z.unknown().optional()
+    }).optional()
+}).catchall(z.unknown()); // 사용자 정의 메타데이터 허용
 const BasePropFields = {
     name: z.string(),
     desc: z.string().optional(),
@@ -277,7 +365,8 @@ const BasePropFields = {
         z.number(),
         z.boolean()
     ]).optional(),
-    generated: GeneratedColumnSchema.optional()
+    generated: GeneratedColumnSchema.optional(),
+    cone: ConeSchema.optional()
 };
 // 부가 필드가 필요없는 prop
 const BasePropFieldsWithoutAdditional = z.object({
@@ -303,12 +392,14 @@ const PrecisionScaleFields = {
 const StringPropSchema = z.object({
     ...BasePropFields,
     type: z.literal("string"),
-    length: z.number().optional()
+    length: z.number().optional(),
+    zodFormat: ZodStringFormat.optional()
 }).strict();
 const StringArrayPropSchema = z.object({
     ...BasePropFields,
     type: z.literal("string[]"),
-    length: z.number().optional()
+    length: z.number().optional(),
+    zodFormat: ZodStringFormat.optional()
 }).strict();
 const EnumPropSchema = z.object({
     ...BasePropFields,
@@ -585,21 +676,54 @@ const EntityIndexSchema = z.object({
     efConstruction: z.number().optional(),
     lists: z.number().optional()
 }).strict();
+/**
+ * SubsetDef 스키마
+ *
+ * 하위 호환성을 위해 배열 형태와 객체 형태 둘 다 지원합니다.
+ */ const SubsetDefSchema = z.union([
+    // 기존 배열 형태
+    z.array(z.union([
+        z.string(),
+        z.object({
+            field: z.string(),
+            internal: z.boolean().optional()
+        })
+    ])),
+    // 새로운 객체 형태
+    z.object({
+        fields: z.array(z.union([
+            z.string(),
+            z.object({
+                field: z.string(),
+                internal: z.boolean().optional()
+            })
+        ])),
+        cone: ConeSchema.optional()
+    })
+]);
+/**
+ * EnumDef 스키마
+ *
+ * 하위 호환성을 위해 Record 형태와 객체 형태 둘 다 지원합니다.
+ */ const EnumDefSchema = z.union([
+    // 기존 Record 형태
+    z.record(z.string(), z.string()),
+    // 새로운 객체 형태
+    z.object({
+        values: z.record(z.string(), z.string()),
+        cone: ConeSchema.optional()
+    })
+]);
 export const EntityJsonSchema = z.object({
     id: z.string().describe("PascalCase로 된 Entity ID"),
     title: z.string().describe("Entity 이름"),
     table: z.string().describe("snake_case로 된 테이블명"),
     parentId: z.string().optional().describe("부모 Entity ID"),
+    cone: ConeSchema.optional(),
     props: z.array(EntityPropSchema),
     indexes: z.array(EntityIndexSchema),
-    subsets: z.record(z.string(), z.array(z.union([
-        z.string(),
-        z.object({
-            field: z.string(),
-            internal: z.boolean().optional()
-        })
-    ]))),
-    enums: z.record(z.string(), z.record(z.string(), z.string()))
+    subsets: z.record(z.string(), SubsetDefSchema),
+    enums: z.record(z.string(), EnumDefSchema)
 }).strict();
 export const TemplateOptions = z.object({
     entity: EntityJsonSchema.omit({
@@ -655,14 +779,6 @@ export const TemplateOptions = z.object({
     view_id_all_select: z.object({
         entityId: z.string()
     }),
-    view_id_async_select: z.object({
-        entityId: z.string(),
-        textField: z.string()
-    }),
-    view_enums_select: z.object({
-        entityId: z.string(),
-        enumId: z.string()
-    }),
     view_enums_buttonset: z.object({
         entityId: z.string(),
         enumId: z.string()
@@ -692,8 +808,6 @@ export const TemplateKey = z.enum([
     "view_search_input",
     "view_form",
     "view_id_all_select",
-    "view_id_async_select",
-    "view_enums_select",
     "view_enums_buttonset",
     "queries",
     "entry_server",
@@ -708,4 +822,4 @@ export const PathAndCode = z.object({
 });
 export var ApiParamType;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/types/types.ts"],"sourcesContent":["import type { FastifyReply, FastifyRequest } from \"fastify\";\nimport { z } from \"zod\";\nimport type { ApiDecoratorOptions, Context } from \"../api\";\nimport type { GuardKey } from \"./../api/decorators\";\nimport type { CacheControlHandler } from \"../cache-control/types\";\n\n/*\n  Utility Types\n*/\nexport function zArrayable<T extends z.ZodTypeAny>(shape: T): z.ZodUnion<[T, z.ZodArray<T>]> {\n  return z.union([shape, shape.array()]);\n}\n// biome-ignore lint/suspicious/noExplicitAny: any is used to make the type distributive\nexport type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;\n\n/*\n  Model-Definition\n*/\nexport type GeneratedColumnType = \"STORED\" | \"VIRTUAL\";\nexport type GeneratedColumn = {\n  type: GeneratedColumnType;\n  expression: string;\n};\nexport type CommonProp = {\n  name: string;\n  nullable?: boolean;\n  toFilter?: true;\n  desc?: string;\n  dbDefault?: string;\n  generated?: GeneratedColumn;\n};\nexport type IntegerProp = CommonProp & {\n  type: \"integer\";\n}; // PG: integer / TS: number / JSON: number\nexport type IntegerArrayProp = CommonProp & {\n  type: \"integer[]\";\n}; // PG: integer[] / TS: number[] / JSON: number[]\nexport type BigIntegerProp = CommonProp & {\n  type: \"bigInteger\";\n}; // PG: bigint / TS: bigint / JSON: bigint\nexport type BigIntegerArrayProp = CommonProp & {\n  type: \"bigInteger[]\";\n}; // PG: bigint[] / TS: bigint[] / JSON: bigint[]\nexport type StringProp = CommonProp & {\n  type: \"string\";\n  length?: number; // PG: varchar(n), text / TS: string / JSON: string\n}; // PG: text / TS: string / JSON: string\nexport type StringArrayProp = CommonProp & {\n  type: \"string[]\";\n  length?: number; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]\n}; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]\nexport type EnumProp = CommonProp & {\n  type: \"enum\";\n  id: string;\n  length?: number;\n}; // PG: text / TS: string / JSON: string\nexport type EnumArrayProp = CommonProp & {\n  type: \"enum[]\";\n  id: string;\n}; // PG: text[] / TS: string[] / JSON: string[]\nexport type NumberProp = CommonProp & {\n  type: \"number\";\n  precision?: number; // PG: numeric(p, s) / TS: number / JSON: number\n  scale?: number; // PG: numeric(p, s) / TS: number / JSON: number\n  numberType?: \"real\" | \"double precision\" | \"numeric\"; // 기본값: numeric\n}; // PG: numeric(p, s) / TS: number / JSON: number\nexport type NumberArrayProp = CommonProp & {\n  type: \"number[]\";\n  precision?: number;\n  scale?: number;\n  numberType?: \"real\" | \"double precision\" | \"numeric\"; // 기본값: numeric\n}; // PG: numeric(p, s)[] / TS: number[] / JSON: number[]\nexport type NumericProp = CommonProp & {\n  type: \"numeric\";\n  precision?: number;\n  scale?: number;\n}; // PG: numeric(p, s) / TS: string / JSON: string\nexport type NumericArrayProp = CommonProp & {\n  type: \"numeric[]\";\n  precision?: number;\n  scale?: number;\n}; // PG: numeric(p, s)[] / TS: string[] / JSON: string[]\nexport type BooleanProp = CommonProp & {\n  type: \"boolean\";\n}; // PG: boolean / TS: boolean / JSON: boolean\nexport type BooleanArrayProp = CommonProp & {\n  type: \"boolean[]\";\n}; // PG: boolean[] / TS: boolean[] / JSON: boolean[]\nexport type DateProp = CommonProp & {\n  type: \"date\";\n  // 기본값은 3, microseconds를 쓰려면 6을 써야함 (0 ~ 6)\n  precision?: number;\n}; // PG: timestampz / TS: Date / JSON: string(ISOString)\nexport type DateArrayProp = CommonProp & {\n  type: \"date[]\";\n  // 기본값은 3, microseconds를 쓰려면 6을 써야함 (0 ~ 6)\n  precision?: number;\n}; // PG: timestamptz[] / TS: Date[] / JSON: string[]\nexport type JsonProp = CommonProp & {\n  type: \"json\";\n  id: string;\n}; // PG: json / TS: any(id) / JSON: any\nexport type UuidProp = CommonProp & {\n  type: \"uuid\";\n}; // PG: uuid / TS: string / JSON: string\nexport type UuidArrayProp = CommonProp & {\n  type: \"uuid[]\";\n}; // PG: uuid[] / TS: string[] / JSON: string[]\nexport type VirtualProp = CommonProp & {\n  type: \"virtual\";\n  id: string;\n  virtualType?: \"query\" | \"code\"; // default: \"code\"\n}; // PG: none / TS: any(id) / JSON: any\nexport type VectorProp = CommonProp & {\n  type: \"vector\";\n  dimensions: number;\n};\nexport type VectorArrayProp = CommonProp & {\n  type: \"vector[]\";\n  dimensions: number;\n};\nexport type TsVectorProp = CommonProp & {\n  type: \"tsvector\";\n};\nexport type RelationType = \"HasMany\" | \"BelongsToOne\" | \"ManyToMany\" | \"OneToOne\";\nexport type RelationOn = \"CASCADE\" | \"SET NULL\" | \"NO ACTION\" | \"SET DEFAULT\" | \"RESTRICT\";\ntype _RelationProp = {\n  type: \"relation\";\n  name: string;\n  with: string;\n  nullable?: boolean; // DEFAULT: false\n  toFilter?: true; // DEFAULT: false\n  desc?: string;\n};\nexport type OneToOneRelationProp = _RelationProp & {\n  relationType: \"OneToOne\";\n  customJoinClause?: string;\n} & (\n    | {\n        hasJoinColumn: true;\n        useConstraint?: boolean; // DEFAULT: true\n        onUpdate?: RelationOn; // DEFAULT: RESTRICT\n        onDelete?: RelationOn; // DEFAULT: RESTRICT\n      }\n    | {\n        hasJoinColumn: false;\n      }\n  );\nexport type BelongsToOneRelationProp = _RelationProp & {\n  relationType: \"BelongsToOne\";\n  customJoinClause?: string;\n  useConstraint?: boolean; // DEFAULT: true\n  onUpdate?: RelationOn; // DEFAULT: RESTRICT\n  onDelete?: RelationOn; // DEFAULT: RESTRICT\n};\nexport type HasManyRelationProp = _RelationProp & {\n  relationType: \"HasMany\";\n  joinColumn: string;\n  fromColumn?: string;\n};\nexport type ManyToManyRelationProp = _RelationProp & {\n  relationType: \"ManyToMany\";\n  joinTable: `${string}__${string}`;\n  onUpdate: RelationOn;\n  onDelete: RelationOn;\n};\nexport type RelationProp =\n  | OneToOneRelationProp\n  | BelongsToOneRelationProp\n  | HasManyRelationProp\n  | ManyToManyRelationProp;\n\nexport type EntityProp =\n  | IntegerProp\n  | IntegerArrayProp\n  | BigIntegerProp\n  | BigIntegerArrayProp\n  | StringProp\n  | StringArrayProp\n  | EnumProp\n  | EnumArrayProp\n  | NumberProp\n  | NumberArrayProp\n  | NumericProp\n  | NumericArrayProp\n  | NumericProp\n  | BooleanProp\n  | BooleanArrayProp\n  | DateProp\n  | DateArrayProp\n  | UuidProp\n  | UuidArrayProp\n  | JsonProp\n  | VirtualProp\n  | VectorProp\n  | VectorArrayProp\n  | TsVectorProp\n  | RelationProp;\n\n/**\n * SonamuFile Types\n *\n * 파일 업로드를 위한 JSON 타입입니다.\n * Entity의 json 속성에서 id로 \"SonamuFile\" 또는 \"SonamuFile[]\"을 지정하여 사용합니다.\n */\nexport interface SonamuFile {\n  name: string;\n  url: string;\n  mime_type: string;\n  size: number;\n}\n\nexport const SonamuFileSchema = z\n  .object({\n    name: z.string(),\n    url: z.string(),\n    mime_type: z.string(),\n    size: z.number(),\n  })\n  .describe(\"SonamuFile\");\n\nexport const SonamuFileArraySchema = z.array(SonamuFileSchema).describe(\"SonamuFile[]\");\n\n/**\n * Sonamu 코어에서 제공하는 내장 JSON 타입 ID 목록\n * 새로운 내장 타입 추가 시 이 배열에 추가하면 자동으로 UI에 노출됩니다.\n */\nexport const BUILT_IN_TYPE_IDS = [\"SonamuFile\", \"SonamuFile[]\"] as const;\nexport type BuiltInTypeId = (typeof BUILT_IN_TYPE_IDS)[number];\n\n/**\n * pgvector 거리 연산자 클래스\n *\n * @description\n * - `vector_cosine_ops`: 코사인 거리 (Cosine Distance) - 권장\n *   - SQL 연산자: `<=>`\n *   - 벡터의 방향만 비교 (크기 무시), 1 - cosine_similarity\n *   - 텍스트 임베딩, 시맨틱 검색에 가장 일반적으로 사용\n *   - 사용 예: OpenAI, Voyage 등 대부분의 임베딩 모델에 권장\n *\n * - `vector_ip_ops`: 내적 (Inner Product)\n *   - SQL 연산자: `<#>`\n *   - 두 벡터의 내적을 계산 (sum(a[i] * b[i]))\n *   - 정규화된 벡터에서 코사인 유사도와 동일한 결과\n *   - 값이 클수록 유사 (음수 연산자이므로 ORDER BY에서 주의)\n *   - 사용 예: 이미 정규화된 임베딩에서 가장 빠른 성능\n *\n * - `vector_l2_ops`: 유클리드 거리 (L2 Distance)\n *   - SQL 연산자: `<->`\n *   - 두 벡터 간의 직선 거리를 계산 (sqrt(sum((a[i] - b[i])^2)))\n *   - 벡터의 크기(magnitude)가 중요할 때 사용\n *   - 사용 예: 이미지 유사도, 절대적 거리 측정이 필요한 경우\n */\nexport type VectorOps = \"vector_cosine_ops\" | \"vector_ip_ops\" | \"vector_l2_ops\";\n\ntype EntityIndexColumn = {\n  name: string;\n  nullsFirst?: boolean;\n  sortOrder?: \"ASC\" | \"DESC\";\n  /** pgvector 인덱스에서 사용할 거리 연산자 (vector 컬럼에만 적용) */\n  vectorOps?: VectorOps;\n};\nexport type EntityIndex = {\n  type: \"index\" | \"unique\" | \"hnsw\" | \"ivfflat\";\n  columns: EntityIndexColumn[];\n  name: string;\n  using?: \"btree\" | \"hash\" | \"gin\" | \"gist\" | \"pgroonga\";\n  nullsNotDistinct?: boolean; // unique index only\n  /**\n   * HNSW (Hierarchical Navigable Small World) 인덱스: 각 노드의 최대 연결 수\n   *\n   * @description\n   * 그래프에서 각 노드가 가질 수 있는 최대 연결 수입니다.\n   * HNSW는 빠른 검색 속도와 높은 정확도를 제공하므로 권장됩니다.\n   * - 기본값: 16\n   * - 범위: 2 ~ 100\n   * - 높을수록: 정확도↑, 빌드 시간↑, 메모리↑\n   * - 권장: 빠른 빌드(8), 균형(16), 높은 정확도(32), 최고 정확도(64)\n   */\n  m?: number;\n  /**\n   * HNSW (Hierarchical Navigable Small World) 인덱스: 구성 시 탐색 범위\n   *\n   * @description\n   * 인덱스 구성 시 각 노드에서 탐색할 범위입니다.\n   * - 기본값: 64\n   * - 범위: 4 ~ 1000\n   * - 높을수록: 정확도↑, 빌드 시간↑\n   * - 권장: 빠른 빌드(32), 균형(64), 높은 정확도(128), 최고 정확도(256)\n   */\n  efConstruction?: number;\n  /**\n   * IVFFlat (Inverted File with Flat Compression) 인덱스: 클러스터링 리스트 수\n   *\n   * @description\n   * 벡터를 클러스터링할 버킷 수를 지정합니다.\n   * IVFFlat은 빠른 빌드와 낮은 메모리 사용이 필요할 때 사용합니다.\n   * - 권장값: sqrt(row_count) ~ row_count / 1000\n   * - 예시: 10,000행 → 100, 100,000행 → 300, 1,000,000행 → 1000\n   * - 많을수록 정확도↑, 검색 속도↓\n   */\n  lists?: number;\n};\n\n// SubsetField 타입: string 또는 internal 옵션이 있는 객체\nexport type SubsetField = string | { field: string; internal?: boolean };\n\nexport function normalizeSubsetField(f: SubsetField): string {\n  return typeof f === \"string\" ? f : f.field;\n}\nexport function isInternalSubsetField(f: SubsetField): boolean {\n  return typeof f !== \"string\" && f.internal === true;\n}\n\nexport type EntityJson = {\n  id: string;\n  parentId?: string;\n  table: string;\n  title?: string;\n  props: EntityProp[];\n  indexes: EntityIndex[];\n  subsets: {\n    [subset: string]: SubsetField[];\n  };\n  enums: {\n    [enumId: string]: {\n      [key: string]: string;\n    };\n  };\n};\nexport type EntitySubsetRow = {\n  field: string;\n  has: {\n    [key: string]: boolean;\n  };\n  isInternal: {\n    [key: string]: boolean;\n  };\n  children: EntitySubsetRow[];\n  prefixes: string[];\n  relationEntity?: string;\n  isOpen?: boolean;\n};\nexport type FlattenSubsetRow = Omit<EntitySubsetRow, \"children\">;\n\n/*\n  PropNode\n*/\n\n/**\n * 엔티티의 필드 구조를 트리 형태로 표현하는 중간 노드입니다.\n *\n * **목적**: Entity의 subset 필드 표현식(예: \"id\", \"user.name\", \"tags[]\")을\n * 재귀적인 트리 구조로 파싱하여 Zod 스키마 생성의 중간 단계로 사용합니다.\n *\n * **변환 흐름**:\n * Entity subset → EntityPropNode (트리 구조) → Zod 스키마 → RenderingNode (UI용)\n *\n * **nodeType**:\n * - \"plain\": 단일 필드 (예: \"id\", \"name\")\n * - \"object\": 중첩 객체 (예: \"user.name\" → user 객체)\n * - \"array\": 배열 (예: \"tags[]\" → tags 배열)\n *\n * **사용 위치**: entity-converter.ts의 propNodeToZodType()\n */\nexport type EntityPropNode =\n  | {\n      nodeType: \"plain\";\n      prop: EntityProp;\n    }\n  | {\n      nodeType: \"object\" | \"array\";\n      prop?: EntityProp;\n      children: EntityPropNode[];\n    };\n\n/*\n  Prop Type Guards\n*/\nexport function isIntegerSingleProp(p: unknown): p is IntegerProp {\n  return (p as IntegerProp)?.type === \"integer\";\n}\nexport function isIntegerArrayProp(p: unknown): p is IntegerArrayProp {\n  return (p as IntegerArrayProp)?.type === \"integer[]\";\n}\nexport function isIntegerProp(p: unknown): p is IntegerProp | IntegerArrayProp {\n  return isIntegerSingleProp(p) || isIntegerArrayProp(p);\n}\nexport function isBigIntegerSingleProp(p: unknown): p is BigIntegerProp {\n  return (p as BigIntegerProp)?.type === \"bigInteger\";\n}\nexport function isBigIntegerArrayProp(p: unknown): p is BigIntegerArrayProp {\n  return (p as BigIntegerArrayProp)?.type === \"bigInteger[]\";\n}\nexport function isBigIntegerProp(p: unknown): p is BigIntegerProp | BigIntegerArrayProp {\n  return isBigIntegerSingleProp(p) || isBigIntegerArrayProp(p);\n}\nexport function isStringSingleProp(p: unknown): p is StringProp {\n  return (p as StringProp)?.type === \"string\";\n}\nexport function isStringArrayProp(p: unknown): p is StringArrayProp {\n  return (p as StringArrayProp)?.type === \"string[]\";\n}\nexport function isStringProp(p: unknown): p is StringProp | StringArrayProp {\n  return isStringSingleProp(p) || isStringArrayProp(p);\n}\nexport function isEnumSingleProp(p: unknown): p is EnumProp {\n  return (p as EnumProp)?.type === \"enum\";\n}\nexport function isEnumArrayProp(p: unknown): p is EnumArrayProp {\n  return (p as EnumArrayProp)?.type === \"enum[]\";\n}\nexport function isEnumProp(p: unknown): p is EnumProp | EnumArrayProp {\n  return isEnumSingleProp(p) || isEnumArrayProp(p);\n}\nexport function isNumberSingleProp(p: unknown): p is NumberProp {\n  return (p as NumberProp)?.type === \"number\";\n}\nexport function isNumberArrayProp(p: unknown): p is NumberArrayProp {\n  return (p as NumberArrayProp)?.type === \"number[]\";\n}\nexport function isNumberProp(p: unknown): p is NumberProp | NumberArrayProp {\n  return isNumberSingleProp(p) || isNumberArrayProp(p);\n}\nexport function isNumericSingleProp(p: unknown): p is NumericProp {\n  return (p as NumericProp)?.type === \"numeric\";\n}\nexport function isNumericArrayProp(p: unknown): p is NumericArrayProp {\n  return (p as NumericArrayProp)?.type === \"numeric[]\";\n}\nexport function isNumericProp(p: unknown): p is NumericProp | NumericArrayProp {\n  return isNumericSingleProp(p) || isNumericArrayProp(p);\n}\nexport function isBooleanSingleProp(p: unknown): p is BooleanProp {\n  return (p as BooleanProp)?.type === \"boolean\";\n}\nexport function isBooleanArrayProp(p: unknown): p is BooleanArrayProp {\n  return (p as BooleanArrayProp)?.type === \"boolean[]\";\n}\nexport function isBooleanProp(p: unknown): p is BooleanProp | BooleanArrayProp {\n  return isBooleanSingleProp(p) || isBooleanArrayProp(p);\n}\nexport function isDateSingleProp(p: unknown): p is DateProp {\n  return (p as DateProp)?.type === \"date\";\n}\nexport function isDateArrayProp(p: unknown): p is DateArrayProp {\n  return (p as DateArrayProp)?.type === \"date[]\";\n}\nexport function isDateProp(p: unknown): p is DateProp | DateArrayProp {\n  return isDateSingleProp(p) || isDateArrayProp(p);\n}\nexport function isUuidSingleProp(p: unknown): p is UuidProp {\n  return (p as UuidProp)?.type === \"uuid\";\n}\nexport function isUuidArrayProp(p: unknown): p is UuidArrayProp {\n  return (p as UuidArrayProp)?.type === \"uuid[]\";\n}\nexport function isUuidProp(p: unknown): p is UuidProp | UuidArrayProp {\n  return isUuidSingleProp(p) || isUuidArrayProp(p);\n}\nexport function isJsonProp(p: unknown): p is JsonProp {\n  return (p as JsonProp)?.type === \"json\";\n}\nexport function isVirtualProp(p: unknown): p is VirtualProp {\n  return (p as VirtualProp)?.type === \"virtual\";\n}\nexport function isVirtualCodeProp(p: unknown): p is VirtualProp {\n  if (!isVirtualProp(p)) return false;\n  return p.virtualType !== \"query\"; // undefined도 \"code\"로 취급\n}\nexport function isVirtualQueryProp(p: unknown): p is VirtualProp {\n  if (!isVirtualProp(p)) return false;\n  return p.virtualType === \"query\";\n}\nexport function isVectorSingleProp(p: unknown): p is VectorProp {\n  return (p as VectorProp)?.type === \"vector\";\n}\nexport function isVectorArrayProp(p: unknown): p is VectorArrayProp {\n  return (p as VectorArrayProp)?.type === \"vector[]\";\n}\nexport function isVectorProp(p: unknown): p is VectorProp | VectorArrayProp {\n  return isVectorSingleProp(p) || isVectorArrayProp(p);\n}\nexport function isTsVectorProp(p: unknown): p is TsVectorProp {\n  return (p as TsVectorProp)?.type === \"tsvector\";\n}\nexport function isRelationProp(p: unknown): p is RelationProp {\n  return (p as RelationProp)?.type === \"relation\";\n}\nexport function isOneToOneRelationProp(p: unknown): p is OneToOneRelationProp {\n  return (p as OneToOneRelationProp)?.relationType === \"OneToOne\";\n}\nexport function isBelongsToOneRelationProp(p: unknown): p is BelongsToOneRelationProp {\n  return (p as BelongsToOneRelationProp)?.relationType === \"BelongsToOne\";\n}\nexport function isHasManyRelationProp(p: unknown): p is HasManyRelationProp {\n  return (p as HasManyRelationProp)?.relationType === \"HasMany\";\n}\nexport function isManyToManyRelationProp(p: unknown): p is ManyToManyRelationProp {\n  return (p as ManyToManyRelationProp)?.relationType === \"ManyToMany\";\n}\n\ntype JoinClause =\n  | {\n      from: string;\n      to: string;\n    }\n  | {\n      custom: string;\n    };\nexport function isCustomJoinClause(p: unknown): p is { custom: string } {\n  return !!(p as { custom: string })?.custom;\n}\n\ntype SubsetLoader = {\n  as: string;\n  table: string;\n  manyJoin: {\n    fromTable: string;\n    fromCol: string;\n    idField: string;\n    toTable: string;\n    toCol: string;\n    through?: {\n      table: string;\n      fromCol: string;\n      toCol: string;\n    };\n  };\n  oneJoins: ({\n    as: string;\n    join: \"inner\" | \"outer\";\n    table: string;\n  } & JoinClause)[];\n  select: string[];\n  loaders?: SubsetLoader[];\n};\n\nexport type SubsetQuery = {\n  select: string[];\n  virtual: string[];\n  joins: ({\n    as: string;\n    join: \"inner\" | \"outer\";\n    table: string;\n  } & JoinClause)[];\n  loaders: SubsetLoader[];\n};\n\n/* BaseModel */\nexport const SonamuQueryMode = z.enum([\"both\", \"list\", \"count\"]);\nexport type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;\n\n/* Semantic Query */\nexport const SonamuSemanticParams = z.object({\n  semanticQuery: z.object({\n    embedding: z.array(z.number()).min(1024).max(1024),\n    threshold: z.number().optional(),\n    method: z.enum([\"cosine\", \"l2\", \"inner_product\"]).optional(),\n  }),\n});\nexport type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;\n\n/* Knex Migration */\nexport type KnexError = {\n  code: string;\n  errno: number;\n  sql: string;\n  sqlMessage: string;\n  sqlState: string;\n};\nexport function isKnexError(e: unknown): e is KnexError {\n  return !!(e as KnexError)?.code && !!(e as KnexError)?.sqlMessage && !!(e as KnexError)?.sqlState;\n}\n\nexport type KnexColumnType =\n  | \"string\"\n  | \"text\"\n  | \"smalltext\"\n  | \"mediumtext\"\n  | \"longtext\"\n  | \"integer\"\n  | \"bigInteger\"\n  | \"decimal\"\n  | \"timestamp\"\n  | \"boolean\"\n  | \"foreign\"\n  | \"uuid\"\n  | \"json\"\n  | \"float\"\n  | \"date\"\n  | \"time\"\n  | \"datetime\";\nexport type MigrationColumnType =\n  | \"string\"\n  | \"string[]\"\n  | \"integer\"\n  | \"integer[]\"\n  | \"bigInteger\"\n  | \"bigInteger[]\"\n  | \"numberOrNumeric\"\n  | \"numberOrNumeric[]\"\n  | \"boolean\"\n  | \"boolean[]\"\n  | \"date\"\n  | \"date[]\"\n  | \"uuid\"\n  | \"uuid[]\"\n  | \"json\"\n  | \"vector\"\n  | \"vector[]\"\n  | \"tsvector\";\nexport type MigrationColumn = {\n  name: string;\n  type: MigrationColumnType;\n  nullable: boolean;\n  numberType?: \"real\" | \"double precision\" | \"numeric\";\n  length?: number;\n  defaultTo?: string;\n  precision?: number;\n  scale?: number;\n  dimensions?: number;\n  generated?: GeneratedColumn;\n};\nexport type MigrationIndex = {\n  type: \"unique\" | \"index\" | \"hnsw\" | \"ivfflat\";\n  columns: EntityIndexColumn[];\n  name: string;\n  using?: \"btree\" | \"hash\" | \"gin\" | \"gist\" | \"pgroonga\";\n  nullsNotDistinct?: boolean;\n  /** HNSW (Hierarchical Navigable Small World): 각 노드의 최대 연결 수 */\n  m?: number;\n  /** HNSW (Hierarchical Navigable Small World): 구성 시 탐색 범위 */\n  efConstruction?: number;\n  /** IVFFlat (Inverted File with Flat Compression): 클러스터링 리스트 수 */\n  lists?: number;\n};\nexport type MigrationForeign = {\n  columns: string[];\n  to: string;\n  onUpdate: RelationOn;\n  onDelete: RelationOn;\n};\nexport type MigrationJoinTable = {\n  table: string;\n  indexes: MigrationIndex[];\n  columns: MigrationColumn[];\n  foreigns: MigrationForeign[];\n};\nexport type MigrationSet = {\n  table: string;\n  columns: MigrationColumn[];\n  indexes: MigrationIndex[];\n  foreigns: MigrationForeign[];\n};\nexport type MigrationSetAndJoinTable = MigrationSet & {\n  joinTables: MigrationJoinTable[];\n};\nexport type GenMigrationCode = {\n  title: string;\n  table: string;\n  type: \"normal\" | \"foreign\";\n  formatted: string | null;\n};\n\n/* Api */\nexport type ApiParam = {\n  name: string;\n  type: ApiParamType;\n  optional: boolean;\n  defaultDef?: string;\n};\nexport namespace ApiParamType {\n  export type Object = {\n    t: \"object\";\n    props: ApiParam[];\n  };\n  export type Union = {\n    t: \"union\";\n    types: ApiParamType[];\n  };\n  export type Intersection = {\n    t: \"intersection\";\n    types: ApiParamType[];\n  };\n  export type StringLiteral = {\n    t: \"string-literal\";\n    value: string;\n  };\n  export type NumericLiteral = {\n    t: \"numeric-literal\";\n    value: number;\n  };\n  export type Array = {\n    t: \"array\";\n    elementsType: ApiParamType;\n  };\n  export type Ref = {\n    t: \"ref\";\n    id: string;\n    args?: ApiParamType[];\n  };\n  export type IndexedAccess = {\n    t: \"indexed-access\";\n    object: ApiParamType;\n    index: ApiParamType;\n  };\n  export type TupleType = {\n    t: \"tuple-type\";\n    elements: ApiParamType[];\n  };\n  export type Pick = Ref & {\n    t: \"ref\";\n    id: \"Pick\";\n  };\n  export type Omit = Ref & {\n    t: \"ref\";\n    id: \"Omit\";\n  };\n  export type Partial = Ref & {\n    t: \"ref\";\n    id: \"Partial\";\n  };\n  export type Promise = Ref & {\n    t: \"ref\";\n    id: \"Promise\";\n  };\n  export type Context = Ref & {\n    t: \"ref\";\n    id: \"Context\";\n  };\n  export type TypeParam = {\n    t: \"type-param\";\n    id: string;\n    constraint?: ApiParamType;\n  };\n\n  export function isObject(v: unknown): v is ApiParamType.Object {\n    return (v as ApiParamType.Object)?.t === \"object\";\n  }\n  export function isUnion(v: unknown): v is ApiParamType.Union {\n    return (v as ApiParamType.Union)?.t === \"union\";\n  }\n  export function isIntersection(v: unknown): v is ApiParamType.Intersection {\n    return (v as ApiParamType.Intersection)?.t === \"intersection\";\n  }\n  export function isStringLiteral(v: unknown): v is ApiParamType.StringLiteral {\n    return (v as ApiParamType.StringLiteral)?.t === \"string-literal\";\n  }\n  export function isNumericLiteral(v: unknown): v is ApiParamType.NumericLiteral {\n    return (v as ApiParamType.NumericLiteral)?.t === \"numeric-literal\";\n  }\n  export function isArray(v: unknown): v is ApiParamType.Array {\n    return (v as ApiParamType.Array)?.t === \"array\";\n  }\n  export function isRef(v: unknown): v is ApiParamType.Ref {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"ref\";\n  }\n  export function isIndexedAccess(v: unknown): v is ApiParamType.IndexedAccess {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"indexed-access\";\n  }\n  export function isTupleType(v: unknown): v is ApiParamType.TupleType {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"tuple-type\";\n  }\n  export function isPick(v: unknown): v is ApiParamType.Pick {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Pick\"\n    );\n  }\n  export function isOmit(v: unknown): v is ApiParamType.Omit {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Omit\"\n    );\n  }\n  export function isPartial(v: unknown): v is ApiParamType.Partial {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Partial\"\n    );\n  }\n  export function isPromise(v: unknown): v is ApiParamType.Promise {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Promise\"\n    );\n  }\n  export function isContext(v: unknown): v is ApiParamType.Context {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Context\"\n    );\n  }\n  export function isRefKnex(v: unknown): v is ApiParamType.Ref {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Knex\"\n    );\n  }\n  export function isTypeParam(v: unknown): v is ApiParamType.TypeParam {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"type-param\";\n  }\n}\nexport type ApiParamType =\n  | \"string\"\n  | \"number\"\n  | \"boolean\"\n  | \"null\"\n  | \"undefined\"\n  | \"void\"\n  | \"any\"\n  | \"unknown\"\n  | \"true\"\n  | \"false\"\n  | ApiParamType.StringLiteral\n  | ApiParamType.NumericLiteral\n  | ApiParamType.Object\n  | ApiParamType.Union\n  | ApiParamType.Intersection\n  | ApiParamType.Array\n  | ApiParamType.Ref\n  | ApiParamType.IndexedAccess\n  | ApiParamType.TypeParam\n  | ApiParamType.TupleType;\n\n/* Template */\n/**\n * UI 컴포넌트 렌더링을 위한 메타데이터 노드입니다.\n *\n * **목적**: Zod 스키마로부터 프론트엔드 UI 컴포넌트를 자동 생성하기 위한\n * 렌더링 정보를 담은 트리 구조입니다. 각 필드가 어떤 UI 컴포넌트로\n * 표현되어야 하는지(텍스트, 이미지, 날짜, Enum 선택 등)를 명시합니다.\n *\n * **변환 흐름**:\n * Entity subset → EntityPropNode → Zod 스키마 → RenderingNode (UI용) → React 컴포넌트 코드 생성\n *\n * **주요 필드**:\n * - `renderType`: UI 컴포넌트 유형 (string-plain, number-fk_id, enums, array 등)\n * - `zodType`: 원본 Zod 스키마 (validation 용)\n * - `children`: 중첩된 객체 필드들 (object일 때)\n * - `element`: 배열 요소 타입 (array일 때)\n *\n * **사용 위치**:\n * - zod-converter.ts의 zodTypeToRenderingNode()에서 생성\n * - view_form.template.ts, view_list.template.ts 등에서 React 컴포넌트 코드 생성에 사용\n */\n// 셀프 참조 타입이므로 Zod 생략하고 직접 정의\nexport const RenderingNode = z.any();\nexport type RenderingNode = {\n  name: string;\n  label: string;\n  renderType:\n    | \"string-plain\"\n    | \"string-image\"\n    | \"string-datetime\"\n    | \"string-date\"\n    | \"datetime\"\n    | \"number-plain\"\n    | \"number-id\"\n    | \"number-fk_id\"\n    | \"boolean\"\n    | \"enums\"\n    | \"array\"\n    | \"array-images\"\n    | \"json-sonamufile\"\n    | \"json-sonamufile-array\"\n    | \"object\"\n    | \"object-pick\"\n    | \"record\"\n    | \"vector\";\n  zodType: z.ZodTypeAny;\n  element?: RenderingNode;\n  children?: RenderingNode[];\n  config?: {\n    picked: string;\n  };\n  optional?: boolean;\n  nullable?: boolean;\n};\n\nconst GeneratedColumnSchema = z.object({\n  type: z.enum([\"STORED\", \"VIRTUAL\"]),\n  expression: z.string(),\n});\n\nconst BasePropFields = {\n  name: z.string(),\n  desc: z.string().optional(),\n  nullable: z.boolean().optional(),\n  toFilter: z.boolean().default(false).optional(),\n  dbDefault: z.union([z.string(), z.number(), z.boolean()]).optional(),\n  generated: GeneratedColumnSchema.optional(),\n};\n\n// 부가 필드가 필요없는 prop\nconst BasePropFieldsWithoutAdditional = z\n  .object({\n    ...BasePropFields,\n    type: z.union([\n      z.literal(\"integer\"),\n      z.literal(\"integer[]\"),\n      z.literal(\"bigInteger\"),\n      z.literal(\"bigInteger[]\"),\n      z.literal(\"boolean\"),\n      z.literal(\"boolean[]\"),\n      z.literal(\"uuid\"),\n      z.literal(\"uuid[]\"),\n      z.literal(\"tsvector\"),\n    ]),\n  })\n  .strict();\n\n// precision/scale 필드\nconst PrecisionScaleFields = {\n  precision: z.number().optional(),\n  scale: z.number().optional(),\n};\n\n// 각 타입별 스키마 정의\n\nconst StringPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"string\"),\n    length: z.number().optional(),\n  })\n  .strict();\nconst StringArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"string[]\"),\n    length: z.number().optional(),\n  })\n  .strict();\n\nconst EnumPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"enum\"),\n    id: z.string(),\n    length: z.number().optional(),\n  })\n  .strict();\nconst EnumArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"enum[]\"),\n    id: z.string(),\n  })\n  .strict();\n\nconst NumberPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"number\"),\n    ...PrecisionScaleFields,\n    numberType: z.enum([\"real\", \"double precision\", \"numeric\"]).optional(),\n  })\n  .strict();\nconst NumberArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"number[]\"),\n    ...PrecisionScaleFields,\n    numberType: z.enum([\"real\", \"double precision\", \"numeric\"]).optional(),\n  })\n  .strict();\n\nconst DatePropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"date\"),\n    precision: z.number().optional(),\n  })\n  .strict();\nconst DateArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"date[]\"),\n    precision: z.number().optional(),\n  })\n  .strict();\n\nconst NumericPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"numeric\"),\n    ...PrecisionScaleFields,\n  })\n  .strict();\nconst NumericArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"numeric[]\"),\n    ...PrecisionScaleFields,\n  })\n  .strict();\n\nconst JsonPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"json\"),\n    id: z.string(),\n  })\n  .strict();\n\nconst VirtualPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"virtual\"),\n    id: z.string(),\n    virtualType: z.enum([\"query\", \"code\"]).optional(),\n  })\n  .strict();\n\nconst VectorPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"vector\"),\n    dimensions: z.number(),\n  })\n  .strict();\nconst VectorArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"vector[]\"),\n    dimensions: z.number(),\n  })\n  .strict();\n\n// Relation 타입은 relationType에 따라 세분화\nconst BaseRelationFields = {\n  ...BasePropFields,\n  type: z.literal(\"relation\"),\n  with: z.string(),\n};\n\n// RelationOn 타입\nconst RelationOnSchema = z.enum([\"CASCADE\", \"SET NULL\", \"NO ACTION\", \"SET DEFAULT\", \"RESTRICT\"]);\n\nconst BelongsToOneRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"BelongsToOne\"),\n    customJoinClause: z.string().optional(),\n    useConstraint: z.boolean().optional(),\n    onUpdate: RelationOnSchema.optional(),\n    onDelete: RelationOnSchema.optional(),\n  })\n  .strict();\n\nconst HasManyRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"HasMany\"),\n    joinColumn: z.string(),\n    fromColumn: z.string().optional(),\n  })\n  .strict();\n\nconst ManyToManyRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"ManyToMany\"),\n    joinTable: z.string(),\n    onUpdate: RelationOnSchema,\n    onDelete: RelationOnSchema,\n  })\n  .strict();\n\nconst OneToOneRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"OneToOne\"),\n    customJoinClause: z.string().optional(),\n    hasJoinColumn: z.boolean().optional(),\n    useConstraint: z.boolean().optional(),\n    onUpdate: RelationOnSchema.optional(),\n    onDelete: RelationOnSchema.optional(),\n  })\n  .strict();\n\nconst RelationTypes = [\"BelongsToOne\", \"HasMany\", \"ManyToMany\", \"OneToOne\"] as const;\nexport const RelationPropSchema = z.discriminatedUnion(\n  \"relationType\",\n  [\n    BelongsToOneRelationPropSchema,\n    HasManyRelationPropSchema,\n    ManyToManyRelationPropSchema,\n    OneToOneRelationPropSchema,\n  ],\n  {\n    error: (iss) =>\n      `relationType은 ${RelationTypes.map((t) => `'${t}'`).join(\", \")} 중 하나여야 합니다. 입력값: \"${(iss.input as Record<string, unknown>)?.relationType}\"`,\n  },\n);\n\nconst NormalPropTypes = [\n  \"integer\",\n  \"integer[]\",\n  \"bigInteger\",\n  \"bigInteger[]\",\n  \"string\",\n  \"string[]\",\n  \"enum\",\n  \"enum[]\",\n  \"number\",\n  \"number[]\",\n  \"numeric\",\n  \"numeric[]\",\n  \"boolean\",\n  \"boolean[]\",\n  \"date\",\n  \"date[]\",\n  \"uuid\",\n  \"uuid[]\",\n  \"json\",\n  \"virtual\",\n  \"vector\",\n  \"vector[]\",\n  \"tsvector\",\n] as const;\n\n// VIRTUAL Generated Column에서 사용 불가능한 타입들\nconst VirtualGeneratedDisallowedTypes = [\n  \"json\",\n  \"vector\",\n  \"vector[]\",\n  \"string[]\",\n  \"integer[]\",\n  \"bigInteger[]\",\n  \"boolean[]\",\n  \"date[]\",\n  \"uuid[]\",\n  \"number[]\",\n  \"numeric[]\",\n  \"enum[]\",\n] as const;\n\nexport const NormalPropSchema = z\n  .discriminatedUnion(\n    \"type\",\n    [\n      BasePropFieldsWithoutAdditional,\n      StringPropSchema,\n      StringArrayPropSchema,\n      EnumPropSchema,\n      EnumArrayPropSchema,\n      NumberPropSchema,\n      NumberArrayPropSchema,\n      DatePropSchema,\n      DateArrayPropSchema,\n      NumericPropSchema,\n      NumericArrayPropSchema,\n      JsonPropSchema,\n      VirtualPropSchema,\n      VectorPropSchema,\n      VectorArrayPropSchema,\n    ],\n    {\n      error: (iss) =>\n        `type은 ${NormalPropTypes.map((t) => `'${t}'`).join(\", \")} 중 하나여야 합니다. 입력값: \"${(iss.input as Record<string, unknown>)?.type}\"`,\n    },\n  )\n  .superRefine((data, ctx) => {\n    if (!data.generated) {\n      return;\n    }\n\n    // dbDefault와 generated 동시 사용 불가\n    if (data.dbDefault !== undefined) {\n      ctx.addIssue({\n        code: \"custom\",\n        message: \"dbDefault와 generated는 함께 사용할 수 없습니다\",\n        path: [\"generated\"],\n      });\n    }\n\n    // virtual 타입은 generated 불가\n    if (data.type === \"virtual\") {\n      ctx.addIssue({\n        code: \"custom\",\n        message: \"virtual 타입은 generated column을 지원하지 않습니다\",\n        path: [\"generated\"],\n      });\n    }\n\n    // VIRTUAL Generated Column 타입 제한 검증\n    if (data.generated.type === \"VIRTUAL\") {\n      if ((VirtualGeneratedDisallowedTypes as readonly string[]).includes(data.type)) {\n        ctx.addIssue({\n          code: \"custom\",\n          message: `VIRTUAL generated column은 ${data.type} 타입을 지원하지 않습니다. STORED를 사용하세요.`,\n          path: [\"generated\", \"type\"],\n          fatal: true,\n        });\n      }\n    }\n  });\n\nconst AllPropTypes = [...NormalPropTypes, \"relation\"] as const;\nconst EntityPropSchema = z.discriminatedUnion(\"type\", [NormalPropSchema, RelationPropSchema], {\n  error: (iss) =>\n    `type은 ${AllPropTypes.map((t) => `'${t}'`).join(\", \")} 중 하나여야 합니다. 입력값: \"${(iss.input as Record<string, unknown>)?.type}\"`,\n});\n\nconst EntityIndexColumnSchema = z.object({\n  name: z.string(),\n  nullsFirst: z.boolean().optional(),\n  sortOrder: z.enum([\"ASC\", \"DESC\"]).optional(),\n  vectorOps: z.enum([\"vector_cosine_ops\", \"vector_ip_ops\", \"vector_l2_ops\"]).optional(),\n});\n\n// EntityIndex 스키마 정의\nconst EntityIndexSchema = z\n  .object({\n    type: z.enum([\"index\", \"unique\", \"hnsw\", \"ivfflat\"]),\n    columns: z.array(EntityIndexColumnSchema),\n    name: z.string().min(1).max(63),\n    using: z.enum([\"btree\", \"hash\", \"gin\", \"gist\", \"pgroonga\"]).optional(),\n    nullsNotDistinct: z.boolean().optional(),\n    m: z.number().optional(),\n    efConstruction: z.number().optional(),\n    lists: z.number().optional(),\n  })\n  .strict();\n\nexport const EntityJsonSchema = z\n  .object({\n    id: z.string().describe(\"PascalCase로 된 Entity ID\"),\n    title: z.string().describe(\"Entity 이름\"),\n    table: z.string().describe(\"snake_case로 된 테이블명\"),\n    parentId: z.string().optional().describe(\"부모 Entity ID\"),\n    props: z.array(EntityPropSchema),\n    indexes: z.array(EntityIndexSchema),\n    subsets: z.record(\n      z.string(),\n      z.array(\n        z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })]),\n      ),\n    ),\n    enums: z.record(z.string(), z.record(z.string(), z.string())),\n  })\n  .strict();\n\nexport const TemplateOptions = z.object({\n  entity: EntityJsonSchema.omit({ id: true })\n    .extend({\n      entityId: z.string(),\n    })\n    .partial({\n      table: true,\n      props: true,\n      indexes: true,\n      subsets: true,\n      enums: true,\n    }),\n  init_types: z.object({\n    entityId: z.string(),\n  }),\n  generated: z.object({}),\n  generated_sso: z.object({}),\n  generated_http: z.object({\n    entityId: z.string(),\n  }),\n  model: z.object({\n    entityId: z.string(),\n    defaultSearchField: z.string().optional(),\n    defaultOrderBy: z.string().optional(),\n  }),\n  model_test: z.object({\n    entityId: z.string(),\n  }),\n  bridge: z.object({\n    entityId: z.string(),\n  }),\n  services: z.object({}),\n  view_list: z.object({\n    entityId: z.string(),\n    extra: z.unknown(),\n  }),\n  view_list_columns: z.object({\n    entityId: z.string(),\n    columns: z\n      .object({\n        name: z.string(),\n        label: z.string(),\n        tc: z.string(),\n      })\n      .array(),\n    columnImports: z.string(),\n  }),\n  view_search_input: z.object({\n    entityId: z.string(),\n  }),\n  view_form: z.object({\n    entityId: z.string(),\n  }),\n  view_id_all_select: z.object({\n    entityId: z.string(),\n  }),\n  view_id_async_select: z.object({\n    entityId: z.string(),\n    textField: z.string(),\n  }),\n  view_enums_select: z.object({\n    entityId: z.string(),\n    enumId: z.string(),\n  }),\n  view_enums_buttonset: z.object({\n    entityId: z.string(),\n    enumId: z.string(),\n  }),\n  queries: z.object({}),\n  entry_server: z.object({}),\n  sd: z.object({\n    target: z.enum([\"api\", \"web\", \"app\"]),\n  }),\n});\nexport type TemplateOptions = z.infer<typeof TemplateOptions>;\n\nexport const TemplateKey = z.enum([\n  \"entity\",\n  \"init_types\",\n  \"generated\",\n  \"generated_sso\",\n  \"generated_http\",\n  \"model\",\n  \"model_test\",\n  \"bridge\",\n  \"services\",\n  \"view_list\",\n  \"view_list_columns\",\n  \"view_search_input\",\n  \"view_form\",\n  \"view_id_all_select\",\n  \"view_id_async_select\",\n  \"view_enums_select\",\n  \"view_enums_buttonset\",\n  \"queries\",\n  \"entry_server\",\n  \"sd\",\n]);\nexport type TemplateKey = z.infer<typeof TemplateKey>;\n\nexport const GenerateOptions = z.object({\n  overwrite: z.boolean().optional(),\n});\nexport type GenerateOptions = z.infer<typeof GenerateOptions>;\n\nexport const PathAndCode = z.object({\n  path: z.string(),\n  code: z.string(),\n});\nexport type PathAndCode = z.infer<typeof PathAndCode>;\n\nexport type FixtureSearchOptions = {\n  entityId: string;\n  field: string;\n  value: string;\n  searchType: \"equals\" | \"like\";\n};\n\ntype ColumnValue = string | number | boolean | Date | null;\nexport type FixtureRecord = {\n  fixtureId: string;\n  entityId: string;\n  id: number;\n  columns: {\n    [key: string]: {\n      prop: EntityProp;\n      value: ColumnValue | ColumnValue[];\n    };\n  };\n  fetchedRecords: string[];\n  belongsRecords: string[];\n  target?: FixtureRecord; // Import 대상 DB 레코드(id가 같은)\n  unique?: FixtureRecord; // Import 대상 DB 레코드(unique key가 같은)\n  override?: boolean;\n};\n\nexport type FixtureImportResult = {\n  entityId: string;\n  data: {\n    [key: string]: ColumnValue;\n  };\n};\n\nexport type RelationNode = {\n  fixtureId: string;\n  entityId: string;\n  related: Set<string>;\n};\n\n// biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스\nexport interface DatabaseSchemaExtend {}\n// biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스\nexport interface DatabaseForeignKeys {}\nexport type ManyToManyBaseSchema<FromIdKey extends string, ToIdKey extends string> = {\n  id: number;\n} & {\n  [K in `${FromIdKey}_id`]: number;\n} & {\n  [K in `${ToIdKey}_id`]: number;\n};\n\n// 객체, 함수, 비동기 함수를 모두 포괄하는 타입\nexport type Executable<T> = T | Promise<T> | (() => T) | (() => Promise<T>);\n\nexport type SonamuFastifyConfig = {\n  contextProvider: (\n    defaultContext: Pick<\n      Context,\n      \"request\" | \"reply\" | \"headers\" | \"createSSE\" | \"naiteStore\" | \"locale\" | \"user\" | \"session\"\n    >,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ) => Context | Promise<Context>;\n  guardHandler: (\n    guard: GuardKey,\n    request: FastifyRequest,\n    api: {\n      typeParameters: ApiParamType.TypeParam[];\n      parameters: ApiParam[];\n      returnType: ApiParamType;\n      modelName: string;\n      methodName: string;\n      path: string;\n      options: ApiDecoratorOptions;\n    },\n  ) => void;\n  /**\n   * 전역 Cache-Control 핸들러입니다.\n   * 요청 타입(api, assets, ssr, csr)에 따라 Cache-Control 설정을 반환합니다.\n   * undefined를 반환하면 타입별 기본값이 적용됩니다.\n   */\n  cacheControlHandler?: CacheControlHandler;\n};\n"],"names":["z","zArrayable","shape","union","array","SonamuFileSchema","object","name","string","url","mime_type","size","number","describe","SonamuFileArraySchema","BUILT_IN_TYPE_IDS","normalizeSubsetField","f","field","isInternalSubsetField","internal","isIntegerSingleProp","p","type","isIntegerArrayProp","isIntegerProp","isBigIntegerSingleProp","isBigIntegerArrayProp","isBigIntegerProp","isStringSingleProp","isStringArrayProp","isStringProp","isEnumSingleProp","isEnumArrayProp","isEnumProp","isNumberSingleProp","isNumberArrayProp","isNumberProp","isNumericSingleProp","isNumericArrayProp","isNumericProp","isBooleanSingleProp","isBooleanArrayProp","isBooleanProp","isDateSingleProp","isDateArrayProp","isDateProp","isUuidSingleProp","isUuidArrayProp","isUuidProp","isJsonProp","isVirtualProp","isVirtualCodeProp","virtualType","isVirtualQueryProp","isVectorSingleProp","isVectorArrayProp","isVectorProp","isTsVectorProp","isRelationProp","isOneToOneRelationProp","relationType","isBelongsToOneRelationProp","isHasManyRelationProp","isManyToManyRelationProp","isCustomJoinClause","custom","SonamuQueryMode","enum","SonamuSemanticParams","semanticQuery","embedding","min","max","threshold","optional","method","isKnexError","e","code","sqlMessage","sqlState","ApiParamType","isObject","v","t","isUnion","isIntersection","isStringLiteral","isNumericLiteral","isArray","isRef","isIndexedAccess","isTupleType","isPick","id","isOmit","isPartial","isPromise","isContext","isRefKnex","isTypeParam","RenderingNode","any","GeneratedColumnSchema","expression","BasePropFields","desc","nullable","boolean","toFilter","default","dbDefault","generated","BasePropFieldsWithoutAdditional","literal","strict","PrecisionScaleFields","precision","scale","StringPropSchema","length","StringArrayPropSchema","EnumPropSchema","EnumArrayPropSchema","NumberPropSchema","numberType","NumberArrayPropSchema","DatePropSchema","DateArrayPropSchema","NumericPropSchema","NumericArrayPropSchema","JsonPropSchema","VirtualPropSchema","VectorPropSchema","dimensions","VectorArrayPropSchema","BaseRelationFields","with","RelationOnSchema","BelongsToOneRelationPropSchema","customJoinClause","useConstraint","onUpdate","onDelete","HasManyRelationPropSchema","joinColumn","fromColumn","ManyToManyRelationPropSchema","joinTable","OneToOneRelationPropSchema","hasJoinColumn","RelationTypes","RelationPropSchema","discriminatedUnion","error","iss","map","join","input","NormalPropTypes","VirtualGeneratedDisallowedTypes","NormalPropSchema","superRefine","data","ctx","undefined","addIssue","message","path","includes","fatal","AllPropTypes","EntityPropSchema","EntityIndexColumnSchema","nullsFirst","sortOrder","vectorOps","EntityIndexSchema","columns","using","nullsNotDistinct","m","efConstruction","lists","EntityJsonSchema","title","table","parentId","props","indexes","subsets","record","enums","TemplateOptions","entity","omit","extend","entityId","partial","init_types","generated_sso","generated_http","model","defaultSearchField","defaultOrderBy","model_test","bridge","services","view_list","extra","unknown","view_list_columns","label","tc","columnImports","view_search_input","view_form","view_id_all_select","view_id_async_select","textField","view_enums_select","enumId","view_enums_buttonset","queries","entry_server","sd","target","TemplateKey","GenerateOptions","overwrite","PathAndCode"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/types/types.ts"],"sourcesContent":["import type { FastifyReply, FastifyRequest } from \"fastify\";\nimport { z } from \"zod\";\nimport type { ApiDecoratorOptions, Context } from \"../api\";\nimport type { GuardKey } from \"./../api/decorators\";\nimport type { CacheControlHandler } from \"../cache-control/types\";\n\n/*\n  Utility Types\n*/\nexport function zArrayable<T extends z.ZodTypeAny>(shape: T): z.ZodUnion<[T, z.ZodArray<T>]> {\n  return z.union([shape, shape.array()]);\n}\n// biome-ignore lint/suspicious/noExplicitAny: any is used to make the type distributive\nexport type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;\n\n/*\n  Model-Definition\n*/\n\n/**\n * cone: 범용 메타데이터 시스템\n *\n * Entity, Prop, Enum, Subset에 추가할 수 있는 범용 메타데이터입니다.\n * Fixture 생성, UI 라벨, 문서화 등 다양한 용도로 활용할 수 있습니다.\n */\nexport type Cone = {\n  // 일반 정보\n  desc?: string; // 짧은 설명 (UI 라벨용)\n  note?: string; // 자유로운 메모 (무제한 길이)\n  tags?: string[]; // 분류/검색용 태그\n\n  // Fixture 생성 관련\n  fixtureHint?: string; // 생성 힌트 (무제한 길이, 짧은 패턴 또는 긴 설명 가능)\n  fixtureGenerator?: string; // Faker.js 코드 또는 커스텀 함수\n  fixtureDefault?: unknown; // 기본값\n\n  // 참조 데이터 관련\n  dataSource?: {\n    strategy: \"sample\" | \"ids\" | \"query\" | \"file\" | \"recent\" | \"random\";\n    config?: unknown; // 전략별 설정\n  };\n\n  // 확장성\n  [key: string]: unknown; // 사용자 정의 메타데이터\n};\n\nexport type GeneratedColumnType = \"STORED\" | \"VIRTUAL\";\nexport type GeneratedColumn = {\n  type: GeneratedColumnType;\n  expression: string;\n};\nexport type CommonProp = {\n  name: string;\n  nullable?: boolean;\n  toFilter?: true;\n  desc?: string;\n  dbDefault?: string;\n  generated?: GeneratedColumn;\n  cone?: Cone; // cone 메타데이터\n};\n\n/**\n * 하위 호환성을 위한 헬퍼 함수\n *\n * desc 필드와 cone.desc 둘 다 지원합니다.\n * cone.desc가 있으면 우선적으로 사용하고, 없으면 desc를 사용합니다.\n */\nexport function getDescription(item: { desc?: string; cone?: Cone }): string | undefined {\n  return item.cone?.desc || item.desc;\n}\nexport type IntegerProp = CommonProp & {\n  type: \"integer\";\n}; // PG: integer / TS: number / JSON: number\nexport type IntegerArrayProp = CommonProp & {\n  type: \"integer[]\";\n}; // PG: integer[] / TS: number[] / JSON: number[]\nexport type BigIntegerProp = CommonProp & {\n  type: \"bigInteger\";\n}; // PG: bigint / TS: bigint / JSON: bigint\nexport type BigIntegerArrayProp = CommonProp & {\n  type: \"bigInteger[]\";\n}; // PG: bigint[] / TS: bigint[] / JSON: bigint[]\n\n/**\n * Zod 4 String Format 타입\n * entity.json에서 string 타입의 prop에 zodFormat 옵션을 지정하여\n * BaseSchema 생성 시 Zod의 string format validation을 적용합니다.\n */\nexport const ZodStringFormat = z.enum([\n  // 기본 포맷\n  \"email\",\n  \"uuid\",\n  \"url\",\n  \"httpUrl\",\n  \"hostname\",\n  \"emoji\",\n  \"base64\",\n  \"base64url\",\n  \"hex\",\n  \"jwt\",\n  \"nanoid\",\n  \"cuid\",\n  \"cuid2\",\n  \"ulid\",\n  \"ipv4\",\n  \"ipv6\",\n  \"mac\",\n  \"cidrv4\",\n  \"cidrv6\",\n  // hash 포맷 (알고리즘별)\n  \"hashMd5\",\n  \"hashSha1\",\n  \"hashSha256\",\n  \"hashSha384\",\n  \"hashSha512\",\n  // ISO 포맷\n  \"isoDate\",\n  \"isoTime\",\n  \"isoDatetime\",\n  \"isoDuration\",\n]);\nexport type ZodStringFormat = z.infer<typeof ZodStringFormat>;\n\nexport type StringProp = CommonProp & {\n  type: \"string\";\n  length?: number; // PG: varchar(n), text / TS: string / JSON: string\n  zodFormat?: ZodStringFormat;\n}; // PG: text / TS: string / JSON: string\nexport type StringArrayProp = CommonProp & {\n  type: \"string[]\";\n  length?: number; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]\n  zodFormat?: ZodStringFormat;\n}; // PG: varchar(n)[], text[] / TS: string[] / JSON: string[]\nexport type EnumProp = CommonProp & {\n  type: \"enum\";\n  id: string;\n  length?: number;\n}; // PG: text / TS: string / JSON: string\nexport type EnumArrayProp = CommonProp & {\n  type: \"enum[]\";\n  id: string;\n}; // PG: text[] / TS: string[] / JSON: string[]\nexport type NumberProp = CommonProp & {\n  type: \"number\";\n  precision?: number; // PG: numeric(p, s) / TS: number / JSON: number\n  scale?: number; // PG: numeric(p, s) / TS: number / JSON: number\n  numberType?: \"real\" | \"double precision\" | \"numeric\"; // 기본값: numeric\n}; // PG: numeric(p, s) / TS: number / JSON: number\nexport type NumberArrayProp = CommonProp & {\n  type: \"number[]\";\n  precision?: number;\n  scale?: number;\n  numberType?: \"real\" | \"double precision\" | \"numeric\"; // 기본값: numeric\n}; // PG: numeric(p, s)[] / TS: number[] / JSON: number[]\nexport type NumericProp = CommonProp & {\n  type: \"numeric\";\n  precision?: number;\n  scale?: number;\n}; // PG: numeric(p, s) / TS: string / JSON: string\nexport type NumericArrayProp = CommonProp & {\n  type: \"numeric[]\";\n  precision?: number;\n  scale?: number;\n}; // PG: numeric(p, s)[] / TS: string[] / JSON: string[]\nexport type BooleanProp = CommonProp & {\n  type: \"boolean\";\n}; // PG: boolean / TS: boolean / JSON: boolean\nexport type BooleanArrayProp = CommonProp & {\n  type: \"boolean[]\";\n}; // PG: boolean[] / TS: boolean[] / JSON: boolean[]\nexport type DateProp = CommonProp & {\n  type: \"date\";\n  // 기본값은 3, microseconds를 쓰려면 6을 써야함 (0 ~ 6)\n  precision?: number;\n}; // PG: timestampz / TS: Date / JSON: string(ISOString)\nexport type DateArrayProp = CommonProp & {\n  type: \"date[]\";\n  // 기본값은 3, microseconds를 쓰려면 6을 써야함 (0 ~ 6)\n  precision?: number;\n}; // PG: timestamptz[] / TS: Date[] / JSON: string[]\nexport type JsonProp = CommonProp & {\n  type: \"json\";\n  id: string;\n}; // PG: json / TS: any(id) / JSON: any\nexport type UuidProp = CommonProp & {\n  type: \"uuid\";\n}; // PG: uuid / TS: string / JSON: string\nexport type UuidArrayProp = CommonProp & {\n  type: \"uuid[]\";\n}; // PG: uuid[] / TS: string[] / JSON: string[]\nexport type VirtualProp = CommonProp & {\n  type: \"virtual\";\n  id: string;\n  virtualType?: \"query\" | \"code\"; // default: \"code\"\n}; // PG: none / TS: any(id) / JSON: any\nexport type VectorProp = CommonProp & {\n  type: \"vector\";\n  dimensions: number;\n};\nexport type VectorArrayProp = CommonProp & {\n  type: \"vector[]\";\n  dimensions: number;\n};\nexport type TsVectorProp = CommonProp & {\n  type: \"tsvector\";\n};\nexport type RelationType = \"HasMany\" | \"BelongsToOne\" | \"ManyToMany\" | \"OneToOne\";\nexport type RelationOn = \"CASCADE\" | \"SET NULL\" | \"NO ACTION\" | \"SET DEFAULT\" | \"RESTRICT\";\ntype _RelationProp = {\n  type: \"relation\";\n  name: string;\n  with: string;\n  nullable?: boolean; // DEFAULT: false\n  toFilter?: true; // DEFAULT: false\n  desc?: string;\n  cone?: Cone; // cone 메타데이터\n};\nexport type OneToOneRelationProp = _RelationProp & {\n  relationType: \"OneToOne\";\n  customJoinClause?: string;\n} & (\n    | {\n        hasJoinColumn: true;\n        useConstraint?: boolean; // DEFAULT: true\n        onUpdate?: RelationOn; // DEFAULT: RESTRICT\n        onDelete?: RelationOn; // DEFAULT: RESTRICT\n      }\n    | {\n        hasJoinColumn: false;\n      }\n  );\nexport type BelongsToOneRelationProp = _RelationProp & {\n  relationType: \"BelongsToOne\";\n  customJoinClause?: string;\n  useConstraint?: boolean; // DEFAULT: true\n  onUpdate?: RelationOn; // DEFAULT: RESTRICT\n  onDelete?: RelationOn; // DEFAULT: RESTRICT\n};\nexport type HasManyRelationProp = _RelationProp & {\n  relationType: \"HasMany\";\n  joinColumn: string;\n  fromColumn?: string;\n};\nexport type ManyToManyRelationProp = _RelationProp & {\n  relationType: \"ManyToMany\";\n  joinTable: `${string}__${string}`;\n  onUpdate: RelationOn;\n  onDelete: RelationOn;\n};\nexport type RelationProp =\n  | OneToOneRelationProp\n  | BelongsToOneRelationProp\n  | HasManyRelationProp\n  | ManyToManyRelationProp;\n\nexport type EntityProp =\n  | IntegerProp\n  | IntegerArrayProp\n  | BigIntegerProp\n  | BigIntegerArrayProp\n  | StringProp\n  | StringArrayProp\n  | EnumProp\n  | EnumArrayProp\n  | NumberProp\n  | NumberArrayProp\n  | NumericProp\n  | NumericArrayProp\n  | NumericProp\n  | BooleanProp\n  | BooleanArrayProp\n  | DateProp\n  | DateArrayProp\n  | UuidProp\n  | UuidArrayProp\n  | JsonProp\n  | VirtualProp\n  | VectorProp\n  | VectorArrayProp\n  | TsVectorProp\n  | RelationProp;\n\n/**\n * SonamuFile Types\n *\n * 파일 업로드를 위한 JSON 타입입니다.\n * Entity의 json 속성에서 id로 \"SonamuFile\" 또는 \"SonamuFile[]\"을 지정하여 사용합니다.\n */\nexport interface SonamuFile {\n  name: string;\n  url: string;\n  mime_type: string;\n  size: number;\n}\n\nexport const SonamuFileSchema = z\n  .object({\n    name: z.string(),\n    url: z.string(),\n    mime_type: z.string(),\n    size: z.number(),\n  })\n  .describe(\"SonamuFile\");\n\nexport const SonamuFileArraySchema = z.array(SonamuFileSchema).describe(\"SonamuFile[]\");\n\n/**\n * Sonamu 코어에서 제공하는 내장 JSON 타입 ID 목록\n * 새로운 내장 타입 추가 시 이 배열에 추가하면 자동으로 UI에 노출됩니다.\n */\nexport const BUILT_IN_TYPE_IDS = [\"SonamuFile\", \"SonamuFile[]\"] as const;\nexport type BuiltInTypeId = (typeof BUILT_IN_TYPE_IDS)[number];\n\n/**\n * pgvector 거리 연산자 클래스\n *\n * @description\n * - `vector_cosine_ops`: 코사인 거리 (Cosine Distance) - 권장\n *   - SQL 연산자: `<=>`\n *   - 벡터의 방향만 비교 (크기 무시), 1 - cosine_similarity\n *   - 텍스트 임베딩, 시맨틱 검색에 가장 일반적으로 사용\n *   - 사용 예: OpenAI, Voyage 등 대부분의 임베딩 모델에 권장\n *\n * - `vector_ip_ops`: 내적 (Inner Product)\n *   - SQL 연산자: `<#>`\n *   - 두 벡터의 내적을 계산 (sum(a[i] * b[i]))\n *   - 정규화된 벡터에서 코사인 유사도와 동일한 결과\n *   - 값이 클수록 유사 (음수 연산자이므로 ORDER BY에서 주의)\n *   - 사용 예: 이미 정규화된 임베딩에서 가장 빠른 성능\n *\n * - `vector_l2_ops`: 유클리드 거리 (L2 Distance)\n *   - SQL 연산자: `<->`\n *   - 두 벡터 간의 직선 거리를 계산 (sqrt(sum((a[i] - b[i])^2)))\n *   - 벡터의 크기(magnitude)가 중요할 때 사용\n *   - 사용 예: 이미지 유사도, 절대적 거리 측정이 필요한 경우\n */\nexport type VectorOps = \"vector_cosine_ops\" | \"vector_ip_ops\" | \"vector_l2_ops\";\n\ntype EntityIndexColumn = {\n  name: string;\n  nullsFirst?: boolean;\n  sortOrder?: \"ASC\" | \"DESC\";\n  /** pgvector 인덱스에서 사용할 거리 연산자 (vector 컬럼에만 적용) */\n  vectorOps?: VectorOps;\n};\nexport type EntityIndex = {\n  type: \"index\" | \"unique\" | \"hnsw\" | \"ivfflat\";\n  columns: EntityIndexColumn[];\n  name: string;\n  using?: \"btree\" | \"hash\" | \"gin\" | \"gist\" | \"pgroonga\";\n  nullsNotDistinct?: boolean; // unique index only\n  /**\n   * HNSW (Hierarchical Navigable Small World) 인덱스: 각 노드의 최대 연결 수\n   *\n   * @description\n   * 그래프에서 각 노드가 가질 수 있는 최대 연결 수입니다.\n   * HNSW는 빠른 검색 속도와 높은 정확도를 제공하므로 권장됩니다.\n   * - 기본값: 16\n   * - 범위: 2 ~ 100\n   * - 높을수록: 정확도↑, 빌드 시간↑, 메모리↑\n   * - 권장: 빠른 빌드(8), 균형(16), 높은 정확도(32), 최고 정확도(64)\n   */\n  m?: number;\n  /**\n   * HNSW (Hierarchical Navigable Small World) 인덱스: 구성 시 탐색 범위\n   *\n   * @description\n   * 인덱스 구성 시 각 노드에서 탐색할 범위입니다.\n   * - 기본값: 64\n   * - 범위: 4 ~ 1000\n   * - 높을수록: 정확도↑, 빌드 시간↑\n   * - 권장: 빠른 빌드(32), 균형(64), 높은 정확도(128), 최고 정확도(256)\n   */\n  efConstruction?: number;\n  /**\n   * IVFFlat (Inverted File with Flat Compression) 인덱스: 클러스터링 리스트 수\n   *\n   * @description\n   * 벡터를 클러스터링할 버킷 수를 지정합니다.\n   * IVFFlat은 빠른 빌드와 낮은 메모리 사용이 필요할 때 사용합니다.\n   * - 권장값: sqrt(row_count) ~ row_count / 1000\n   * - 예시: 10,000행 → 100, 100,000행 → 300, 1,000,000행 → 1000\n   * - 많을수록 정확도↑, 검색 속도↓\n   */\n  lists?: number;\n};\n\n// SubsetField 타입: string 또는 internal 옵션이 있는 객체\nexport type SubsetField = string | { field: string; internal?: boolean };\n\nexport function normalizeSubsetField(f: SubsetField): string {\n  return typeof f === \"string\" ? f : f.field;\n}\nexport function isInternalSubsetField(f: SubsetField): boolean {\n  return typeof f !== \"string\" && f.internal === true;\n}\n\n/**\n * SubsetDef: Subset 정의\n *\n * 하위 호환성을 위해 SubsetField[] 배열 형태도 지원합니다.\n */\nexport type SubsetDef =\n  | SubsetField[] // 기존 배열 형태\n  | {\n      // 새로운 객체 형태\n      fields: SubsetField[];\n      cone?: Cone;\n    };\n\n/**\n * EnumDef: Enum 정의\n *\n * 하위 호환성을 위해 Record<string, string> 형태도 지원합니다.\n */\nexport type EnumDef =\n  | Record<string, string> // 기존 Record 형태\n  | {\n      // 새로운 객체 형태\n      values: Record<string, string>;\n      cone?: Cone;\n    };\n\n/**\n * SubsetDef가 새로운 객체 형태인지 확인\n */\nexport function isSubsetDefWithCone(def: SubsetDef): def is { fields: SubsetField[]; cone?: Cone } {\n  return !Array.isArray(def) && \"fields\" in def;\n}\n\n/**\n * EnumDef가 새로운 객체 형태인지 확인\n */\nexport function isEnumDefWithCone(\n  def: EnumDef,\n): def is { values: Record<string, string>; cone?: Cone } {\n  return (\n    \"values\" in def && !(\"cone\" in def && def.cone === undefined && Object.keys(def).length > 1)\n  );\n}\n\n/**\n * SubsetDef에서 fields 추출\n */\nexport function getSubsetFields(def: SubsetDef): SubsetField[] {\n  return Array.isArray(def) ? def : def.fields;\n}\n\n/**\n * EnumDef에서 values 추출\n */\nexport function getEnumDefValues(def: EnumDef): Record<string, string> {\n  return isEnumDefWithCone(def) ? def.values : def;\n}\n\nexport type EntityJson = {\n  id: string;\n  parentId?: string;\n  table: string;\n  title?: string;\n  cone?: Cone; // cone 메타데이터\n  props: EntityProp[];\n  indexes: EntityIndex[];\n  subsets: {\n    [subset: string]: SubsetDef;\n  };\n  enums: {\n    [enumId: string]: EnumDef;\n  };\n};\nexport type EntitySubsetRow = {\n  field: string;\n  has: {\n    [key: string]: boolean;\n  };\n  isInternal: {\n    [key: string]: boolean;\n  };\n  children: EntitySubsetRow[];\n  prefixes: string[];\n  relationEntity?: string;\n  isOpen?: boolean;\n};\nexport type FlattenSubsetRow = Omit<EntitySubsetRow, \"children\">;\n\n/*\n  PropNode\n*/\n\n/**\n * 엔티티의 필드 구조를 트리 형태로 표현하는 중간 노드입니다.\n *\n * **목적**: Entity의 subset 필드 표현식(예: \"id\", \"user.name\", \"tags[]\")을\n * 재귀적인 트리 구조로 파싱하여 Zod 스키마 생성의 중간 단계로 사용합니다.\n *\n * **변환 흐름**:\n * Entity subset → EntityPropNode (트리 구조) → Zod 스키마 → RenderingNode (UI용)\n *\n * **nodeType**:\n * - \"plain\": 단일 필드 (예: \"id\", \"name\")\n * - \"object\": 중첩 객체 (예: \"user.name\" → user 객체)\n * - \"array\": 배열 (예: \"tags[]\" → tags 배열)\n *\n * **사용 위치**: entity-converter.ts의 propNodeToZodType()\n */\nexport type EntityPropNode =\n  | {\n      nodeType: \"plain\";\n      prop: EntityProp;\n    }\n  | {\n      nodeType: \"object\" | \"array\";\n      prop?: EntityProp;\n      children: EntityPropNode[];\n    };\n\n/*\n  Prop Type Guards\n*/\nexport function isIntegerSingleProp(p: unknown): p is IntegerProp {\n  return (p as IntegerProp)?.type === \"integer\";\n}\nexport function isIntegerArrayProp(p: unknown): p is IntegerArrayProp {\n  return (p as IntegerArrayProp)?.type === \"integer[]\";\n}\nexport function isIntegerProp(p: unknown): p is IntegerProp | IntegerArrayProp {\n  return isIntegerSingleProp(p) || isIntegerArrayProp(p);\n}\nexport function isBigIntegerSingleProp(p: unknown): p is BigIntegerProp {\n  return (p as BigIntegerProp)?.type === \"bigInteger\";\n}\nexport function isBigIntegerArrayProp(p: unknown): p is BigIntegerArrayProp {\n  return (p as BigIntegerArrayProp)?.type === \"bigInteger[]\";\n}\nexport function isBigIntegerProp(p: unknown): p is BigIntegerProp | BigIntegerArrayProp {\n  return isBigIntegerSingleProp(p) || isBigIntegerArrayProp(p);\n}\nexport function isStringSingleProp(p: unknown): p is StringProp {\n  return (p as StringProp)?.type === \"string\";\n}\nexport function isStringArrayProp(p: unknown): p is StringArrayProp {\n  return (p as StringArrayProp)?.type === \"string[]\";\n}\nexport function isStringProp(p: unknown): p is StringProp | StringArrayProp {\n  return isStringSingleProp(p) || isStringArrayProp(p);\n}\nexport function isEnumSingleProp(p: unknown): p is EnumProp {\n  return (p as EnumProp)?.type === \"enum\";\n}\nexport function isEnumArrayProp(p: unknown): p is EnumArrayProp {\n  return (p as EnumArrayProp)?.type === \"enum[]\";\n}\nexport function isEnumProp(p: unknown): p is EnumProp | EnumArrayProp {\n  return isEnumSingleProp(p) || isEnumArrayProp(p);\n}\nexport function isNumberSingleProp(p: unknown): p is NumberProp {\n  return (p as NumberProp)?.type === \"number\";\n}\nexport function isNumberArrayProp(p: unknown): p is NumberArrayProp {\n  return (p as NumberArrayProp)?.type === \"number[]\";\n}\nexport function isNumberProp(p: unknown): p is NumberProp | NumberArrayProp {\n  return isNumberSingleProp(p) || isNumberArrayProp(p);\n}\nexport function isNumericSingleProp(p: unknown): p is NumericProp {\n  return (p as NumericProp)?.type === \"numeric\";\n}\nexport function isNumericArrayProp(p: unknown): p is NumericArrayProp {\n  return (p as NumericArrayProp)?.type === \"numeric[]\";\n}\nexport function isNumericProp(p: unknown): p is NumericProp | NumericArrayProp {\n  return isNumericSingleProp(p) || isNumericArrayProp(p);\n}\nexport function isBooleanSingleProp(p: unknown): p is BooleanProp {\n  return (p as BooleanProp)?.type === \"boolean\";\n}\nexport function isBooleanArrayProp(p: unknown): p is BooleanArrayProp {\n  return (p as BooleanArrayProp)?.type === \"boolean[]\";\n}\nexport function isBooleanProp(p: unknown): p is BooleanProp | BooleanArrayProp {\n  return isBooleanSingleProp(p) || isBooleanArrayProp(p);\n}\nexport function isDateSingleProp(p: unknown): p is DateProp {\n  return (p as DateProp)?.type === \"date\";\n}\nexport function isDateArrayProp(p: unknown): p is DateArrayProp {\n  return (p as DateArrayProp)?.type === \"date[]\";\n}\nexport function isDateProp(p: unknown): p is DateProp | DateArrayProp {\n  return isDateSingleProp(p) || isDateArrayProp(p);\n}\nexport function isUuidSingleProp(p: unknown): p is UuidProp {\n  return (p as UuidProp)?.type === \"uuid\";\n}\nexport function isUuidArrayProp(p: unknown): p is UuidArrayProp {\n  return (p as UuidArrayProp)?.type === \"uuid[]\";\n}\nexport function isUuidProp(p: unknown): p is UuidProp | UuidArrayProp {\n  return isUuidSingleProp(p) || isUuidArrayProp(p);\n}\nexport function isJsonProp(p: unknown): p is JsonProp {\n  return (p as JsonProp)?.type === \"json\";\n}\nexport function isVirtualProp(p: unknown): p is VirtualProp {\n  return (p as VirtualProp)?.type === \"virtual\";\n}\nexport function isVirtualCodeProp(p: unknown): p is VirtualProp {\n  if (!isVirtualProp(p)) return false;\n  return p.virtualType !== \"query\"; // undefined도 \"code\"로 취급\n}\nexport function isVirtualQueryProp(p: unknown): p is VirtualProp {\n  if (!isVirtualProp(p)) return false;\n  return p.virtualType === \"query\";\n}\nexport function isVectorSingleProp(p: unknown): p is VectorProp {\n  return (p as VectorProp)?.type === \"vector\";\n}\nexport function isVectorArrayProp(p: unknown): p is VectorArrayProp {\n  return (p as VectorArrayProp)?.type === \"vector[]\";\n}\nexport function isVectorProp(p: unknown): p is VectorProp | VectorArrayProp {\n  return isVectorSingleProp(p) || isVectorArrayProp(p);\n}\nexport function isTsVectorProp(p: unknown): p is TsVectorProp {\n  return (p as TsVectorProp)?.type === \"tsvector\";\n}\nexport function isRelationProp(p: unknown): p is RelationProp {\n  return (p as RelationProp)?.type === \"relation\";\n}\nexport function isOneToOneRelationProp(p: unknown): p is OneToOneRelationProp {\n  return (p as OneToOneRelationProp)?.relationType === \"OneToOne\";\n}\nexport function isBelongsToOneRelationProp(p: unknown): p is BelongsToOneRelationProp {\n  return (p as BelongsToOneRelationProp)?.relationType === \"BelongsToOne\";\n}\nexport function isHasManyRelationProp(p: unknown): p is HasManyRelationProp {\n  return (p as HasManyRelationProp)?.relationType === \"HasMany\";\n}\nexport function isManyToManyRelationProp(p: unknown): p is ManyToManyRelationProp {\n  return (p as ManyToManyRelationProp)?.relationType === \"ManyToMany\";\n}\n\ntype JoinClause =\n  | {\n      from: string;\n      to: string;\n    }\n  | {\n      custom: string;\n    };\nexport function isCustomJoinClause(p: unknown): p is { custom: string } {\n  return !!(p as { custom: string })?.custom;\n}\n\ntype SubsetLoader = {\n  as: string;\n  table: string;\n  manyJoin: {\n    fromTable: string;\n    fromCol: string;\n    idField: string;\n    toTable: string;\n    toCol: string;\n    through?: {\n      table: string;\n      fromCol: string;\n      toCol: string;\n    };\n  };\n  oneJoins: ({\n    as: string;\n    join: \"inner\" | \"outer\";\n    table: string;\n  } & JoinClause)[];\n  select: string[];\n  loaders?: SubsetLoader[];\n};\n\nexport type SubsetQuery = {\n  select: string[];\n  virtual: string[];\n  joins: ({\n    as: string;\n    join: \"inner\" | \"outer\";\n    table: string;\n  } & JoinClause)[];\n  loaders: SubsetLoader[];\n};\n\n/* BaseModel */\nexport const SonamuQueryMode = z.enum([\"both\", \"list\", \"count\"]);\nexport type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;\n\n/* Semantic Query */\nexport const SonamuSemanticParams = z.object({\n  semanticQuery: z.object({\n    embedding: z.array(z.number()).min(1024).max(1024),\n    threshold: z.number().optional(),\n    method: z.enum([\"cosine\", \"l2\", \"inner_product\"]).optional(),\n  }),\n});\nexport type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;\n\n/* Knex Migration */\nexport type KnexError = {\n  code: string;\n  errno: number;\n  sql: string;\n  sqlMessage: string;\n  sqlState: string;\n};\nexport function isKnexError(e: unknown): e is KnexError {\n  return !!(e as KnexError)?.code && !!(e as KnexError)?.sqlMessage && !!(e as KnexError)?.sqlState;\n}\n\nexport type KnexColumnType =\n  | \"string\"\n  | \"text\"\n  | \"smalltext\"\n  | \"mediumtext\"\n  | \"longtext\"\n  | \"integer\"\n  | \"bigInteger\"\n  | \"decimal\"\n  | \"timestamp\"\n  | \"boolean\"\n  | \"foreign\"\n  | \"uuid\"\n  | \"json\"\n  | \"float\"\n  | \"date\"\n  | \"time\"\n  | \"datetime\";\nexport type MigrationColumnType =\n  | \"string\"\n  | \"string[]\"\n  | \"integer\"\n  | \"integer[]\"\n  | \"bigInteger\"\n  | \"bigInteger[]\"\n  | \"numberOrNumeric\"\n  | \"numberOrNumeric[]\"\n  | \"boolean\"\n  | \"boolean[]\"\n  | \"date\"\n  | \"date[]\"\n  | \"uuid\"\n  | \"uuid[]\"\n  | \"json\"\n  | \"vector\"\n  | \"vector[]\"\n  | \"tsvector\";\nexport type MigrationColumn = {\n  name: string;\n  type: MigrationColumnType;\n  nullable: boolean;\n  numberType?: \"real\" | \"double precision\" | \"numeric\";\n  length?: number;\n  defaultTo?: string;\n  precision?: number;\n  scale?: number;\n  dimensions?: number;\n  generated?: GeneratedColumn;\n};\nexport type MigrationIndex = {\n  type: \"unique\" | \"index\" | \"hnsw\" | \"ivfflat\";\n  columns: EntityIndexColumn[];\n  name: string;\n  using?: \"btree\" | \"hash\" | \"gin\" | \"gist\" | \"pgroonga\";\n  nullsNotDistinct?: boolean;\n  /** HNSW (Hierarchical Navigable Small World): 각 노드의 최대 연결 수 */\n  m?: number;\n  /** HNSW (Hierarchical Navigable Small World): 구성 시 탐색 범위 */\n  efConstruction?: number;\n  /** IVFFlat (Inverted File with Flat Compression): 클러스터링 리스트 수 */\n  lists?: number;\n};\nexport type MigrationForeign = {\n  columns: string[];\n  to: string;\n  onUpdate: RelationOn;\n  onDelete: RelationOn;\n};\nexport type MigrationJoinTable = {\n  table: string;\n  indexes: MigrationIndex[];\n  columns: MigrationColumn[];\n  foreigns: MigrationForeign[];\n};\nexport type MigrationSet = {\n  table: string;\n  columns: MigrationColumn[];\n  indexes: MigrationIndex[];\n  foreigns: MigrationForeign[];\n};\nexport type MigrationSetAndJoinTable = MigrationSet & {\n  joinTables: MigrationJoinTable[];\n};\nexport type GenMigrationCode = {\n  title: string;\n  table: string;\n  type: \"normal\" | \"foreign\";\n  formatted: string | null;\n};\n\n/* Api */\nexport type ApiParam = {\n  name: string;\n  type: ApiParamType;\n  optional: boolean;\n  defaultDef?: string;\n};\nexport namespace ApiParamType {\n  export type Function = {\n    t: \"function\";\n    parameters: ApiParam[];\n    returnType: ApiParamType;\n  };\n  export type Object = {\n    t: \"object\";\n    props: ApiParam[];\n  };\n  export type Union = {\n    t: \"union\";\n    types: ApiParamType[];\n  };\n  export type Intersection = {\n    t: \"intersection\";\n    types: ApiParamType[];\n  };\n  export type StringLiteral = {\n    t: \"string-literal\";\n    value: string;\n  };\n  export type NumericLiteral = {\n    t: \"numeric-literal\";\n    value: number;\n  };\n  export type Array = {\n    t: \"array\";\n    elementsType: ApiParamType;\n  };\n  export type Ref = {\n    t: \"ref\";\n    id: string;\n    args?: ApiParamType[];\n  };\n  export type IndexedAccess = {\n    t: \"indexed-access\";\n    object: ApiParamType;\n    index: ApiParamType;\n  };\n  export type TupleType = {\n    t: \"tuple-type\";\n    elements: ApiParamType[];\n  };\n  export type Pick = Ref & {\n    t: \"ref\";\n    id: \"Pick\";\n  };\n  export type Omit = Ref & {\n    t: \"ref\";\n    id: \"Omit\";\n  };\n  export type Partial = Ref & {\n    t: \"ref\";\n    id: \"Partial\";\n  };\n  export type Promise = Ref & {\n    t: \"ref\";\n    id: \"Promise\";\n  };\n  export type Context = Ref & {\n    t: \"ref\";\n    id: \"Context\";\n  };\n  export type TypeParam = {\n    t: \"type-param\";\n    id: string;\n    constraint?: ApiParamType;\n  };\n\n  export function isObject(v: unknown): v is ApiParamType.Object {\n    return (v as ApiParamType.Object)?.t === \"object\";\n  }\n  export function isUnion(v: unknown): v is ApiParamType.Union {\n    return (v as ApiParamType.Union)?.t === \"union\";\n  }\n  export function isIntersection(v: unknown): v is ApiParamType.Intersection {\n    return (v as ApiParamType.Intersection)?.t === \"intersection\";\n  }\n  export function isStringLiteral(v: unknown): v is ApiParamType.StringLiteral {\n    return (v as ApiParamType.StringLiteral)?.t === \"string-literal\";\n  }\n  export function isNumericLiteral(v: unknown): v is ApiParamType.NumericLiteral {\n    return (v as ApiParamType.NumericLiteral)?.t === \"numeric-literal\";\n  }\n  export function isArray(v: unknown): v is ApiParamType.Array {\n    return (v as ApiParamType.Array)?.t === \"array\";\n  }\n  export function isRef(v: unknown): v is ApiParamType.Ref {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"ref\";\n  }\n  export function isIndexedAccess(v: unknown): v is ApiParamType.IndexedAccess {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"indexed-access\";\n  }\n  export function isTupleType(v: unknown): v is ApiParamType.TupleType {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"tuple-type\";\n  }\n  export function isPick(v: unknown): v is ApiParamType.Pick {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Pick\"\n    );\n  }\n  export function isOmit(v: unknown): v is ApiParamType.Omit {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Omit\"\n    );\n  }\n  export function isPartial(v: unknown): v is ApiParamType.Partial {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Partial\"\n    );\n  }\n  export function isPromise(v: unknown): v is ApiParamType.Promise {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Promise\"\n    );\n  }\n  export function isContext(v: unknown): v is ApiParamType.Context {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Context\"\n    );\n  }\n  export function isRefKnex(v: unknown): v is ApiParamType.Ref {\n    return (\n      typeof v === \"object\" &&\n      v !== null &&\n      (v as { t?: unknown }).t === \"ref\" &&\n      (v as { id?: unknown }).id === \"Knex\"\n    );\n  }\n  export function isTypeParam(v: unknown): v is ApiParamType.TypeParam {\n    return typeof v === \"object\" && v !== null && (v as { t?: unknown }).t === \"type-param\";\n  }\n}\nexport type ApiParamType =\n  | \"string\"\n  | \"number\"\n  | \"boolean\"\n  | \"null\"\n  | \"undefined\"\n  | \"void\"\n  | \"any\"\n  | \"unknown\"\n  | \"true\"\n  | \"false\"\n  | ApiParamType.StringLiteral\n  | ApiParamType.NumericLiteral\n  | ApiParamType.Object\n  | ApiParamType.Union\n  | ApiParamType.Intersection\n  | ApiParamType.Array\n  | ApiParamType.Ref\n  | ApiParamType.IndexedAccess\n  | ApiParamType.TypeParam\n  | ApiParamType.TupleType\n  | ApiParamType.Function;\n\n/* Template */\n/**\n * UI 컴포넌트 렌더링을 위한 메타데이터 노드입니다.\n *\n * **목적**: Zod 스키마로부터 프론트엔드 UI 컴포넌트를 자동 생성하기 위한\n * 렌더링 정보를 담은 트리 구조입니다. 각 필드가 어떤 UI 컴포넌트로\n * 표현되어야 하는지(텍스트, 이미지, 날짜, Enum 선택 등)를 명시합니다.\n *\n * **변환 흐름**:\n * Entity subset → EntityPropNode → Zod 스키마 → RenderingNode (UI용) → React 컴포넌트 코드 생성\n *\n * **주요 필드**:\n * - `renderType`: UI 컴포넌트 유형 (string-plain, number-fk_id, enums, array 등)\n * - `zodType`: 원본 Zod 스키마 (validation 용)\n * - `children`: 중첩된 객체 필드들 (object일 때)\n * - `element`: 배열 요소 타입 (array일 때)\n *\n * **사용 위치**:\n * - zod-converter.ts의 zodTypeToRenderingNode()에서 생성\n * - view_form.template.ts, view_list.template.ts 등에서 React 컴포넌트 코드 생성에 사용\n */\n// 셀프 참조 타입이므로 Zod 생략하고 직접 정의\nexport const RenderingNode = z.any();\nexport type RenderingNode = {\n  name: string;\n  label: string;\n  renderType:\n    | \"string-plain\"\n    | \"string-image\"\n    | \"string-datetime\"\n    | \"string-date\"\n    | \"string-id\"\n    | \"string-fk_id\"\n    | \"datetime\"\n    | \"number-plain\"\n    | \"number-id\"\n    | \"number-fk_id\"\n    | \"boolean\"\n    | \"enums\"\n    | \"array\"\n    | \"array-images\"\n    | \"json-sonamufile\"\n    | \"json-sonamufile-array\"\n    | \"object\"\n    | \"object-pick\"\n    | \"record\"\n    | \"vector\";\n  zodType: z.ZodTypeAny;\n  element?: RenderingNode;\n  children?: RenderingNode[];\n  config?: {\n    picked: string;\n  };\n  optional?: boolean;\n  nullable?: boolean;\n};\n\nconst GeneratedColumnSchema = z.object({\n  type: z.enum([\"STORED\", \"VIRTUAL\"]),\n  expression: z.string(),\n});\n\n/**\n * Cone 스키마 검증\n *\n * cone 메타데이터의 유효성을 검증합니다.\n */\nconst ConeSchema = z\n  .object({\n    desc: z.string().optional(),\n    note: z.string().optional(),\n    tags: z.array(z.string()).optional(),\n    fixtureHint: z.string().optional(),\n    fixtureGenerator: z.string().optional(),\n    fixtureDefault: z.unknown().optional(),\n    dataSource: z\n      .object({\n        strategy: z.enum([\"sample\", \"ids\", \"query\", \"file\", \"recent\", \"random\"]),\n        config: z.unknown().optional(),\n      })\n      .optional(),\n  })\n  .catchall(z.unknown()); // 사용자 정의 메타데이터 허용\n\nconst BasePropFields = {\n  name: z.string(),\n  desc: z.string().optional(),\n  nullable: z.boolean().optional(),\n  toFilter: z.boolean().default(false).optional(),\n  dbDefault: z.union([z.string(), z.number(), z.boolean()]).optional(),\n  generated: GeneratedColumnSchema.optional(),\n  cone: ConeSchema.optional(),\n};\n\n// 부가 필드가 필요없는 prop\nconst BasePropFieldsWithoutAdditional = z\n  .object({\n    ...BasePropFields,\n    type: z.union([\n      z.literal(\"integer\"),\n      z.literal(\"integer[]\"),\n      z.literal(\"bigInteger\"),\n      z.literal(\"bigInteger[]\"),\n      z.literal(\"boolean\"),\n      z.literal(\"boolean[]\"),\n      z.literal(\"uuid\"),\n      z.literal(\"uuid[]\"),\n      z.literal(\"tsvector\"),\n    ]),\n  })\n  .strict();\n\n// precision/scale 필드\nconst PrecisionScaleFields = {\n  precision: z.number().optional(),\n  scale: z.number().optional(),\n};\n\n// 각 타입별 스키마 정의\n\nconst StringPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"string\"),\n    length: z.number().optional(),\n    zodFormat: ZodStringFormat.optional(),\n  })\n  .strict();\nconst StringArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"string[]\"),\n    length: z.number().optional(),\n    zodFormat: ZodStringFormat.optional(),\n  })\n  .strict();\n\nconst EnumPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"enum\"),\n    id: z.string(),\n    length: z.number().optional(),\n  })\n  .strict();\nconst EnumArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"enum[]\"),\n    id: z.string(),\n  })\n  .strict();\n\nconst NumberPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"number\"),\n    ...PrecisionScaleFields,\n    numberType: z.enum([\"real\", \"double precision\", \"numeric\"]).optional(),\n  })\n  .strict();\nconst NumberArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"number[]\"),\n    ...PrecisionScaleFields,\n    numberType: z.enum([\"real\", \"double precision\", \"numeric\"]).optional(),\n  })\n  .strict();\n\nconst DatePropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"date\"),\n    precision: z.number().optional(),\n  })\n  .strict();\nconst DateArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"date[]\"),\n    precision: z.number().optional(),\n  })\n  .strict();\n\nconst NumericPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"numeric\"),\n    ...PrecisionScaleFields,\n  })\n  .strict();\nconst NumericArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"numeric[]\"),\n    ...PrecisionScaleFields,\n  })\n  .strict();\n\nconst JsonPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"json\"),\n    id: z.string(),\n  })\n  .strict();\n\nconst VirtualPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"virtual\"),\n    id: z.string(),\n    virtualType: z.enum([\"query\", \"code\"]).optional(),\n  })\n  .strict();\n\nconst VectorPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"vector\"),\n    dimensions: z.number(),\n  })\n  .strict();\nconst VectorArrayPropSchema = z\n  .object({\n    ...BasePropFields,\n    type: z.literal(\"vector[]\"),\n    dimensions: z.number(),\n  })\n  .strict();\n\n// Relation 타입은 relationType에 따라 세분화\nconst BaseRelationFields = {\n  ...BasePropFields,\n  type: z.literal(\"relation\"),\n  with: z.string(),\n};\n\n// RelationOn 타입\nconst RelationOnSchema = z.enum([\"CASCADE\", \"SET NULL\", \"NO ACTION\", \"SET DEFAULT\", \"RESTRICT\"]);\n\nconst BelongsToOneRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"BelongsToOne\"),\n    customJoinClause: z.string().optional(),\n    useConstraint: z.boolean().optional(),\n    onUpdate: RelationOnSchema.optional(),\n    onDelete: RelationOnSchema.optional(),\n  })\n  .strict();\n\nconst HasManyRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"HasMany\"),\n    joinColumn: z.string(),\n    fromColumn: z.string().optional(),\n  })\n  .strict();\n\nconst ManyToManyRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"ManyToMany\"),\n    joinTable: z.string(),\n    onUpdate: RelationOnSchema,\n    onDelete: RelationOnSchema,\n  })\n  .strict();\n\nconst OneToOneRelationPropSchema = z\n  .object({\n    ...BaseRelationFields,\n    relationType: z.literal(\"OneToOne\"),\n    customJoinClause: z.string().optional(),\n    hasJoinColumn: z.boolean().optional(),\n    useConstraint: z.boolean().optional(),\n    onUpdate: RelationOnSchema.optional(),\n    onDelete: RelationOnSchema.optional(),\n  })\n  .strict();\n\nconst RelationTypes = [\"BelongsToOne\", \"HasMany\", \"ManyToMany\", \"OneToOne\"] as const;\nexport const RelationPropSchema = z.discriminatedUnion(\n  \"relationType\",\n  [\n    BelongsToOneRelationPropSchema,\n    HasManyRelationPropSchema,\n    ManyToManyRelationPropSchema,\n    OneToOneRelationPropSchema,\n  ],\n  {\n    error: (iss) =>\n      `relationType은 ${RelationTypes.map((t) => `'${t}'`).join(\", \")} 중 하나여야 합니다. 입력값: \"${(iss.input as Record<string, unknown>)?.relationType}\"`,\n  },\n);\n\nconst NormalPropTypes = [\n  \"integer\",\n  \"integer[]\",\n  \"bigInteger\",\n  \"bigInteger[]\",\n  \"string\",\n  \"string[]\",\n  \"enum\",\n  \"enum[]\",\n  \"number\",\n  \"number[]\",\n  \"numeric\",\n  \"numeric[]\",\n  \"boolean\",\n  \"boolean[]\",\n  \"date\",\n  \"date[]\",\n  \"uuid\",\n  \"uuid[]\",\n  \"json\",\n  \"virtual\",\n  \"vector\",\n  \"vector[]\",\n  \"tsvector\",\n] as const;\n\n// VIRTUAL Generated Column에서 사용 불가능한 타입들\nconst VirtualGeneratedDisallowedTypes = [\n  \"json\",\n  \"vector\",\n  \"vector[]\",\n  \"string[]\",\n  \"integer[]\",\n  \"bigInteger[]\",\n  \"boolean[]\",\n  \"date[]\",\n  \"uuid[]\",\n  \"number[]\",\n  \"numeric[]\",\n  \"enum[]\",\n] as const;\n\nexport const NormalPropSchema = z\n  .discriminatedUnion(\n    \"type\",\n    [\n      BasePropFieldsWithoutAdditional,\n      StringPropSchema,\n      StringArrayPropSchema,\n      EnumPropSchema,\n      EnumArrayPropSchema,\n      NumberPropSchema,\n      NumberArrayPropSchema,\n      DatePropSchema,\n      DateArrayPropSchema,\n      NumericPropSchema,\n      NumericArrayPropSchema,\n      JsonPropSchema,\n      VirtualPropSchema,\n      VectorPropSchema,\n      VectorArrayPropSchema,\n    ],\n    {\n      error: (iss) =>\n        `type은 ${NormalPropTypes.map((t) => `'${t}'`).join(\", \")} 중 하나여야 합니다. 입력값: \"${(iss.input as Record<string, unknown>)?.type}\"`,\n    },\n  )\n  .superRefine((data, ctx) => {\n    if (!data.generated) {\n      return;\n    }\n\n    // dbDefault와 generated 동시 사용 불가\n    if (data.dbDefault !== undefined) {\n      ctx.addIssue({\n        code: \"custom\",\n        message: \"dbDefault와 generated는 함께 사용할 수 없습니다\",\n        path: [\"generated\"],\n      });\n    }\n\n    // virtual 타입은 generated 불가\n    if (data.type === \"virtual\") {\n      ctx.addIssue({\n        code: \"custom\",\n        message: \"virtual 타입은 generated column을 지원하지 않습니다\",\n        path: [\"generated\"],\n      });\n    }\n\n    // VIRTUAL Generated Column 타입 제한 검증\n    if (data.generated.type === \"VIRTUAL\") {\n      if ((VirtualGeneratedDisallowedTypes as readonly string[]).includes(data.type)) {\n        ctx.addIssue({\n          code: \"custom\",\n          message: `VIRTUAL generated column은 ${data.type} 타입을 지원하지 않습니다. STORED를 사용하세요.`,\n          path: [\"generated\", \"type\"],\n          fatal: true,\n        });\n      }\n    }\n  });\n\nconst AllPropTypes = [...NormalPropTypes, \"relation\"] as const;\nconst EntityPropSchema = z.discriminatedUnion(\"type\", [NormalPropSchema, RelationPropSchema], {\n  error: (iss) =>\n    `type은 ${AllPropTypes.map((t) => `'${t}'`).join(\", \")} 중 하나여야 합니다. 입력값: \"${(iss.input as Record<string, unknown>)?.type}\"`,\n});\n\nconst EntityIndexColumnSchema = z.object({\n  name: z.string(),\n  nullsFirst: z.boolean().optional(),\n  sortOrder: z.enum([\"ASC\", \"DESC\"]).optional(),\n  vectorOps: z.enum([\"vector_cosine_ops\", \"vector_ip_ops\", \"vector_l2_ops\"]).optional(),\n});\n\n// EntityIndex 스키마 정의\nconst EntityIndexSchema = z\n  .object({\n    type: z.enum([\"index\", \"unique\", \"hnsw\", \"ivfflat\"]),\n    columns: z.array(EntityIndexColumnSchema),\n    name: z.string().min(1).max(63),\n    using: z.enum([\"btree\", \"hash\", \"gin\", \"gist\", \"pgroonga\"]).optional(),\n    nullsNotDistinct: z.boolean().optional(),\n    m: z.number().optional(),\n    efConstruction: z.number().optional(),\n    lists: z.number().optional(),\n  })\n  .strict();\n\n/**\n * SubsetDef 스키마\n *\n * 하위 호환성을 위해 배열 형태와 객체 형태 둘 다 지원합니다.\n */\nconst SubsetDefSchema = z.union([\n  // 기존 배열 형태\n  z.array(z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })])),\n  // 새로운 객체 형태\n  z.object({\n    fields: z.array(\n      z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })]),\n    ),\n    cone: ConeSchema.optional(),\n  }),\n]);\n\n/**\n * EnumDef 스키마\n *\n * 하위 호환성을 위해 Record 형태와 객체 형태 둘 다 지원합니다.\n */\nconst EnumDefSchema = z.union([\n  // 기존 Record 형태\n  z.record(z.string(), z.string()),\n  // 새로운 객체 형태\n  z.object({\n    values: z.record(z.string(), z.string()),\n    cone: ConeSchema.optional(),\n  }),\n]);\n\nexport const EntityJsonSchema = z\n  .object({\n    id: z.string().describe(\"PascalCase로 된 Entity ID\"),\n    title: z.string().describe(\"Entity 이름\"),\n    table: z.string().describe(\"snake_case로 된 테이블명\"),\n    parentId: z.string().optional().describe(\"부모 Entity ID\"),\n    cone: ConeSchema.optional(),\n    props: z.array(EntityPropSchema),\n    indexes: z.array(EntityIndexSchema),\n    subsets: z.record(z.string(), SubsetDefSchema),\n    enums: z.record(z.string(), EnumDefSchema),\n  })\n  .strict();\n\nexport const TemplateOptions = z.object({\n  entity: EntityJsonSchema.omit({ id: true })\n    .extend({\n      entityId: z.string(),\n    })\n    .partial({\n      table: true,\n      props: true,\n      indexes: true,\n      subsets: true,\n      enums: true,\n    }),\n  init_types: z.object({\n    entityId: z.string(),\n  }),\n  generated: z.object({}),\n  generated_sso: z.object({}),\n  generated_http: z.object({\n    entityId: z.string(),\n  }),\n  model: z.object({\n    entityId: z.string(),\n    defaultSearchField: z.string().optional(),\n    defaultOrderBy: z.string().optional(),\n  }),\n  model_test: z.object({\n    entityId: z.string(),\n  }),\n  bridge: z.object({\n    entityId: z.string(),\n  }),\n  services: z.object({}),\n  view_list: z.object({\n    entityId: z.string(),\n    extra: z.unknown(),\n  }),\n  view_list_columns: z.object({\n    entityId: z.string(),\n    columns: z\n      .object({\n        name: z.string(),\n        label: z.string(),\n        tc: z.string(),\n      })\n      .array(),\n    columnImports: z.string(),\n  }),\n  view_search_input: z.object({\n    entityId: z.string(),\n  }),\n  view_form: z.object({\n    entityId: z.string(),\n  }),\n  view_id_all_select: z.object({\n    entityId: z.string(),\n  }),\n  view_enums_buttonset: z.object({\n    entityId: z.string(),\n    enumId: z.string(),\n  }),\n  queries: z.object({}),\n  entry_server: z.object({}),\n  sd: z.object({\n    target: z.enum([\"api\", \"web\", \"app\"]),\n  }),\n});\nexport type TemplateOptions = z.infer<typeof TemplateOptions>;\n\nexport const TemplateKey = z.enum([\n  \"entity\",\n  \"init_types\",\n  \"generated\",\n  \"generated_sso\",\n  \"generated_http\",\n  \"model\",\n  \"model_test\",\n  \"bridge\",\n  \"services\",\n  \"view_list\",\n  \"view_list_columns\",\n  \"view_search_input\",\n  \"view_form\",\n  \"view_id_all_select\",\n  \"view_enums_buttonset\",\n  \"queries\",\n  \"entry_server\",\n  \"sd\",\n]);\nexport type TemplateKey = z.infer<typeof TemplateKey>;\n\nexport const GenerateOptions = z.object({\n  overwrite: z.boolean().optional(),\n});\nexport type GenerateOptions = z.infer<typeof GenerateOptions>;\n\nexport const PathAndCode = z.object({\n  path: z.string(),\n  code: z.string(),\n});\nexport type PathAndCode = z.infer<typeof PathAndCode>;\n\nexport type FixtureSearchOptions = {\n  entityId: string;\n  field: string;\n  value: string;\n  searchType: \"equals\" | \"like\";\n};\n\ntype ColumnValue = string | number | boolean | Date | null;\nexport type FixtureRecord = {\n  fixtureId: string;\n  entityId: string;\n  id: number | string;\n  columns: {\n    [key: string]: {\n      prop: EntityProp;\n      value: ColumnValue | ColumnValue[];\n    };\n  };\n  fetchedRecords: string[];\n  belongsRecords: string[];\n  target?: FixtureRecord; // Import 대상 DB 레코드(id가 같은)\n  unique?: FixtureRecord; // Import 대상 DB 레코드(unique key가 같은)\n  override?: boolean;\n};\n\nexport type FixtureImportResult = {\n  entityId: string;\n  data: {\n    [key: string]: ColumnValue;\n  };\n};\n\nexport type RelationNode = {\n  fixtureId: string;\n  entityId: string;\n  related: Set<string>;\n};\n\n// biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스\nexport interface DatabaseSchemaExtend {}\n// biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스\nexport interface DatabaseForeignKeys {}\nexport type ManyToManyBaseSchema<\n  FromIdKey extends string,\n  ToIdKey extends string,\n  FromPkType = number,\n  ToPkType = number,\n> = {\n  id: number;\n} & {\n  [K in `${FromIdKey}_id`]: FromPkType;\n} & {\n  [K in `${ToIdKey}_id`]: ToPkType;\n};\n\n// 객체, 함수, 비동기 함수를 모두 포괄하는 타입\nexport type Executable<T> = T | Promise<T> | (() => T) | (() => Promise<T>);\n\nexport type SonamuFastifyConfig = {\n  contextProvider: (\n    defaultContext: Pick<\n      Context,\n      \"request\" | \"reply\" | \"headers\" | \"createSSE\" | \"naiteStore\" | \"locale\" | \"user\" | \"session\"\n    >,\n    request: FastifyRequest,\n    reply: FastifyReply,\n  ) => Context | Promise<Context>;\n  guardHandler: (\n    guard: GuardKey,\n    request: FastifyRequest,\n    api: {\n      typeParameters: ApiParamType.TypeParam[];\n      parameters: ApiParam[];\n      returnType: ApiParamType;\n      modelName: string;\n      methodName: string;\n      path: string;\n      options: ApiDecoratorOptions;\n    },\n  ) => void;\n  /**\n   * 전역 Cache-Control 핸들러입니다.\n   * 요청 타입(api, assets, ssr, csr)에 따라 Cache-Control 설정을 반환합니다.\n   * undefined를 반환하면 타입별 기본값이 적용됩니다.\n   */\n  cacheControlHandler?: CacheControlHandler;\n};\n"],"names":["z","zArrayable","shape","union","array","getDescription","item","cone","desc","ZodStringFormat","enum","SonamuFileSchema","object","name","string","url","mime_type","size","number","describe","SonamuFileArraySchema","BUILT_IN_TYPE_IDS","normalizeSubsetField","f","field","isInternalSubsetField","internal","isSubsetDefWithCone","def","Array","isArray","isEnumDefWithCone","undefined","Object","keys","length","getSubsetFields","fields","getEnumDefValues","values","isIntegerSingleProp","p","type","isIntegerArrayProp","isIntegerProp","isBigIntegerSingleProp","isBigIntegerArrayProp","isBigIntegerProp","isStringSingleProp","isStringArrayProp","isStringProp","isEnumSingleProp","isEnumArrayProp","isEnumProp","isNumberSingleProp","isNumberArrayProp","isNumberProp","isNumericSingleProp","isNumericArrayProp","isNumericProp","isBooleanSingleProp","isBooleanArrayProp","isBooleanProp","isDateSingleProp","isDateArrayProp","isDateProp","isUuidSingleProp","isUuidArrayProp","isUuidProp","isJsonProp","isVirtualProp","isVirtualCodeProp","virtualType","isVirtualQueryProp","isVectorSingleProp","isVectorArrayProp","isVectorProp","isTsVectorProp","isRelationProp","isOneToOneRelationProp","relationType","isBelongsToOneRelationProp","isHasManyRelationProp","isManyToManyRelationProp","isCustomJoinClause","custom","SonamuQueryMode","SonamuSemanticParams","semanticQuery","embedding","min","max","threshold","optional","method","isKnexError","e","code","sqlMessage","sqlState","ApiParamType","isObject","v","t","isUnion","isIntersection","isStringLiteral","isNumericLiteral","isRef","isIndexedAccess","isTupleType","isPick","id","isOmit","isPartial","isPromise","isContext","isRefKnex","isTypeParam","RenderingNode","any","GeneratedColumnSchema","expression","ConeSchema","note","tags","fixtureHint","fixtureGenerator","fixtureDefault","unknown","dataSource","strategy","config","catchall","BasePropFields","nullable","boolean","toFilter","default","dbDefault","generated","BasePropFieldsWithoutAdditional","literal","strict","PrecisionScaleFields","precision","scale","StringPropSchema","zodFormat","StringArrayPropSchema","EnumPropSchema","EnumArrayPropSchema","NumberPropSchema","numberType","NumberArrayPropSchema","DatePropSchema","DateArrayPropSchema","NumericPropSchema","NumericArrayPropSchema","JsonPropSchema","VirtualPropSchema","VectorPropSchema","dimensions","VectorArrayPropSchema","BaseRelationFields","with","RelationOnSchema","BelongsToOneRelationPropSchema","customJoinClause","useConstraint","onUpdate","onDelete","HasManyRelationPropSchema","joinColumn","fromColumn","ManyToManyRelationPropSchema","joinTable","OneToOneRelationPropSchema","hasJoinColumn","RelationTypes","RelationPropSchema","discriminatedUnion","error","iss","map","join","input","NormalPropTypes","VirtualGeneratedDisallowedTypes","NormalPropSchema","superRefine","data","ctx","addIssue","message","path","includes","fatal","AllPropTypes","EntityPropSchema","EntityIndexColumnSchema","nullsFirst","sortOrder","vectorOps","EntityIndexSchema","columns","using","nullsNotDistinct","m","efConstruction","lists","SubsetDefSchema","EnumDefSchema","record","EntityJsonSchema","title","table","parentId","props","indexes","subsets","enums","TemplateOptions","entity","omit","extend","entityId","partial","init_types","generated_sso","generated_http","model","defaultSearchField","defaultOrderBy","model_test","bridge","services","view_list","extra","view_list_columns","label","tc","columnImports","view_search_input","view_form","view_id_all_select","view_enums_buttonset","enumId","queries","entry_server","sd","target","TemplateKey","GenerateOptions","overwrite","PathAndCode"],"mappings":"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"}

package/dist/ui/ai-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-client.d.ts","sourceRoot":"","sources":["../../src/ui/ai-client.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,KAAK,EAAiB,YAAY,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAOxE,OAAO,EAEL,KAAK,aAAa,EAInB,MAAM,gBAAgB,CAAC;AAQxB,cAAM,QAAQ;IACZ,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,KAAK,CAIG;IAEV,IAAI;IAcV,aAAa,CACX,QAAQ,EAAE,YAAY,EAAE,EACxB,cAAc,EAAE,aAAa,EAAE,GAC9B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;IA+M7B,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;CAuQnE;AAiDD,eAAO,MAAM,QAAQ,UAAiB,CAAC"}
+{"version":3,"file":"ai-client.d.ts","sourceRoot":"","sources":["../../src/ui/ai-client.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,KAAK,EAAiB,YAAY,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAOxE,OAAO,EAEL,KAAK,aAAa,EAKnB,MAAM,gBAAgB,CAAC;AAQxB,cAAM,QAAQ;IACZ,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,KAAK,CAIG;IAEV,IAAI;IAcV,aAAa,CACX,QAAQ,EAAE,YAAY,EAAE,EACxB,cAAc,EAAE,aAAa,EAAE,GAC9B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;IA+M7B,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;CA8QnE;AAiDD,eAAO,MAAM,QAAQ,UAAiB,CAAC"}