sonamu 0.6.0 → 0.7.1

package/dist/ai/providers/rtzr/options.js

@@ -0,0 +1,47 @@
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+const rtzrOptionsShape = {
+    domain: z.enum([
+        "CALL",
+        "GENERAL"
+    ]).default("GENERAL"),
+    language: z.string(),
+    languageCandidates: z.array(z.string()).optional(),
+    keywords: z.union([
+        z.string(),
+        z.array(z.string())
+    ]).optional(),
+    paragraphSplitterMax: z.number().optional(),
+    diarization: z.boolean().optional(),
+    itn: z.boolean().optional(),
+    diarizationSpkCount: z.number().optional(),
+    disfluencyFilter: z.boolean().optional(),
+    paragraphSplitter: z.boolean().optional(),
+    profanityFilter: z.boolean().optional(),
+    wordTimestamp: z.boolean().optional()
+};
+const rtzrOptionsMap = {
+    domain: "domain",
+    language: "language",
+    languageCandidates: "language_candidates",
+    keywords: "keywords",
+    paragraphSplitterMax: "paragraph_splitter.max",
+    diarization: "use_diarization",
+    itn: "use_itn",
+    diarizationSpkCount: "diarization.spk_count",
+    disfluencyFilter: "use_disfluency_filter",
+    paragraphSplitter: "use_paragraph_splitter",
+    profanityFilter: "use_profanity_filter",
+    wordTimestamp: "use_word_timestamp"
+};
+// https://developers.rtzr.ai/docs/stt-file/
+export const rtzrTranscriptionProviderOptions = lazySchema(()=>zodSchema(z.object(rtzrOptionsShape).transform((item)=>{
+        return Object.fromEntries(Object.entries(item).map(([key, value])=>{
+            return [
+                rtzrOptionsMap[key],
+                value
+            ];
+        }));
+    })));
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ai/providers/rtzr/provider.d.ts

@@ -0,0 +1,18 @@
+import { type ProviderV3, type TranscriptionModelV3 } from "@ai-sdk/provider";
+import { type FetchFunction } from "@ai-sdk/provider-utils";
+import type { RtzrTranscriptionModelId } from "./options";
+export interface RtzrProvider extends ProviderV3 {
+    (modelId: RtzrTranscriptionModelId): TranscriptionModelV3;
+    transcription(modelId: RtzrTranscriptionModelId): TranscriptionModelV3;
+}
+export interface RtzrProviderSettings {
+    baseURL?: string;
+    clientId?: string;
+    clientSecret?: string;
+    headers?: Record<string, string>;
+    name?: string;
+    fetch?: FetchFunction;
+}
+export declare function createRtzr(options?: RtzrProviderSettings): RtzrProvider;
+export declare const rtzr: RtzrProvider;
+//# sourceMappingURL=provider.d.ts.map

package/dist/ai/providers/rtzr/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAChG,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAE1D,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;IAC1D,aAAa,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC;CACxE;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,wBAAgB,UAAU,CAAC,OAAO,GAAE,oBAAyB,GAAG,YAAY,CA+D3E;AAED,eAAO,MAAM,IAAI,cAAe,CAAC"}

package/dist/ai/providers/rtzr/provider.js

