sonamu 0.8.26 → 0.9.0

package/dist/api/code-converters.js

@@ -1,263 +1,240 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { ApiParamType, init_types } from "../types/types.js";
+import { z as z$1 } from "zod";
+
+//#region src/api/code-converters.ts
 /**
- * code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.
- *
- * 1. API 시리즈들:
- * - ExtendedApi, ApiParam, ApiParamType
- * - API 메타데이터를 표현하는 타입 정의들
- *
- * 2. ZodObject 변환
- * - API 타입 정의 → Zod 타입 인스턴스 (런타임 밸리데이션용)
- * - getZodTypeFromApiParamType → getZodObjectFromApiParams → getZodObjectFromApi
- *
- * 3. TsTypeDef 변환
- * - API 타입 정의 → TypeScript 타입 코드 문자열 (코드 생성용)
- * - apiParamTypeToTsType → apiParamToTsCode, apiParamToTsCodeAsObject
- *
- * 참고:
- * - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용
- * - EntityProp 변환: zod-converter.ts 참조
- */ import { z } from "zod";
-import { ApiParamType } from "../types/types.js";
+* code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.
+*
+* 1. API 시리즈들:
+* - ExtendedApi, ApiParam, ApiParamType
+* - API 메타데이터를 표현하는 타입 정의들
+*
+* 2. ZodObject 변환
+* - API 타입 정의 → Zod 타입 인스턴스 (런타임 밸리데이션용)
+* - getZodTypeFromApiParamType → getZodObjectFromApiParams → getZodObjectFromApi
+*
+* 3. TsTypeDef 변환
+* - API 타입 정의 → TypeScript 타입 코드 문자열 (코드 생성용)
+* - apiParamTypeToTsType → apiParamToTsCode, apiParamToTsCodeAsObject
+*
+* 참고:
+* - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용
+* - EntityProp 변환: zod-converter.ts 참조
+*/
 /**
- * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.
- * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.
- */ export function unwrapPromiseOnce(paramType) {
-    if (ApiParamType.isPromise(paramType)) {
-        return paramType.args?.[0];
-    } else {
-        return paramType;
-    }
+* Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.
+* Promise가 아닌 경우 원본 타입을 그대로 반환합니다.
+*/
+function unwrapPromiseOnce(paramType) {
+	if (ApiParamType.isPromise(paramType)) {
+		return paramType.args?.[0];
+	} else {
+		return paramType;
+	}
 }
-/*
- * API를 구성하는 요소들을 ZodObject로 변환하기 위한 함수들입니다.
- */ /**
- * ApiParamType을 Zod 타입 인스턴스로 변환합니다.
- * string, number, array, union 등 모든 ApiParamType을 처리하며,
- * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.
- */ export function getZodTypeFromApiParamType(paramType, references) {
-    switch(paramType){
-        case "string":
-            return z.string();
-        case "number":
-            return z.number();
-        case "boolean":
-            return z.boolean();
-        default:
-            {
-                const advType = paramType;
-                switch(advType.t){
-                    case "string-literal":
-                    case "numeric-literal":
-                        return z.literal(advType.value);
-                    case "object":
-                        {
-                            const objType = paramType;
-                            return getZodObjectFromApiParams(objType.props);
-                        }
-                    case "array":
-                        {
-                            const arrType = paramType;
-                            return z.array(getZodTypeFromApiParamType(arrType.elementsType, references));
-                        }
-                    case "ref":
-                        {
-                            const refType = paramType;
-                            // Date 타입 처리
-                            if (refType.id === "Date") {
-                                return z.date();
-                            }
-                            // 객체 키 관리 유틸리티
-                            if ([
-                                "Pick",
-                                "Omit"
-                            ].includes(refType.id)) {
-                                if (refType.args?.length !== 2) {
-                                    throw new Error(`잘못된 ${refType.id}`);
-                                }
-                                const [obj, literalOrUnion] = refType.args.map((arg)=>getZodTypeFromApiParamType(arg, references));
-                                let keys = [];
-                                if (literalOrUnion instanceof z.ZodUnion) {
-                                    keys = literalOrUnion.def.options.map((option)=>option.def.values[0]);
-                                } else {
-                                    keys = literalOrUnion.def.values;
-                                }
-                                const keyRecord = Object.fromEntries(keys.map((key)=>[
-                                        key,
-                                        true
-                                    ]));
-                                if (refType.id === "Pick") {
-                                    if (obj.pick) {
-                                        // biome-ignore lint/suspicious/noExplicitAny: Zod 4.3.6 pick 타입 호환성
-                                        return obj.pick(keyRecord);
-                                    }
-                                } else {
-                                    if (obj.omit) {
-                                        // biome-ignore lint/suspicious/noExplicitAny: Zod 4.3.6 omit 타입 호환성
-                                        return obj.omit(keyRecord);
-                                    }
-                                }
-                            }
-                            if ([
-                                "Partial"
-                            ].includes(refType.id)) {
-                                if (refType.args?.length !== 1) {
-                                    throw new Error(`잘못된 ${refType.id}`);
-                                }
-                                const obj = getZodTypeFromApiParamType(refType.args[0], references);
-                                // biome-ignore lint/suspicious/noExplicitAny: Partial 인수 타입 캐스팅
-                                return obj.partial();
-                            }
-                            const reference = references[refType.id];
-                            if (reference === undefined) {
-                                return z.unknown();
-                            // throw new Error(`ref 참조 불가 ${refType.id}`);
-                            }
-                            return reference;
-                        }
-                    case "union":
-                        {
-                            const unionType = paramType;
-                            // nullable 유니온
-                            if (unionType.types.length === 2 && unionType.types.some((type)=>type === "null")) {
-                                if (unionType.types[0] === "null") {
-                                    return getZodTypeFromApiParamType(unionType.types[1], references).nullable();
-                                } else {
-                                    return getZodTypeFromApiParamType(unionType.types[0], references).nullable();
-                                }
-                            }
-                            // 일반 유니온
-                            return z.union(unionType.types.map((type)=>getZodTypeFromApiParamType(type, references)));
-                        }
-                    case "intersection":
-                        {
-                            const intersectionType = paramType;
-                            return intersectionType.types.reduce((result, type, index)=>{
-                                const resolvedType = getZodTypeFromApiParamType(type, references);
-                                if (index === 0) {
-                                    return resolvedType;
-                                } else {
-                                    return z.intersection(result, resolvedType);
-                                }
-                            }, z.unknown());
-                        }
-                    case "tuple-type":
-                        {
-                            const tupleType = paramType;
-                            return z.tuple(// biome-ignore lint/suspicious/noExplicitAny: 생성되는 ZodTuple의 타입을 추적하기 어려움
-                            tupleType.elements.map((elem)=>getZodTypeFromApiParamType(elem, references)));
-                        }
-                }
-                return z.unknown();
-            }
-    }
+/**
+* ApiParamType을 Zod 타입 인스턴스로 변환합니다.
+* string, number, array, union 등 모든 ApiParamType을 처리하며,
+* 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.
+*/
+function getZodTypeFromApiParamType(paramType, references) {
+	switch (paramType) {
+		case "string": return z$1.string();
+		case "number": return z$1.number();
+		case "boolean": return z$1.boolean();
+		default: {
+			const advType = paramType;
+			switch (advType.t) {
+				case "string-literal":
+				case "numeric-literal": return z$1.literal(advType.value);
+				case "object": {
+					const objType = paramType;
+					return getZodObjectFromApiParams(objType.props);
+				}
+				case "array": {
+					const arrType = paramType;
+					return z$1.array(getZodTypeFromApiParamType(arrType.elementsType, references));
+				}
+				case "ref": {
+					const refType = paramType;
+					if (refType.id === "Date") {
+						return z$1.date();
+					}
+					if (["Pick", "Omit"].includes(refType.id)) {
+						if (refType.args?.length !== 2) {
+							throw new Error(`잘못된 ${refType.id}`);
+						}
+						const [obj, literalOrUnion] = refType.args.map((arg) => getZodTypeFromApiParamType(arg, references));
+						let keys = [];
+						if (literalOrUnion instanceof z$1.ZodUnion) {
+							keys = literalOrUnion.def.options.map((option) => option.def.values[0]);
+						} else {
+							keys = literalOrUnion.def.values;
+						}
+						const keyRecord = Object.fromEntries(keys.map((key) => [key, true]));
+						if (refType.id === "Pick") {
+							if (obj.pick) {
+								return obj.pick(keyRecord);
+							}
+						} else {
+							if (obj.omit) {
+								return obj.omit(keyRecord);
+							}
+						}
+					}
+					if (["Partial"].includes(refType.id)) {
+						if (refType.args?.length !== 1) {
+							throw new Error(`잘못된 ${refType.id}`);
+						}
+						const obj = getZodTypeFromApiParamType(refType.args[0], references);
+						return obj.partial();
+					}
+					const reference = references[refType.id];
+					if (reference === undefined) {
+						return z$1.unknown();
+					}
+					return reference;
+				}
+				case "union": {
+					const unionType = paramType;
+					if (unionType.types.length === 2 && unionType.types.some((type) => type === "null")) {
+						if (unionType.types[0] === "null") {
+							return getZodTypeFromApiParamType(unionType.types[1], references).nullable();
+						} else {
+							return getZodTypeFromApiParamType(unionType.types[0], references).nullable();
+						}
+					}
+					return z$1.union(unionType.types.map((type) => getZodTypeFromApiParamType(type, references)));
+				}
+				case "intersection": {
+					const intersectionType = paramType;
+					return intersectionType.types.reduce((result, type, index) => {
+						const resolvedType = getZodTypeFromApiParamType(type, references);
+						if (index === 0) {
+							return resolvedType;
+						} else {
+							return z$1.intersection(result, resolvedType);
+						}
+					}, z$1.unknown());
+				}
+				case "tuple-type": {
+					const tupleType = paramType;
+					return z$1.tuple(tupleType.elements.map((elem) => getZodTypeFromApiParamType(elem, references)));
+				}
+			}
+			return z$1.unknown();
+		}
+	}
 }
 /**
- * ApiParam 배열을 ZodObject로 변환합니다.
- * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.
- */ export function getZodObjectFromApiParams(apiParams, references = {}) {
-    return z.object(Object.fromEntries(apiParams.map((param)=>{
-        let zodType = getZodTypeFromApiParamType(param.type, references);
-        if (param.optional) {
-            zodType = zodType.optional();
-        }
-        return [
-            param.name,
-            zodType
-        ];
-    })));
+* ApiParam 배열을 ZodObject로 변환합니다.
+* 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.
+*/
+function getZodObjectFromApiParams(apiParams, references = {}) {
+	return z$1.object(Object.fromEntries(apiParams.map((param) => {
+		let zodType = getZodTypeFromApiParamType(param.type, references);
+		if (param.optional) {
+			zodType = zodType.optional();
+		}
+		return [param.name, zodType];
+	})));
 }
 /**
- * ExtendedApi를 ZodObject로 변환합니다.
- * TypeParameter와 일반 파라미터를 처리하며,
- * Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.
- */ export function getZodObjectFromApi(api, references = {}) {
-    if (api.typeParameters?.length > 0) {
-        for (const typeParam of api.typeParameters){
-            if (typeParam.constraint) {
-                const zodType = getZodTypeFromApiParamType(typeParam.constraint, references);
-                // FIXME: references는 글로벌 오브젝트로, typeParam.id("T" 등)를 key로 이렇게 덮어씌워버리면 loadedTypes가 오염됨.
-                // biome-ignore lint/suspicious/noExplicitAny: 레퍼런스 타입 캐스팅
-                references[typeParam.id] = zodType;
-            }
-        }
-    }
-    const ReqType = getZodObjectFromApiParams(// api parsing한 결과가 api params
-    api.parameters.filter((param)=>!ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional === true && param.name.startsWith("_"))), references);
-    return ReqType;
+* ExtendedApi를 ZodObject로 변환합니다.
+* TypeParameter와 일반 파라미터를 처리하며,
+* Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.
+*/
+function getZodObjectFromApi(api, references = {}) {
+	if (api.typeParameters?.length > 0) {
+		for (const typeParam of api.typeParameters) {
+			if (typeParam.constraint) {
+				const zodType = getZodTypeFromApiParamType(typeParam.constraint, references);
+				references[typeParam.id] = zodType;
+			}
+		}
+	}
+	const ReqType = getZodObjectFromApiParams(api.parameters.filter((param) => !ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional && param.name.startsWith("_"))), references);
+	return ReqType;
 }
-/*
- * API 타입 정의를 TypeScript 코드 문자열로 변환하기 위한 함수들입니다.
- */ /**
- * ApiParamType을 TypeScript 타입 문자열로 변환합니다.
- * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,
- * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.
- */ export function apiParamTypeToTsType(paramType, injectImportKeys) {
-    if ([
-        "string",
-        "number",
-        "boolean",
-        "true",
-        "false",
-        "null",
-        "undefined",
-        "void",
-        "any",
-        "unknown"
-    ].includes(paramType)) {
-        return paramType;
-    } else if (ApiParamType.isObject(paramType)) {
-        return `{ ${apiParamToTsCode(paramType.props, injectImportKeys)} }`;
-    } else if (ApiParamType.isStringLiteral(paramType)) {
-        return `"${paramType.value}"`;
-    } else if (ApiParamType.isNumericLiteral(paramType)) {
-        return String(paramType.value);
-    } else if (ApiParamType.isUnion(paramType)) {
-        return paramType.types.map((type)=>apiParamTypeToTsType(type, injectImportKeys)).join(" | ");
-    } else if (ApiParamType.isIntersection(paramType)) {
-        return paramType.types.map((type)=>apiParamTypeToTsType(type, injectImportKeys)).join(" & ");
-    } else if (ApiParamType.isArray(paramType)) {
-        // intersection이나 union인 경우 괄호로 감싸기
-        const elementsType = apiParamTypeToTsType(paramType.elementsType, injectImportKeys);
-        return ApiParamType.isIntersection(paramType.elementsType) || ApiParamType.isUnion(paramType.elementsType) ? `(${elementsType})[]` : `${elementsType}[]`;
-    } else if (ApiParamType.isRef(paramType)) {
-        if ([
-            "Pick",
-            "Omit",
-            "Promise",
-            "Partial",
-            "Date"
-        ].includes(paramType.id) === false) {
-            // importKeys 인젝션
-            injectImportKeys.push(paramType.id);
-        }
-        if (paramType.args === undefined || paramType.args.length === 0) {
-            return paramType.id;
-        } else {
-            return `${paramType.id}<${paramType.args.map((arg)=>apiParamTypeToTsType(arg, injectImportKeys)).join(",")}>`;
-        }
-    } else if (ApiParamType.isIndexedAccess(paramType)) {
-        return `${apiParamTypeToTsType(paramType.object, injectImportKeys)}[${apiParamTypeToTsType(paramType.index, injectImportKeys)}]`;
-    } else if (ApiParamType.isTupleType(paramType)) {
-        return `[ ${paramType.elements.map((elem)=>apiParamTypeToTsType(elem, injectImportKeys))} ]`;
-    } else if (ApiParamType.isTypeParam(paramType)) {
-        return `${paramType.id}${paramType.constraint ? ` extends ${apiParamTypeToTsType(paramType.constraint, injectImportKeys)}` : ""}`;
-    } else {
-        throw new Error(`resolve 불가 ApiParamType ${paramType}`);
-    }
+/**
+* ApiParamType을 TypeScript 타입 문자열로 변환합니다.
+* union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,
+* import가 필요한 타입 ID는 injectImportKeys에 수집합니다.
+*/
+function apiParamTypeToTsType(paramType, injectImportKeys) {
+	if ([
+		"string",
+		"number",
+		"boolean",
+		"true",
+		"false",
+		"null",
+		"undefined",
+		"void",
+		"any",
+		"unknown"
+	].includes(paramType)) {
+		return paramType;
+	} else if (ApiParamType.isObject(paramType)) {
+		return `{ ${apiParamToTsCode(paramType.props, injectImportKeys)} }`;
+	} else if (ApiParamType.isStringLiteral(paramType)) {
+		return `"${paramType.value}"`;
+	} else if (ApiParamType.isNumericLiteral(paramType)) {
+		return String(paramType.value);
+	} else if (ApiParamType.isUnion(paramType)) {
+		return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(" | ");
+	} else if (ApiParamType.isIntersection(paramType)) {
+		return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(" & ");
+	} else if (ApiParamType.isArray(paramType)) {
+		const elementsType = apiParamTypeToTsType(paramType.elementsType, injectImportKeys);
+		return ApiParamType.isIntersection(paramType.elementsType) || ApiParamType.isUnion(paramType.elementsType) ? `(${elementsType})[]` : `${elementsType}[]`;
+	} else if (ApiParamType.isRef(paramType)) {
+		if (![
+			"Pick",
+			"Omit",
+			"Promise",
+			"Partial",
+			"Date"
+		].includes(paramType.id)) {
+			injectImportKeys.push(paramType.id);
+		}
+		if (paramType.args === undefined || paramType.args.length === 0) {
+			return paramType.id;
+		} else {
+			return `${paramType.id}<${paramType.args.map((arg) => apiParamTypeToTsType(arg, injectImportKeys)).join(",")}>`;
+		}
+	} else if (ApiParamType.isIndexedAccess(paramType)) {
+		return `${apiParamTypeToTsType(paramType.object, injectImportKeys)}[${apiParamTypeToTsType(paramType.index, injectImportKeys)}]`;
+	} else if (ApiParamType.isTupleType(paramType)) {
+		return `[ ${paramType.elements.map((elem) => apiParamTypeToTsType(elem, injectImportKeys))} ]`;
+	} else if (ApiParamType.isTypeParam(paramType)) {
+		return `${paramType.id}${paramType.constraint ? ` extends ${apiParamTypeToTsType(paramType.constraint, injectImportKeys)}` : ""}`;
+	} else {
+		throw new Error(`resolve 불가 ApiParamType ${paramType}`);
+	}
 }
 /**
- * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.
- * 예: "name: string, age?: number, active: boolean = true"
- */ export function apiParamToTsCode(params, injectImportKeys) {
-    return params.map((param)=>{
-        return `${param.name}${param.optional && !param.defaultDef ? "?" : ""}: ${apiParamTypeToTsType(param.type, injectImportKeys)}${param.defaultDef ? `= ${param.defaultDef}` : ""}`;
-    }).join(", ");
+* ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.
+* 예: "name: string, age?: number, active: boolean = true"
+*/
+function apiParamToTsCode(params, injectImportKeys) {
+	return params.map((param) => {
+		return `${param.name}${param.optional && !param.defaultDef ? "?" : ""}: ${apiParamTypeToTsType(param.type, injectImportKeys)}${param.defaultDef ? `= ${param.defaultDef}` : ""}`;
+	}).join(", ");
 }
 /**
- * ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.
- * 예: "{ name: string, age?: number, active: boolean = true }"
- */ export function apiParamToTsCodeAsObject(params, injectImportKeys) {
-    return `{ ${params.map((param)=>`${param.name}${param.optional ? "?" : ""}: ${apiParamTypeToTsType(param.type, injectImportKeys)}${param.defaultDef ? `= ${param.defaultDef}` : ""}`).join(", ")} }`;
+* ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.
+* 예: "{ name: string, age?: number, active: boolean = true }"
+*/
+function apiParamToTsCodeAsObject(params, injectImportKeys) {
+	return `{ ${params.map((param) => `${param.name}${param.optional ? "?" : ""}: ${apiParamTypeToTsType(param.type, injectImportKeys)}${param.defaultDef ? `= ${param.defaultDef}` : ""}`).join(", ")} }`;
 }
+var init_code_converters = __esmMin((() => {
+	init_types();
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/api/code-converters.ts"],"sourcesContent":["/**\n * code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.\n *\n * 1. API 시리즈들:\n * - ExtendedApi, ApiParam, ApiParamType\n * - API 메타데이터를 표현하는 타입 정의들\n *\n * 2. ZodObject 변환\n * - API 타입 정의 → Zod 타입 인스턴스 (런타임 밸리데이션용)\n * - getZodTypeFromApiParamType → getZodObjectFromApiParams → getZodObjectFromApi\n *\n * 3. TsTypeDef 변환\n * - API 타입 정의 → TypeScript 타입 코드 문자열 (코드 생성용)\n * - apiParamTypeToTsType → apiParamToTsCode, apiParamToTsCodeAsObject\n *\n * 참고:\n * - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용\n * - EntityProp 변환: zod-converter.ts 참조\n */\n\nimport { z } from \"zod\";\nimport type { core } from \"zod/v4\";\nimport type { $ZodLooseShape } from \"zod/v4/core\";\nimport { type ApiParam, ApiParamType } from \"../types/types\";\nimport type { ExtendedApi } from \"./decorators\";\n\n// <any>를 자제하고, Zod에서 제약하는 기본적인 Generic Type Parameter를 사용함.\ntype AnyZodObject = z.ZodObject<$ZodLooseShape>;\ntype AnyZodLiteral = z.ZodLiteral<core.util.Literal>;\n\n/**\n * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.\n * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.\n */\nexport function unwrapPromiseOnce(paramType: ApiParamType) {\n  if (ApiParamType.isPromise(paramType)) {\n    return paramType.args?.[0];\n  } else {\n    return paramType;\n  }\n}\n\n/*\n * API를 구성하는 요소들을 ZodObject로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 Zod 타입 인스턴스로 변환합니다.\n * string, number, array, union 등 모든 ApiParamType을 처리하며,\n * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.\n */\nexport function getZodTypeFromApiParamType(\n  paramType: ApiParamType,\n  references: {\n    [id: string]: z.ZodType;\n  },\n): z.ZodType<unknown> {\n  switch (paramType) {\n    case \"string\":\n      return z.string();\n    case \"number\":\n      return z.number();\n    case \"boolean\":\n      return z.boolean();\n    default: {\n      const advType = paramType as { t: string; value?: string | number };\n      switch (advType.t) {\n        case \"string-literal\":\n        case \"numeric-literal\":\n          return z.literal(advType.value);\n        case \"object\": {\n          const objType = paramType as { t: string; props: ApiParam[] };\n          return getZodObjectFromApiParams(objType.props);\n        }\n        case \"array\": {\n          const arrType = paramType as {\n            t: string;\n            elementsType: ApiParamType;\n          };\n          return z.array(getZodTypeFromApiParamType(arrType.elementsType, references));\n        }\n        case \"ref\": {\n          const refType = paramType as {\n            t: string;\n            id: string;\n            args?: ApiParamType[];\n          };\n          // Date 타입 처리\n          if (refType.id === \"Date\") {\n            return z.date();\n          }\n          // 객체 키 관리 유틸리티\n          if ([\"Pick\", \"Omit\"].includes(refType.id)) {\n            if (refType.args?.length !== 2) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const [obj, literalOrUnion] = refType.args.map(\n              (arg) => getZodTypeFromApiParamType(arg, references),\n              // biome-ignore lint/suspicious/noExplicitAny: 생성되는 ZodUnion의 타입을 추적하기 어려움\n            ) as [AnyZodObject, z.ZodUnion<any> | AnyZodLiteral];\n\n            let keys: string[] = [];\n            if (literalOrUnion instanceof z.ZodUnion) {\n              keys = literalOrUnion.def.options.map(\n                (option: { def: { values: string[] } }) => option.def.values[0],\n              );\n            } else {\n              keys = (literalOrUnion as z.ZodLiteral<string>).def.values;\n            }\n            const keyRecord = Object.fromEntries(keys.map((key) => [key, true as const]));\n            if (refType.id === \"Pick\") {\n              if (obj.pick) {\n                // biome-ignore lint/suspicious/noExplicitAny: Zod 4.3.6 pick 타입 호환성\n                return obj.pick(keyRecord as any);\n              }\n            } else {\n              if (obj.omit) {\n                // biome-ignore lint/suspicious/noExplicitAny: Zod 4.3.6 omit 타입 호환성\n                return obj.omit(keyRecord as any);\n              }\n            }\n          }\n          if ([\"Partial\"].includes(refType.id)) {\n            if (refType.args?.length !== 1) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const obj = getZodTypeFromApiParamType(refType.args[0], references);\n            // biome-ignore lint/suspicious/noExplicitAny: Partial 인수 타입 캐스팅\n            return (obj as z.ZodObject<any>).partial();\n          }\n          const reference = references[refType.id];\n          if (reference === undefined) {\n            return z.unknown();\n            // throw new Error(`ref 참조 불가 ${refType.id}`);\n          }\n          return reference;\n        }\n        case \"union\": {\n          const unionType = paramType as {\n            t: string;\n            types: ApiParamType[];\n          };\n          // nullable 유니온\n          if (unionType.types.length === 2 && unionType.types.some((type) => type === \"null\")) {\n            if (unionType.types[0] === \"null\") {\n              return getZodTypeFromApiParamType(unionType.types[1], references).nullable();\n            } else {\n              return getZodTypeFromApiParamType(unionType.types[0], references).nullable();\n            }\n          }\n          // 일반 유니온\n          return z.union(\n            unionType.types.map((type) => getZodTypeFromApiParamType(type, references)),\n          );\n        }\n        case \"intersection\": {\n          const intersectionType = paramType as {\n            t: string;\n            types: ApiParamType[];\n          };\n          return intersectionType.types.reduce(\n            (result, type, index) => {\n              const resolvedType = getZodTypeFromApiParamType(type, references);\n              if (index === 0) {\n                return resolvedType;\n              } else {\n                return z.intersection(result, resolvedType);\n              }\n            },\n            z.unknown() as z.ZodType<unknown>,\n          );\n        }\n        case \"tuple-type\": {\n          const tupleType = paramType as ApiParamType.TupleType;\n          return z.tuple(\n            // biome-ignore lint/suspicious/noExplicitAny: 생성되는 ZodTuple의 타입을 추적하기 어려움\n            tupleType.elements.map((elem) => getZodTypeFromApiParamType(elem, references)) as any,\n          );\n        }\n      }\n      return z.unknown();\n    }\n  }\n}\n\n/**\n * ApiParam 배열을 ZodObject로 변환합니다.\n * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.\n */\nexport function getZodObjectFromApiParams(\n  apiParams: ApiParam[],\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n): z.ZodObject {\n  return z.object(\n    Object.fromEntries(\n      apiParams.map((param) => {\n        let zodType = getZodTypeFromApiParamType(param.type, references);\n        if (param.optional) {\n          zodType = zodType.optional();\n        }\n        return [param.name, zodType];\n      }),\n    ),\n  );\n}\n\n/**\n * ExtendedApi를 ZodObject로 변환합니다.\n * TypeParameter와 일반 파라미터를 처리하며,\n * Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.\n */\nexport function getZodObjectFromApi(\n  api: ExtendedApi,\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n) {\n  if (api.typeParameters?.length > 0) {\n    for (const typeParam of api.typeParameters) {\n      if (typeParam.constraint) {\n        const zodType = getZodTypeFromApiParamType(typeParam.constraint, references);\n\n        // FIXME: references는 글로벌 오브젝트로, typeParam.id(\"T\" 등)를 key로 이렇게 덮어씌워버리면 loadedTypes가 오염됨.\n        // biome-ignore lint/suspicious/noExplicitAny: 레퍼런스 타입 캐스팅\n        (references[typeParam.id] as z.ZodType<any>) = zodType;\n      }\n    }\n  }\n  const ReqType = getZodObjectFromApiParams(\n    // api parsing한 결과가 api params\n    api.parameters.filter(\n      (param) =>\n        !ApiParamType.isContext(param.type) &&\n        !ApiParamType.isRefKnex(param.type) &&\n        !(param.optional === true && param.name.startsWith(\"_\")), // _로 시작하는 파라미터는 제외\n    ),\n    references,\n  );\n  return ReqType;\n}\n\n/*\n * API 타입 정의를 TypeScript 코드 문자열로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 TypeScript 타입 문자열로 변환합니다.\n * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,\n * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.\n */\nexport function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string {\n  if (\n    [\n      \"string\",\n      \"number\",\n      \"boolean\",\n      \"true\",\n      \"false\",\n      \"null\",\n      \"undefined\",\n      \"void\",\n      \"any\",\n      \"unknown\",\n    ].includes(paramType as string)\n  ) {\n    return paramType as string;\n  } else if (ApiParamType.isObject(paramType)) {\n    return `{ ${apiParamToTsCode(paramType.props, injectImportKeys)} }`;\n  } else if (ApiParamType.isStringLiteral(paramType)) {\n    return `\"${paramType.value}\"`;\n  } else if (ApiParamType.isNumericLiteral(paramType)) {\n    return String(paramType.value);\n  } else if (ApiParamType.isUnion(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" | \");\n  } else if (ApiParamType.isIntersection(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" & \");\n  } else if (ApiParamType.isArray(paramType)) {\n    // intersection이나 union인 경우 괄호로 감싸기\n    const elementsType = apiParamTypeToTsType(paramType.elementsType, injectImportKeys);\n    return ApiParamType.isIntersection(paramType.elementsType) ||\n      ApiParamType.isUnion(paramType.elementsType)\n      ? `(${elementsType})[]`\n      : `${elementsType}[]`;\n  } else if (ApiParamType.isRef(paramType)) {\n    if ([\"Pick\", \"Omit\", \"Promise\", \"Partial\", \"Date\"].includes(paramType.id) === false) {\n      // importKeys 인젝션\n      injectImportKeys.push(paramType.id);\n    }\n    if (paramType.args === undefined || paramType.args.length === 0) {\n      return paramType.id;\n    } else {\n      return `${paramType.id}<${paramType.args\n        .map((arg) => apiParamTypeToTsType(arg, injectImportKeys))\n        .join(\",\")}>`;\n    }\n  } else if (ApiParamType.isIndexedAccess(paramType)) {\n    return `${apiParamTypeToTsType(\n      paramType.object,\n      injectImportKeys,\n    )}[${apiParamTypeToTsType(paramType.index, injectImportKeys)}]`;\n  } else if (ApiParamType.isTupleType(paramType)) {\n    return `[ ${paramType.elements.map((elem) => apiParamTypeToTsType(elem, injectImportKeys))} ]`;\n  } else if (ApiParamType.isTypeParam(paramType)) {\n    return `${paramType.id}${\n      paramType.constraint\n        ? ` extends ${apiParamTypeToTsType(paramType.constraint, injectImportKeys)}`\n        : \"\"\n    }`;\n  } else {\n    throw new Error(`resolve 불가 ApiParamType ${paramType}`);\n  }\n}\n\n/**\n * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.\n * 예: \"name: string, age?: number, active: boolean = true\"\n */\nexport function apiParamToTsCode(params: ApiParam[], injectImportKeys: string[]): string {\n  return params\n    .map((param) => {\n      return `${param.name}${\n        param.optional && !param.defaultDef ? \"?\" : \"\"\n      }: ${apiParamTypeToTsType(param.type, injectImportKeys)}${\n        param.defaultDef ? `= ${param.defaultDef}` : \"\"\n      }`;\n    })\n    .join(\", \");\n}\n\n/**\n * ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.\n * 예: \"{ name: string, age?: number, active: boolean = true }\"\n */\nexport function apiParamToTsCodeAsObject(params: ApiParam[], injectImportKeys: string[]): string {\n  return `{ ${params\n    .map(\n      (param) =>\n        `${param.name}${param.optional ? \"?\" : \"\"}: ${apiParamTypeToTsType(\n          param.type,\n          injectImportKeys,\n        )}${param.defaultDef ? `= ${param.defaultDef}` : \"\"}`,\n    )\n    .join(\", \")} }`;\n}\n"],"names":["z","ApiParamType","unwrapPromiseOnce","paramType","isPromise","args","getZodTypeFromApiParamType","references","string","number","boolean","advType","t","literal","value","objType","getZodObjectFromApiParams","props","arrType","array","elementsType","refType","id","date","includes","length","Error","obj","literalOrUnion","map","arg","keys","ZodUnion","def","options","option","values","keyRecord","Object","fromEntries","key","pick","omit","partial","reference","undefined","unknown","unionType","types","some","type","nullable","union","intersectionType","reduce","result","index","resolvedType","intersection","tupleType","tuple","elements","elem","apiParams","object","param","zodType","optional","name","getZodObjectFromApi","api","typeParameters","typeParam","constraint","ReqType","parameters","filter","isContext","isRefKnex","startsWith","apiParamTypeToTsType","injectImportKeys","isObject","apiParamToTsCode","isStringLiteral","isNumericLiteral","String","isUnion","join","isIntersection","isArray","isRef","push","isIndexedAccess","isTupleType","isTypeParam","params","defaultDef","apiParamToTsCodeAsObject"],"mappings":"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"}
+//#endregion
+init_code_converters();
+export { apiParamToTsCode, apiParamToTsCodeAsObject, apiParamTypeToTsType, getZodObjectFromApi, getZodObjectFromApiParams, getZodTypeFromApiParamType, init_code_converters, unwrapPromiseOnce };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-converters.js","names":["z","keys: string[]"],"sources":["../../src/api/code-converters.ts"],"sourcesContent":["/**\n * code-converters는 API 타입 정의들을 Zod 객체나 TypeScript 코드로 변환하는 함수들을 제공합니다.\n *\n * 1. API 시리즈들:\n * - ExtendedApi, ApiParam, ApiParamType\n * - API 메타데이터를 표현하는 타입 정의들\n *\n * 2. ZodObject 변환\n * - API 타입 정의 → Zod 타입 인스턴스 (런타임 밸리데이션용)\n * - getZodTypeFromApiParamType → getZodObjectFromApiParams → getZodObjectFromApi\n *\n * 3. TsTypeDef 변환\n * - API 타입 정의 → TypeScript 타입 코드 문자열 (코드 생성용)\n * - apiParamTypeToTsType → apiParamToTsCode, apiParamToTsCodeAsObject\n *\n * 참고:\n * - ZodTypeDef 생성 (Zod 코드 문자열): zod-converter.ts의 zodTypeToZodCode 사용\n * - EntityProp 변환: zod-converter.ts 참조\n */\n\nimport { z } from \"zod\";\n\nimport { ApiParamType } from \"../types/types\";\nimport { type ApiParam } from \"../types/types\";\nimport { type ExtendedApi } from \"./decorators\";\n\n// <any>를 자제하고, Zod에서 제약하는 기본적인 Generic Type Parameter를 사용함.\ntype AnyZodObject = z.ZodObject;\ntype AnyZodLiteral = z.ZodLiteral;\n\n/**\n * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.\n * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.\n */\nexport function unwrapPromiseOnce(paramType: ApiParamType) {\n  if (ApiParamType.isPromise(paramType)) {\n    return paramType.args?.[0];\n  } else {\n    return paramType;\n  }\n}\n\n/*\n * API를 구성하는 요소들을 ZodObject로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 Zod 타입 인스턴스로 변환합니다.\n * string, number, array, union 등 모든 ApiParamType을 처리하며,\n * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.\n */\nexport function getZodTypeFromApiParamType(\n  paramType: ApiParamType,\n  references: {\n    [id: string]: z.ZodType;\n  },\n): z.ZodType {\n  switch (paramType) {\n    case \"string\":\n      return z.string();\n    case \"number\":\n      return z.number();\n    case \"boolean\":\n      return z.boolean();\n    default: {\n      const advType = paramType as { t: string; value?: string | number };\n      switch (advType.t) {\n        case \"string-literal\":\n        case \"numeric-literal\":\n          return z.literal(advType.value);\n        case \"object\": {\n          const objType = paramType as { t: string; props: ApiParam[] };\n          return getZodObjectFromApiParams(objType.props);\n        }\n        case \"array\": {\n          const arrType = paramType as {\n            t: string;\n            elementsType: ApiParamType;\n          };\n          return z.array(getZodTypeFromApiParamType(arrType.elementsType, references));\n        }\n        case \"ref\": {\n          const refType = paramType as {\n            t: string;\n            id: string;\n            args?: ApiParamType[];\n          };\n          // Date 타입 처리\n          if (refType.id === \"Date\") {\n            return z.date();\n          }\n          // 객체 키 관리 유틸리티\n          if ([\"Pick\", \"Omit\"].includes(refType.id)) {\n            if (refType.args?.length !== 2) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const [obj, literalOrUnion] = refType.args.map(\n              (arg) => getZodTypeFromApiParamType(arg, references),\n              // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 생성되는 ZodUnion의 타입을 추적하기 어려움\n            ) as [AnyZodObject, z.ZodUnion<any> | AnyZodLiteral];\n\n            let keys: string[] = [];\n            if (literalOrUnion instanceof z.ZodUnion) {\n              keys = literalOrUnion.def.options.map(\n                (option: { def: { values: string[] } }) => option.def.values[0],\n              );\n            } else {\n              keys = (literalOrUnion as z.ZodLiteral<string>).def.values;\n            }\n            const keyRecord = Object.fromEntries(keys.map((key) => [key, true as const]));\n            if (refType.id === \"Pick\") {\n              if (obj.pick) {\n                // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Zod 4.3.6 pick 타입 호환성\n                return obj.pick(keyRecord as any);\n              }\n            } else {\n              if (obj.omit) {\n                // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Zod 4.3.6 omit 타입 호환성\n                return obj.omit(keyRecord as any);\n              }\n            }\n          }\n          if ([\"Partial\"].includes(refType.id)) {\n            if (refType.args?.length !== 1) {\n              throw new Error(`잘못된 ${refType.id}`);\n            }\n            const obj = getZodTypeFromApiParamType(refType.args[0], references);\n            // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- Partial 인수 타입 캐스팅\n            return (obj as z.ZodObject<any>).partial();\n          }\n          const reference = references[refType.id];\n          if (reference === undefined) {\n            return z.unknown();\n            // throw new Error(`ref 참조 불가 ${refType.id}`);\n          }\n          return reference;\n        }\n        case \"union\": {\n          const unionType = paramType as {\n            t: string;\n            types: ApiParamType[];\n          };\n          // nullable 유니온\n          if (unionType.types.length === 2 && unionType.types.some((type) => type === \"null\")) {\n            if (unionType.types[0] === \"null\") {\n              return getZodTypeFromApiParamType(unionType.types[1], references).nullable();\n            } else {\n              return getZodTypeFromApiParamType(unionType.types[0], references).nullable();\n            }\n          }\n          // 일반 유니온\n          return z.union(\n            unionType.types.map((type) => getZodTypeFromApiParamType(type, references)),\n          );\n        }\n        case \"intersection\": {\n          const intersectionType = paramType as {\n            t: string;\n            types: ApiParamType[];\n          };\n          return intersectionType.types.reduce((result, type, index) => {\n            const resolvedType = getZodTypeFromApiParamType(type, references);\n            if (index === 0) {\n              return resolvedType;\n            } else {\n              return z.intersection(result, resolvedType);\n            }\n          }, z.unknown() as z.ZodType);\n        }\n        case \"tuple-type\": {\n          const tupleType = paramType as ApiParamType.TupleType;\n          return z.tuple(\n            // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 생성되는 ZodTuple의 타입을 추적하기 어려움\n            tupleType.elements.map((elem) => getZodTypeFromApiParamType(elem, references)) as any,\n          );\n        }\n      }\n      return z.unknown();\n    }\n  }\n}\n\n/**\n * ApiParam 배열을 ZodObject로 변환합니다.\n * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.\n */\nexport function getZodObjectFromApiParams(\n  apiParams: ApiParam[],\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n): z.ZodObject {\n  return z.object(\n    Object.fromEntries(\n      apiParams.map((param) => {\n        let zodType = getZodTypeFromApiParamType(param.type, references);\n        if (param.optional) {\n          zodType = zodType.optional();\n        }\n        return [param.name, zodType];\n      }),\n    ),\n  );\n}\n\n/**\n * ExtendedApi를 ZodObject로 변환합니다.\n * TypeParameter와 일반 파라미터를 처리하며,\n * Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.\n */\nexport function getZodObjectFromApi(\n  api: ExtendedApi,\n  references: {\n    [id: string]: z.ZodType;\n  } = {},\n) {\n  if (api.typeParameters?.length > 0) {\n    for (const typeParam of api.typeParameters) {\n      if (typeParam.constraint) {\n        const zodType = getZodTypeFromApiParamType(typeParam.constraint, references);\n\n        // FIXME: references는 글로벌 오브젝트로, typeParam.id(\"T\" 등)를 key로 이렇게 덮어씌워버리면 loadedTypes가 오염됨.\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 레퍼런스 타입 캐스팅\n        (references[typeParam.id] as z.ZodType<any>) = zodType;\n      }\n    }\n  }\n  const ReqType = getZodObjectFromApiParams(\n    // api parsing한 결과가 api params\n    api.parameters.filter(\n      (param) =>\n        !ApiParamType.isContext(param.type) &&\n        !ApiParamType.isRefKnex(param.type) &&\n        !(param.optional && param.name.startsWith(\"_\")), // _로 시작하는 파라미터는 제외\n    ),\n    references,\n  );\n  return ReqType;\n}\n\n/*\n * API 타입 정의를 TypeScript 코드 문자열로 변환하기 위한 함수들입니다.\n */\n\n/**\n * ApiParamType을 TypeScript 타입 문자열로 변환합니다.\n * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,\n * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.\n */\nexport function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string {\n  if (\n    [\n      \"string\",\n      \"number\",\n      \"boolean\",\n      \"true\",\n      \"false\",\n      \"null\",\n      \"undefined\",\n      \"void\",\n      \"any\",\n      \"unknown\",\n    ].includes(paramType as string)\n  ) {\n    return paramType as string;\n  } else if (ApiParamType.isObject(paramType)) {\n    return `{ ${apiParamToTsCode(paramType.props, injectImportKeys)} }`;\n  } else if (ApiParamType.isStringLiteral(paramType)) {\n    return `\"${paramType.value}\"`;\n  } else if (ApiParamType.isNumericLiteral(paramType)) {\n    return String(paramType.value);\n  } else if (ApiParamType.isUnion(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" | \");\n  } else if (ApiParamType.isIntersection(paramType)) {\n    return paramType.types.map((type) => apiParamTypeToTsType(type, injectImportKeys)).join(\" & \");\n  } else if (ApiParamType.isArray(paramType)) {\n    // intersection이나 union인 경우 괄호로 감싸기\n    const elementsType = apiParamTypeToTsType(paramType.elementsType, injectImportKeys);\n    return ApiParamType.isIntersection(paramType.elementsType) ||\n      ApiParamType.isUnion(paramType.elementsType)\n      ? `(${elementsType})[]`\n      : `${elementsType}[]`;\n  } else if (ApiParamType.isRef(paramType)) {\n    if (![\"Pick\", \"Omit\", \"Promise\", \"Partial\", \"Date\"].includes(paramType.id)) {\n      // importKeys 인젝션\n      injectImportKeys.push(paramType.id);\n    }\n    if (paramType.args === undefined || paramType.args.length === 0) {\n      return paramType.id;\n    } else {\n      return `${paramType.id}<${paramType.args\n        .map((arg) => apiParamTypeToTsType(arg, injectImportKeys))\n        .join(\",\")}>`;\n    }\n  } else if (ApiParamType.isIndexedAccess(paramType)) {\n    return `${apiParamTypeToTsType(\n      paramType.object,\n      injectImportKeys,\n    )}[${apiParamTypeToTsType(paramType.index, injectImportKeys)}]`;\n  } else if (ApiParamType.isTupleType(paramType)) {\n    return `[ ${paramType.elements.map((elem) => apiParamTypeToTsType(elem, injectImportKeys))} ]`;\n  } else if (ApiParamType.isTypeParam(paramType)) {\n    return `${paramType.id}${\n      paramType.constraint\n        ? ` extends ${apiParamTypeToTsType(paramType.constraint, injectImportKeys)}`\n        : \"\"\n    }`;\n  } else {\n    throw new Error(`resolve 불가 ApiParamType ${paramType}`);\n  }\n}\n\n/**\n * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.\n * 예: \"name: string, age?: number, active: boolean = true\"\n */\nexport function apiParamToTsCode(params: ApiParam[], injectImportKeys: string[]): string {\n  return params\n    .map((param) => {\n      return `${param.name}${\n        param.optional && !param.defaultDef ? \"?\" : \"\"\n      }: ${apiParamTypeToTsType(param.type, injectImportKeys)}${\n        param.defaultDef ? `= ${param.defaultDef}` : \"\"\n      }`;\n    })\n    .join(\", \");\n}\n\n/**\n * ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.\n * 예: \"{ name: string, age?: number, active: boolean = true }\"\n */\nexport function apiParamToTsCodeAsObject(params: ApiParam[], injectImportKeys: string[]): string {\n  return `{ ${params\n    .map(\n      (param) =>\n        `${param.name}${param.optional ? \"?\" : \"\"}: ${apiParamTypeToTsType(\n          param.type,\n          injectImportKeys,\n        )}${param.defaultDef ? `= ${param.defaultDef}` : \"\"}`,\n    )\n    .join(\", \")} }`;\n}\n"],"mappings":"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"}