@@ -0,0 +1,54 @@
+import { NoSuchModelError } from "@ai-sdk/provider";
+import { loadApiKey, loadOptionalSetting, withoutTrailingSlash, withUserAgentSuffix } from "@ai-sdk/provider-utils";
+import { RtzrTranscriptionModel } from "./model.js";
+export function createRtzr(options = {}) {
+    const baseURL = withoutTrailingSlash(loadOptionalSetting({
+        settingValue: options.baseURL,
+        environmentVariableName: "RTZR_BASE_URL"
+    })) ?? "https://openapi.vito.ai/v1";
+    const providerName = options.name ?? "rtzr";
+    const getHeaders = ()=>withUserAgentSuffix({
+            ...options.headers
+        }, `cartanova-ai/rtzr-api-provider`);
+    const createTranscriptionModel = (modelId)=>{
+        const clientId = loadApiKey({
+            apiKey: options.clientId,
+            environmentVariableName: "RTZR_CLIENT_ID",
+            description: "RTZR"
+        });
+        const clientSecret = loadApiKey({
+            apiKey: options.clientSecret,
+            environmentVariableName: "RTZR_CLIENT_SECRET",
+            description: "RTZR"
+        });
+        return new RtzrTranscriptionModel(modelId, {
+            provider: `${providerName}.transcription`,
+            auth: {
+                clientId,
+                clientSecret
+            },
+            url: ({ path })=>`${baseURL}${path}`,
+            headers: getHeaders,
+            fetch: options.fetch
+        });
+    };
+    const provider = (modelId)=>createTranscriptionModel(modelId);
+    provider.specificationVersion = "v3";
+    provider.transcription = createTranscriptionModel;
+    provider.transcriptionModel = createTranscriptionModel;
+    const handleUnsupportedTypes = (modelType)=>{
+        return (modelId)=>{
+            throw new NoSuchModelError({
+                modelId,
+                modelType
+            });
+        };
+    };
+    provider.languageModel = handleUnsupportedTypes("languageModel");
+    provider.embeddingModel = handleUnsupportedTypes("embeddingModel");
+    provider.imageModel = handleUnsupportedTypes("imageModel");
+    return provider;
+}
+export const rtzr = createRtzr();
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ai/providers/rtzr/utils.d.ts

@@ -0,0 +1,19 @@
+import { type FetchFunction, type ResponseHandler } from "@ai-sdk/provider-utils";
+export declare function handleFetchError({ error, url, requestBodyValues, }: {
+    error: unknown;
+    url: string;
+    requestBodyValues: unknown;
+}): unknown;
+export declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, }: {
+    url: string;
+    headers?: Record<string, string | undefined>;
+    failedResponseHandler: ResponseHandler<Error>;
+    successfulResponseHandler: ResponseHandler<T>;
+    abortSignal?: AbortSignal;
+    fetch?: FetchFunction;
+}) => Promise<{
+    value: T;
+    rawValue?: unknown;
+    responseHeaders?: Record<string, string>;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ai/providers/rtzr/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/ai/providers/rtzr/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,GAAG,EACH,iBAAiB,GAClB,EAAE;IACD,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,EAAE,OAAO,CAAC;CAC5B,WAuBA;AAKD,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,yFAOjC;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,qBAAqB,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAC9C,yBAAyB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC9C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;;;;EAiEA,CAAC"}

package/dist/ai/providers/rtzr/utils.js

@@ -0,0 +1,88 @@
+import { APICallError } from "@ai-sdk/provider";
+import { extractResponseHeaders, isAbortError, withUserAgentSuffix } from "@ai-sdk/provider-utils";
+const FETCH_FAILED_ERROR_MESSAGES = [
+    "fetch failed",
+    "failed to fetch"
+];
+export function handleFetchError({ error, url, requestBodyValues }) {
+    if (isAbortError(error)) {
+        return error;
+    }
+    if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
+        const cause = error.cause;
+        if (cause != null) {
+            return new APICallError({
+                message: `Cannot connect to API: ${cause.message}`,
+                cause,
+                url,
+                requestBodyValues,
+                isRetryable: true
+            });
+        }
+    }
+    return error;
+}
+// use function to allow for mocking in tests:
+const getOriginalFetch = ()=>globalThis.fetch;
+export const getFromApi = async ({ url, headers = {}, successfulResponseHandler, failedResponseHandler, abortSignal, fetch = getOriginalFetch() })=>{
+    try {
+        const response = await fetch(url, {
+            method: "GET",
+            headers: withUserAgentSuffix(headers, `cartanova-ai/rtzr-api-provider`),
+            signal: abortSignal
+        });
+        const responseHeaders = extractResponseHeaders(response);
+        if (!response.ok) {
+            let errorInformation;
+            try {
+                errorInformation = await failedResponseHandler({
+                    response,
+                    url,
+                    requestBodyValues: {}
+                });
+            } catch (error) {
+                if (isAbortError(error) || APICallError.isInstance(error)) {
+                    throw error;
+                }
+                throw new APICallError({
+                    message: "Failed to process error response",
+                    cause: error,
+                    statusCode: response.status,
+                    url,
+                    responseHeaders,
+                    requestBodyValues: {}
+                });
+            }
+            throw errorInformation.value;
+        }
+        try {
+            return await successfulResponseHandler({
+                response,
+                url,
+                requestBodyValues: {}
+            });
+        } catch (error) {
+            if (error instanceof Error) {
+                if (isAbortError(error) || APICallError.isInstance(error)) {
+                    throw error;
+                }
+            }
+            throw new APICallError({
+                message: "Failed to process successful response",
+                cause: error,
+                statusCode: response.status,
+                url,
+                responseHeaders,
+                requestBodyValues: {}
+            });
+        }
+    } catch (error) {
+        throw handleFetchError({
+            error,
+            url,
+            requestBodyValues: {}
+        });
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/base-frame.d.ts

@@ -1,5 +1,5 @@
-import { Knex } from "knex";
-import { DBPreset } from "../database/db";
+import type { Knex } from "knex";
+import type { DBPreset } from "../database/db";
 import { UpsertBuilder } from "../database/upsert-builder";
 export declare abstract class BaseFrameClass {
     getDB(which: DBPreset): Knex;

package/dist/api/base-frame.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-frame.d.ts","sourceRoot":"","sources":["../../src/api/base-frame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAM,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,8BAAsB,cAAc;IAClC,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI5B,gBAAgB;CAGjB"}
+{"version":3,"file":"base-frame.d.ts","sourceRoot":"","sources":["../../src/api/base-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,8BAAsB,cAAc;IAClC,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI5B,gBAAgB;CAGjB"}

package/dist/api/base-frame.js

@@ -1,3 +1,4 @@
+// Static imports kept for non-async functions (getDB, getUpsertBuilder)
 import { DB } from "../database/db.js";
 import { UpsertBuilder } from "../database/upsert-builder.js";
 export class BaseFrameClass {
@@ -9,4 +10,4 @@ export class BaseFrameClass {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvYmFzZS1mcmFtZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBLbmV4IH0gZnJvbSBcImtuZXhcIjtcbmltcG9ydCB7IERCLCBEQlByZXNldCB9IGZyb20gXCIuLi9kYXRhYmFzZS9kYlwiO1xuaW1wb3J0IHsgVXBzZXJ0QnVpbGRlciB9IGZyb20gXCIuLi9kYXRhYmFzZS91cHNlcnQtYnVpbGRlclwiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZUZyYW1lQ2xhc3Mge1xuICBnZXREQih3aGljaDogREJQcmVzZXQpOiBLbmV4IHtcbiAgICByZXR1cm4gREIuZ2V0REIod2hpY2gpO1xuICB9XG5cbiAgZ2V0VXBzZXJ0QnVpbGRlcigpIHtcbiAgICByZXR1cm4gbmV3IFVwc2VydEJ1aWxkZXIoKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbIkRCIiwiVXBzZXJ0QnVpbGRlciIsIkJhc2VGcmFtZUNsYXNzIiwiZ2V0REIiLCJ3aGljaCIsImdldFVwc2VydEJ1aWxkZXIiXSwibWFwcGluZ3MiOiJBQUNBLFNBQVNBLEVBQUUsUUFBa0Isb0JBQWlCO0FBQzlDLFNBQVNDLGFBQWEsUUFBUSxnQ0FBNkI7QUFFM0QsT0FBTyxNQUFlQztJQUNwQkMsTUFBTUMsS0FBZSxFQUFRO1FBQzNCLE9BQU9KLEdBQUdHLEtBQUssQ0FBQ0M7SUFDbEI7SUFFQUMsbUJBQW1CO1FBQ2pCLE9BQU8sSUFBSUo7SUFDYjtBQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvYmFzZS1mcmFtZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEtuZXggfSBmcm9tIFwia25leFwiO1xuaW1wb3J0IHR5cGUgeyBEQlByZXNldCB9IGZyb20gXCIuLi9kYXRhYmFzZS9kYlwiO1xuLy8gU3RhdGljIGltcG9ydHMga2VwdCBmb3Igbm9uLWFzeW5jIGZ1bmN0aW9ucyAoZ2V0REIsIGdldFVwc2VydEJ1aWxkZXIpXG5pbXBvcnQgeyBEQiB9IGZyb20gXCIuLi9kYXRhYmFzZS9kYlwiO1xuaW1wb3J0IHsgVXBzZXJ0QnVpbGRlciB9IGZyb20gXCIuLi9kYXRhYmFzZS91cHNlcnQtYnVpbGRlclwiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZUZyYW1lQ2xhc3Mge1xuICBnZXREQih3aGljaDogREJQcmVzZXQpOiBLbmV4IHtcbiAgICByZXR1cm4gREIuZ2V0REIod2hpY2gpO1xuICB9XG5cbiAgZ2V0VXBzZXJ0QnVpbGRlcigpIHtcbiAgICByZXR1cm4gbmV3IFVwc2VydEJ1aWxkZXIoKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbIkRCIiwiVXBzZXJ0QnVpbGRlciIsIkJhc2VGcmFtZUNsYXNzIiwiZ2V0REIiLCJ3aGljaCIsImdldFVwc2VydEJ1aWxkZXIiXSwibWFwcGluZ3MiOiJBQUVBLHdFQUF3RTtBQUN4RSxTQUFTQSxFQUFFLFFBQVEsb0JBQWlCO0FBQ3BDLFNBQVNDLGFBQWEsUUFBUSxnQ0FBNkI7QUFFM0QsT0FBTyxNQUFlQztJQUNwQkMsTUFBTUMsS0FBZSxFQUFRO1FBQzNCLE9BQU9KLEdBQUdHLEtBQUssQ0FBQ0M7SUFDbEI7SUFFQUMsbUJBQW1CO1FBQ2pCLE9BQU8sSUFBSUo7SUFDYjtBQUNGIn0=

package/dist/api/caster.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"caster.d.ts","sourceRoot":"","sources":["../../src/api/caster.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAyB5C,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,CAuDvD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,wEAIrD"}
+{"version":3,"file":"caster.d.ts","sourceRoot":"","sources":["../../src/api/caster.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AA0B5C,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,CA8CvD;AAGD,wBAAgB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,wEAKrD"}

package/dist/api/caster.js

@@ -18,6 +18,7 @@ function isZodNumberAnyway(zodType) {
     return false;
 }
 // ZodType을 이용해 raw를 Type Coercing
+// biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
 export function caster(zodType, raw) {
     if (isZodNumberAnyway(zodType) && typeof raw === "string") {
         // number
@@ -27,6 +28,7 @@ export function caster(zodType, raw) {
         if (Array.isArray(raw)) {
             const numType = zodType.options.find((opt)=>isNumberType(opt));
             assert(numType !== undefined);
+            // biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
             return raw.map((elem)=>caster(numType, elem));
         } else {
             return Number(raw);
@@ -36,6 +38,7 @@ export function caster(zodType, raw) {
         return raw === "true";
     } else if (raw !== null && Array.isArray(raw) && zodType instanceof z.ZodArray) {
         // array
+        // biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
         return raw.map((elem)=>caster(zodType.element, elem));
     } else if (zodType instanceof z.ZodObject && typeof raw === "object" && raw !== null) {
         // object
@@ -57,10 +60,12 @@ export function caster(zodType, raw) {
         return raw;
     }
 }
+// biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
 export function fastifyCaster(schema) {
+    // biome-ignore lint/suspicious/noExplicitAny: 캐스팅에는 any가 필요함.
     return z.preprocess((raw)=>{
         return caster(schema, raw);
     }, schema);
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/code-converters.d.ts

@@ -1,26 +1,70 @@
+/**
+ * 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 type { $ZodLooseShape } from "zod/v4/core";
-import { ApiParam, ApiParamType, EntityProp, EntityPropNode, TextProp } from "../types/types";
-import { ExtendedApi } from "./decorators";
+import { type ApiParam, ApiParamType } from "../types/types";
+import type { ExtendedApi } from "./decorators";
 type AnyZodObject = z.ZodObject<$ZodLooseShape>;
-export declare function getZodObjectFromApi(api: ExtendedApi, references?: {
+/**
+ * Promise 타입을 한 번 언래핑하여 내부 타입을 반환합니다.
+ * Promise가 아닌 경우 원본 타입을 그대로 반환합니다.
+ */
+export declare function unwrapPromiseOnce(paramType: ApiParamType): ApiParamType | undefined;
+/**
+ * ApiParamType을 Zod 타입 인스턴스로 변환합니다.
+ * string, number, array, union 등 모든 ApiParamType을 처리하며,
+ * 순환참조가 발생하는 경우 z.unknown()으로 fallback합니다.
+ */
+export declare function getZodTypeFromApiParamType(paramType: ApiParamType, references: {
     [id: string]: AnyZodObject;
-}): z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>;
+}): z.ZodType<unknown>;
+/**
+ * ApiParam 배열을 ZodObject로 변환합니다.
+ * 각 파라미터의 optional 여부를 반영하여 Zod 스키마를 생성합니다.
+ */
 export declare function getZodObjectFromApiParams(apiParams: ApiParam[], references?: {
     [id: string]: AnyZodObject;
 }): z.ZodObject;
-export declare function getZodTypeFromApiParamType(paramType: ApiParamType, references: {
+/**
+ * ExtendedApi를 ZodObject로 변환합니다.
+ * TypeParameter와 일반 파라미터를 처리하며,
+ * Context, RefKnex, _로 시작하는 optional 파라미터는 제외합니다.
+ */
+export declare function getZodObjectFromApi(api: ExtendedApi, references?: {
     [id: string]: AnyZodObject;
-}): z.ZodType<unknown>;
-export declare function propNodeToZodTypeDef(propNode: EntityPropNode, injectImportKeys: string[]): string;
-export declare function getTextTypeLength(textType: TextProp["textType"]): number;
-export declare function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]): string;
-export declare function zodTypeToZodCode(zt: z.ZodType): string;
+}): z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>;
+/**
+ * ApiParamType을 TypeScript 타입 문자열로 변환합니다.
+ * union, intersection, array, ref 등 모든 타입을 TS 문법으로 표현하며,
+ * import가 필요한 타입 ID는 injectImportKeys에 수집합니다.
+ */
+export declare function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string;
+/**
+ * ApiParam 배열을 TypeScript 함수 파라미터 코드로 변환합니다.
+ * 예: "name: string, age?: number, active: boolean = true"
+ */
 export declare function apiParamToTsCode(params: ApiParam[], injectImportKeys: string[]): string;
+/**
+ * ApiParam 배열을 TypeScript 객체 타입 코드로 변환합니다.
+ * 예: "{ name: string, age?: number, active: boolean = true }"
+ */
 export declare function apiParamToTsCodeAsObject(params: ApiParam[], injectImportKeys: string[]): string;
-export declare function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string;
-export declare function unwrapPromiseOnce(paramType: ApiParamType): ApiParamType;
-export declare function serializeZodType(zt: z.ZodType): any;
-export declare function zodTypeToTsTypeDef(zt: z.ZodType): string;
 export {};
 //# sourceMappingURL=code-converters.d.ts.map

package/dist/api/code-converters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-converters.d.ts","sourceRoot":"","sources":["../../src/api/code-converters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EAoBT,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAK3C,KAAK,YAAY,GAAG,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;AAWhD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,WAAW,EAChB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;CACvB,qDAwBP;AAKD,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,EAAE,EACrB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;CACvB,GACL,CAAC,CAAC,SAAS,CAab;AAKD,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,YAAY,EACvB,UAAU,EAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;CAC5B,GACA,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAwIpB;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,cAAc,EACxB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CA8BR;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,MAAM,CASxE;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,UAAU,EAChB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CAyDR;AAGD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,GAAG,MAAM,CAyFtD;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,QAAQ,EAAE,EAClB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CAUR;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,QAAQ,EAAE,EAClB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CAUR;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,YAAY,EACvB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CAsER;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,YAAY,gBAMxD;AAGD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,GAAG,GAAG,CAuEnD;AAGD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,GAAG,MAAM,CA8DxD"}
+{"version":3,"file":"code-converters.d.ts","sourceRoot":"","sources":["../../src/api/code-converters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,KAAK,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,KAAK,YAAY,GAAG,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;AAGhD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,YAAY,4BAMxD;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,YAAY,EACvB,UAAU,EAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;CAC5B,GACA,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CA6HpB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,EAAE,EACrB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;CACvB,GACL,CAAC,CAAC,SAAS,CAYb;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,WAAW,EAChB,UAAU,GAAE;IACV,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;CACvB,qDAsBP;AAMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAwDhG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAUvF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,MAAM,CAU/F"}