@ir-kit/openapi-kotlin 0.1.0

package/dist/ir/operations.js

@@ -0,0 +1,124 @@
+import { pascal } from "@ir-kit/codegen-core";
+import { iterOperations } from "@ir-kit/openapi";
+import { ktArg, ktCall, ktExprStmt, ktFun, ktIdent, ktInterface, ktMember, ktRef, ktReturn, ktTopLevelFun, } from "../kt-dsl/index.js";
+import { buildClientClass } from "./impl/index.js";
+import { operationSignature, } from "./operation/index.js";
+/**
+ * Translate `IR.Model.paths` into Kotlin interfaces (one per tag) and
+ * matching OkHttp + kotlinx-serialization impl classes. Inline body /
+ * response / param schemas are promoted to synthetic top-level decls
+ * in the same output array.
+ */
+export function operationsToDecls(paths, opts = {}) {
+    const defaultTag = opts.defaultTag ?? "Default";
+    const interfaceName = opts.interfaceName ?? ((tag) => `${pascal(tag)}Api`);
+    const clientClassName = opts.clientClassName ?? ((p) => `OkHttp${p}`);
+    const decls = [];
+    const emit = (d) => decls.push(d);
+    const byTag = new Map();
+    for (const { pathStr, method, op, schemeNames } of iterOperations(paths, opts.securitySchemeNames)) {
+        const sig = operationSignature(op, method, pathStr, emit, schemeNames);
+        const tag = op.tags?.[0] ?? defaultTag;
+        const list = byTag.get(tag);
+        if (list)
+            list.push(sig);
+        else
+            byTag.set(tag, [sig]);
+    }
+    let needsMultipart = false;
+    let needsAuth = false;
+    for (const [tag, sigs] of byTag) {
+        const ifaceName = interfaceName(tag);
+        const allSigs = sigs.flatMap((s) => [
+            s,
+            withResponseSignature(s),
+        ]);
+        decls.push(ktInterface({
+            name: ifaceName,
+            funs: allSigs.map(signatureToInterfaceFun),
+        }));
+        for (const sig of allSigs) {
+            decls.push(ktTopLevelFun(signatureToConvenienceFun(sig, ifaceName)));
+        }
+        if (sigs.some(hasSecurity))
+            needsAuth = true;
+        if (!opts.interfaceOnly) {
+            const result = buildClientClass(clientClassName(ifaceName), ifaceName, allSigs, {
+                open: opts.openImpl,
+            });
+            decls.push(result.class);
+            if (result.needsMultipart)
+                needsMultipart = true;
+        }
+    }
+    return { decls, needsMultipart, needsAuth };
+}
+/**
+ * Derive the `*WithResponse` companion of a signature: name suffix
+ * `WithResponse`, and return type wraps the original alongside
+ * OkHttp's `Response`. Void operations bundle to just `Response`
+ * (no payload to pair with).
+ */
+function withResponseSignature(sig) {
+    return {
+        ...sig,
+        name: `${sig.name}WithResponse`,
+        returnType: withResponseReturnType(sig.returnType),
+    };
+}
+function withResponseReturnType(t) {
+    const isUnit = t.kind === "primitive" && t.name === "Unit";
+    return isUnit ? ktRef("Response") : ktRef("Pair", [t, ktRef("Response")]);
+}
+function hasSecurity(sig) {
+    return sig.securitySchemeNames.length > 0;
+}
+/**
+ * Strip defaults from interface-fun parameters. Kotlin allows defaults
+ * on interface methods, but the convention is to keep interface
+ * signatures lean and put defaults on the implementation; the
+ * convenience extension below provides the no-options overload.
+ */
+function signatureToInterfaceFun(sig) {
+    const ifaceParams = sig.params.map((p) => p.default === undefined ? p : { ...p, default: undefined });
+    return ktFun({
+        name: sig.name,
+        params: ifaceParams,
+        returnType: sig.returnType,
+        modifiers: ["suspend"],
+        doc: sig.doc,
+        // No body — interface requirement.
+    });
+}
+/**
+ * Convenience overload emitted as a top-level extension fun. Drops the
+ * trailing `options` param and forwards with `RequestOptions()` defaults.
+ *
+ * @example
+ * ```kotlin
+ * public suspend fun PetApi.getPetById(petId: Long): Pet {
+ *     return getPetById(petId = petId, options = RequestOptions())
+ * }
+ * ```
+ */
+function signatureToConvenienceFun(sig, receiverName) {
+    // Drop the trailing options param — that's the whole point of the overload.
+    const baseParams = sig.params.slice(0, -1).map((p) => 
+    // The convenience overload also drops defaults — when callers reach
+    // for it, they already opted into the no-options shape.
+    p.default === undefined ? p : { ...p, default: undefined });
+    const callArgs = baseParams.map((p) => ktArg(ktIdent(p.name), p.name));
+    callArgs.push(ktArg(ktCall(ktIdent("RequestOptions"), []), "options"));
+    const forwarded = ktCall(ktMember(ktIdent("this"), sig.name), callArgs);
+    const isUnit = sig.returnType.kind === "primitive" && sig.returnType.name === "Unit";
+    return ktFun({
+        name: sig.name,
+        params: baseParams,
+        returnType: sig.returnType,
+        modifiers: ["suspend"],
+        doc: sig.doc,
+        receiver: ktRef(receiverName),
+        body: [isUnit ? ktExprStmt(forwarded) : ktReturn(forwarded)],
+    });
+}
+//# sourceMappingURL=operations.js.map

package/dist/ir/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sourceRoot":"","sources":["../../src/ir/operations.ts"],"names":[],"mappings":"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"}

package/dist/ir/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export type { RuntimeFile, RuntimeOpts } from "./templates.js";
+export { apiClientKt, buildRuntimeFiles } from "./templates.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ir/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ir/runtime/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/ir/runtime/index.js

@@ -0,0 +1,2 @@
+export { apiClientKt, buildRuntimeFiles } from "./templates.js";
+//# sourceMappingURL=index.js.map

package/dist/ir/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ir/runtime/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/ir/runtime/templates.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Runtime helper sources. These files ship verbatim into every generated
+ * SDK — no spec-driven content beyond the package name. Encoding them as
+ * fixed Kotlin strings (rather than DSL-built) keeps the codegen surface
+ * small: the DSL only has to model what the per-operation impl actually
+ * uses.
+ *
+ * Convention: `__PACKAGE__` is replaced by the consumer-chosen package
+ * name during `buildRuntimeFiles(...)`.
+ */
+export interface RuntimeOpts {
+    /** Emit `var auth: MutableMap<String, Auth>` on `APIClient` and the
+     *  `Auth` / `APIKeyLocation` files. Set when the spec declares any
+     *  `securitySchemes`. */
+    hasAuth: boolean;
+    /** Emit the `multipart/form-data` helper. Set when at least one op has
+     *  a `multipart/form-data` body. */
+    hasMultipart: boolean;
+    /** Emit the `application/x-www-form-urlencoded` helper file (`FormUrlEncoder`
+     *  object). Currently this is folded into ad-hoc `FormBody.Builder` calls
+     *  in the impl, so we don't ship a dedicated runtime file for it. */
+    hasFormUrlEncoded: boolean;
+}
+export interface RuntimeFile {
+    name: string;
+    content: string;
+}
+export declare function apiClientKt(opts: RuntimeOpts): string;
+/** Ordered runtime files. The orchestrator places them under `API/`. */
+export declare function buildRuntimeFiles(opts: RuntimeOpts, pkg: string): RuntimeFile[];
+//# sourceMappingURL=templates.d.ts.map

package/dist/ir/runtime/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/ir/runtime/templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,WAAW;IAC1B;;6BAEyB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB;wCACoC;IACpC,YAAY,EAAE,OAAO,CAAC;IACtB;;yEAEqE;IACrE,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AA+YD,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAKrD;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,GACV,WAAW,EAAE,CAwBf"}

package/dist/ir/runtime/templates.js

@@ -0,0 +1,431 @@
+/**
+ * Runtime helper sources. These files ship verbatim into every generated
+ * SDK — no spec-driven content beyond the package name. Encoding them as
+ * fixed Kotlin strings (rather than DSL-built) keeps the codegen surface
+ * small: the DSL only has to model what the per-operation impl actually
+ * uses.
+ *
+ * Convention: `__PACKAGE__` is replaced by the consumer-chosen package
+ * name during `buildRuntimeFiles(...)`.
+ */
+const API_INTERCEPTORS_KT = `package __PACKAGE__
+
+import okhttp3.Request
+
+/**
+ * Bag of per-request mutation hooks. Mirrors hey-api's TS client where
+ * \`client.interceptors.request.use(fn)\` registers an interceptor that
+ * runs against every outgoing request. Multiple interceptors compose —
+ * auth, logging, and tracing all coexist as separate entries instead
+ * of being chained inside one closure.
+ */
+public class APIInterceptors {
+    public val request: MutableList<suspend (Request) -> Request> = mutableListOf()
+}
+`;
+const API_ERROR_KT = `package __PACKAGE__
+
+/**
+ * The typed error every impl method throws on non-2xx responses.
+ *
+ *  - \`ClientError(statusCode, body)\`     — 4XX
+ *  - \`ServerError(statusCode, body)\`     — 5XX
+ *  - \`UnexpectedStatus(statusCode, body)\` — 1XX/3XX/anything outside 2-5
+ *  - \`DecodingFailed(cause)\`             — kotlinx-serialization threw on a 2XX body
+ *  - \`Transport(cause)\`                  — OkHttp / network-layer failure
+ *
+ * Consumers \`catch\` and pattern-match. Bodies are surfaced as raw
+ * \`ByteArray\` so callers can decode error envelopes themselves with the
+ * codec they prefer.
+ */
+public sealed class APIError(message: String? = null, cause: Throwable? = null) :
+    RuntimeException(message, cause) {
+
+    public class ClientError(
+        public val statusCode: Int,
+        public val body: ByteArray,
+    ) : APIError("Client error: \$statusCode")
+
+    public class ServerError(
+        public val statusCode: Int,
+        public val body: ByteArray,
+    ) : APIError("Server error: \$statusCode")
+
+    public class UnexpectedStatus(
+        public val statusCode: Int,
+        public val body: ByteArray,
+    ) : APIError("Unexpected status: \$statusCode")
+
+    public class DecodingFailed(cause: Throwable) :
+        APIError("Decoding failed: \${cause.message}", cause)
+
+    public class Transport(cause: Throwable) :
+        APIError("Transport failure: \${cause.message}", cause)
+}
+`;
+const QUERY_STYLE_KT = `package __PACKAGE__
+
+/**
+ * Query-array serialization style — matches the OpenAPI 3 \`style\` field
+ * for query parameters whose value is an array. The default is \`form\`
+ * with explode=true; the others appear when the spec opts into them.
+ */
+public enum class QueryStyle {
+    FORM,
+    SPACE_DELIMITED,
+    PIPE_DELIMITED,
+}
+`;
+const URL_ENCODING_KT = `package __PACKAGE__
+
+import okhttp3.HttpUrl
+
+/**
+ * Helpers used by generated impl code to add OpenAPI-shaped query
+ * parameters onto an \`HttpUrl.Builder\` without each call site having to
+ * know the style/explode rules.
+ *
+ *  - \`addScalar\` skips when the value is \`null\` so optional-and-missing
+ *    params don't emit a key at all.
+ *  - \`addArray\` honours \`style\` + \`explode\`: explode=true emits one
+ *    \`?name=v\` per element; explode=false joins per the style separator.
+ */
+public object URLEncoding {
+    public fun addScalar(builder: HttpUrl.Builder, name: String, value: Any?) {
+        if (value == null) return
+        builder.addQueryParameter(name, value.toString())
+    }
+
+    public fun addArray(
+        builder: HttpUrl.Builder,
+        name: String,
+        values: List<Any>?,
+        style: QueryStyle = QueryStyle.FORM,
+        explode: Boolean = true,
+    ) {
+        if (values == null) return
+        if (explode) {
+            for (v in values) builder.addQueryParameter(name, v.toString())
+            return
+        }
+        val sep = when (style) {
+            QueryStyle.FORM -> ","
+            QueryStyle.SPACE_DELIMITED -> " "
+            QueryStyle.PIPE_DELIMITED -> "|"
+        }
+        builder.addQueryParameter(name, values.joinToString(sep) { it.toString() })
+    }
+}
+`;
+const MULTIPART_KT = `package __PACKAGE__
+
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.MultipartBody
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+
+/**
+ * Thin wrapper over OkHttp's \`MultipartBody.Builder\` — keeps the impl
+ * code symmetric with the JSON / form-urlencoded paths.
+ *
+ *  - \`appendText(name, value)\`           — text part.
+ *  - \`appendFile(name, filename, bytes,\`
+ *    \`mimeType)\`                          — binary part.
+ *  - \`build()\`                            — finalizes and returns a
+ *                                            \`RequestBody\` ready to pass
+ *                                            into \`.method("POST", body)\`.
+ */
+public class MultipartFormBody {
+    private val builder: MultipartBody.Builder =
+        MultipartBody.Builder().setType(MultipartBody.FORM)
+
+    public fun appendText(name: String, value: String) {
+        builder.addFormDataPart(name, value)
+    }
+
+    public fun appendFile(
+        name: String,
+        filename: String,
+        bytes: ByteArray,
+        mimeType: String = "application/octet-stream",
+    ) {
+        val body: RequestBody = bytes.toRequestBody(mimeType.toMediaTypeOrNull())
+        builder.addFormDataPart(name, filename, body)
+    }
+
+    public fun build(): RequestBody = builder.build()
+}
+`;
+const REQUEST_OPTIONS_KT = `package __PACKAGE__
+
+import okhttp3.HttpUrl
+import okhttp3.Request
+import okhttp3.Response
+
+/**
+ * Per-call options bag — every generated method takes a
+ * \`RequestOptions\` last param. Mirrors hey-api's TS SDK options shape.
+ *
+ *  - \`client\`               — override the impl's bound \`APIClient\`.
+ *  - \`baseUrl\`              — override \`client.baseUrl\` for one call.
+ *  - \`timeout\`              — per-call call-timeout in milliseconds.
+ *  - \`headers\`              — extra/override headers, applied last.
+ *  - \`requestInterceptors\`  — extra suspend interceptors, run after
+ *                              client-level ones.
+ *  - \`responseValidator\`    — runs after a 2xx response; throwing
+ *                              converts the call into an exception.
+ *  - \`responseTransformer\`  — rewrite the response body before decode.
+ */
+public data class RequestOptions(
+    public val client: APIClient? = null,
+    public val baseUrl: HttpUrl? = null,
+    public val timeout: Long? = null,
+    public val headers: Map<String, String> = emptyMap(),
+    public val requestInterceptors: List<suspend (Request) -> Request> = emptyList(),
+    public val responseValidator: (suspend (ByteArray, Response) -> Unit)? = null,
+    public val responseTransformer: (suspend (ByteArray) -> ByteArray)? = null,
+)
+`;
+const API_KEY_LOCATION_KT = `package __PACKAGE__
+
+public enum class APIKeyLocation {
+    HEADER,
+    QUERY,
+    COOKIE,
+}
+`;
+const AUTH_KT = `package __PACKAGE__
+
+import java.util.Base64
+import okhttp3.HttpUrl
+import okhttp3.Request
+
+/**
+ * Auth schemes consumers reach for in practice:
+ *
+ *  - \`Bearer(token)\`            — \`Authorization: Bearer <token>\`.
+ *  - \`ApiKey(name, value, in)\`  — header / query / cookie placement,
+ *                                  matching the spec's
+ *                                  \`securitySchemes.<name>.in\`.
+ *  - \`Basic(username, password)\` — \`Authorization: Basic <base64>\`.
+ *
+ * Per-operation auth is auto-wired by the generator when an op has
+ * \`security\` requirements; it walks the requirement names and applies
+ * any matching scheme value the consumer has placed on \`APIClient.auth\`.
+ *
+ * \`apply\` mutates the request builder in-place for header / cookie
+ * auth and returns the (possibly rewritten) \`HttpUrl\` so query auth
+ * can re-thread its name=value into the URL.
+ */
+public sealed class Auth {
+    public abstract fun apply(builder: Request.Builder, url: HttpUrl): HttpUrl
+
+    public data class Bearer(public val token: String) : Auth() {
+        override fun apply(builder: Request.Builder, url: HttpUrl): HttpUrl {
+            builder.header("Authorization", "Bearer \$token")
+            return url
+        }
+    }
+
+    public data class ApiKey(
+        public val name: String,
+        public val value: String,
+        public val location: APIKeyLocation,
+    ) : Auth() {
+        override fun apply(builder: Request.Builder, url: HttpUrl): HttpUrl =
+            when (location) {
+                APIKeyLocation.HEADER -> {
+                    builder.header(name, value)
+                    url
+                }
+                APIKeyLocation.QUERY ->
+                    url.newBuilder().addQueryParameter(name, value).build()
+                APIKeyLocation.COOKIE -> {
+                    val cookie = "\$name=\$value"
+                    val existing = builder.build().header("Cookie")
+                    builder.header("Cookie", existing?.let { "\$it; \$cookie" } ?: cookie)
+                    url
+                }
+            }
+    }
+
+    public data class Basic(
+        public val username: String,
+        public val password: String,
+    ) : Auth() {
+        override fun apply(builder: Request.Builder, url: HttpUrl): HttpUrl {
+            val encoded = Base64.getEncoder()
+                .encodeToString("\$username:\$password".toByteArray(Charsets.UTF_8))
+            builder.header("Authorization", "Basic \$encoded")
+            return url
+        }
+    }
+}
+`;
+const API_CLIENT_KT_BASE = `package __PACKAGE__
+
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+
+/**
+ * Runtime helper every per-tag impl class delegates to. Owns the
+ * transport-level concerns — \`OkHttpClient\`, \`Json\`, the interceptor
+ * pipeline — and provides one source of truth for status-code
+ * dispatch and decoding.
+ *
+ *  - \`execute<T>(request, deserializer, …)\`       — decodes a 2xx body to \`T\`.
+ *  - \`executeUnit(request, …)\`                    — discards the body.
+ *  - \`executeWithResponse<T>(request, deserializer,\`
+ *    \`…)\`                                          — decode + raw \`Response\`.
+ *  - \`executeUnitWithResponse(request, …)\`        — raw \`Response\` only.
+ *  - \`executeRaw(request, …)\`                     — raw \`(ByteArray, Response)\`,
+ *                                                    used by multi-2xx ops.
+ *
+ * Status-code dispatch lives in \`sendAndDispatch\`; 2xx returns the
+ * body bytes, 4xx/5xx throw the matching \`APIError\` subclass.
+ */
+public class APIClient(
+    public var baseUrl: HttpUrl,
+    public val httpClient: OkHttpClient = OkHttpClient(),
+    public val json: Json = Json {
+        ignoreUnknownKeys = true
+        encodeDefaults = true
+    },
+    public val interceptors: APIInterceptors = APIInterceptors(),__AUTH_FIELD__
+) {
+    public suspend fun <T> execute(
+        request: Request,
+        deserializer: kotlinx.serialization.DeserializationStrategy<T>,
+        timeout: Long? = null,
+        extraInterceptors: List<suspend (Request) -> Request> = emptyList(),
+        responseValidator: (suspend (ByteArray, Response) -> Unit)? = null,
+        responseTransformer: (suspend (ByteArray) -> ByteArray)? = null,
+    ): T {
+        val (data, response) = sendAndDispatch(request, timeout, extraInterceptors)
+        responseValidator?.invoke(data, response)
+        val body = responseTransformer?.invoke(data) ?: data
+        return try {
+            json.decodeFromString(deserializer, body.decodeToString())
+        } catch (e: Throwable) {
+            throw APIError.DecodingFailed(e)
+        }
+    }
+
+    public suspend fun executeUnit(
+        request: Request,
+        timeout: Long? = null,
+        extraInterceptors: List<suspend (Request) -> Request> = emptyList(),
+        responseValidator: (suspend (ByteArray, Response) -> Unit)? = null,
+    ) {
+        val (data, response) = sendAndDispatch(request, timeout, extraInterceptors)
+        responseValidator?.invoke(data, response)
+    }
+
+    public suspend fun <T> executeWithResponse(
+        request: Request,
+        deserializer: kotlinx.serialization.DeserializationStrategy<T>,
+        timeout: Long? = null,
+        extraInterceptors: List<suspend (Request) -> Request> = emptyList(),
+        responseValidator: (suspend (ByteArray, Response) -> Unit)? = null,
+        responseTransformer: (suspend (ByteArray) -> ByteArray)? = null,
+    ): Pair<T, Response> {
+        val (data, response) = sendAndDispatch(request, timeout, extraInterceptors)
+        responseValidator?.invoke(data, response)
+        val body = responseTransformer?.invoke(data) ?: data
+        return try {
+            json.decodeFromString(deserializer, body.decodeToString()) to response
+        } catch (e: Throwable) {
+            throw APIError.DecodingFailed(e)
+        }
+    }
+
+    public suspend fun executeUnitWithResponse(
+        request: Request,
+        timeout: Long? = null,
+        extraInterceptors: List<suspend (Request) -> Request> = emptyList(),
+        responseValidator: (suspend (ByteArray, Response) -> Unit)? = null,
+    ): Response {
+        val (data, response) = sendAndDispatch(request, timeout, extraInterceptors)
+        responseValidator?.invoke(data, response)
+        return response
+    }
+
+    public suspend fun executeRaw(
+        request: Request,
+        timeout: Long? = null,
+        extraInterceptors: List<suspend (Request) -> Request> = emptyList(),
+        responseValidator: (suspend (ByteArray, Response) -> Unit)? = null,
+        responseTransformer: (suspend (ByteArray) -> ByteArray)? = null,
+    ): Pair<ByteArray, Response> {
+        val (data, response) = sendAndDispatch(request, timeout, extraInterceptors)
+        responseValidator?.invoke(data, response)
+        val body = responseTransformer?.invoke(data) ?: data
+        return body to response
+    }
+
+    private suspend fun sendAndDispatch(
+        request: Request,
+        timeout: Long?,
+        extraInterceptors: List<suspend (Request) -> Request>,
+    ): Pair<ByteArray, Response> {
+        var req = request
+        for (interceptor in interceptors.request) req = interceptor(req)
+        for (interceptor in extraInterceptors) req = interceptor(req)
+        val callClient = if (timeout == null) httpClient else
+            httpClient.newBuilder().callTimeout(timeout, TimeUnit.MILLISECONDS).build()
+        val response = try {
+            withContext(Dispatchers.IO) {
+                callClient.newCall(req).execute()
+            }
+        } catch (e: Throwable) {
+            throw APIError.Transport(e)
+        }
+        val body = response.body?.bytes() ?: ByteArray(0)
+        return when (val code = response.code) {
+            in 200..299 -> body to response
+            in 400..499 -> throw APIError.ClientError(code, body)
+            in 500..599 -> throw APIError.ServerError(code, body)
+            else -> throw APIError.UnexpectedStatus(code, body)
+        }
+    }
+}
+`;
+export function apiClientKt(opts) {
+    const authField = opts.hasAuth
+        ? "\n    public val auth: MutableMap<String, Auth> = mutableMapOf(),"
+        : "";
+    return API_CLIENT_KT_BASE.replace("__AUTH_FIELD__", authField);
+}
+/** Ordered runtime files. The orchestrator places them under `API/`. */
+export function buildRuntimeFiles(opts, pkg) {
+    const subst = (s) => s.replace(/__PACKAGE__/g, pkg);
+    const files = [
+        { name: "APIClient.kt", content: subst(apiClientKt(opts)) },
+        { name: "APIError.kt", content: subst(API_ERROR_KT) },
+        { name: "APIInterceptors.kt", content: subst(API_INTERCEPTORS_KT) },
+        { name: "QueryStyle.kt", content: subst(QUERY_STYLE_KT) },
+        { name: "URLEncoding.kt", content: subst(URL_ENCODING_KT) },
+        { name: "RequestOptions.kt", content: subst(REQUEST_OPTIONS_KT) },
+    ];
+    if (opts.hasAuth) {
+        files.push({ name: "Auth.kt", content: subst(AUTH_KT) });
+        files.push({
+            name: "APIKeyLocation.kt",
+            content: subst(API_KEY_LOCATION_KT),
+        });
+    }
+    if (opts.hasMultipart) {
+        files.push({
+            name: "MultipartFormBody.kt",
+            content: subst(MULTIPART_KT),
+        });
+    }
+    return files;
+}
+//# sourceMappingURL=templates.js.map

package/dist/ir/runtime/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../../src/ir/runtime/templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAqBH,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;CAc3B,CAAC;AAEF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCpB,CAAC;AAEF,MAAM,cAAc,GAAG;;;;;;;;;;;;CAYtB,CAAC;AAEF,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCvB,CAAC;AAEF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCpB,CAAC;AAEF,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B1B,CAAC;AAEF,MAAM,mBAAmB,GAAG;;;;;;;CAO3B,CAAC;AAEF,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEf,CAAC;AAEF,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqI1B,CAAC;AAEF,MAAM,UAAU,WAAW,CAAC,IAAiB;IAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO;QAC5B,CAAC,CAAC,mEAAmE;QACrE,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,kBAAkB,CAAC,OAAO,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;AACjE,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,iBAAiB,CAC/B,IAAiB,EACjB,GAAW;IAEX,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;IAC5D,MAAM,KAAK,GAAkB;QAC3B,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE;QAC3D,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE;QACrD,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAC,EAAE;QACnE,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,cAAc,CAAC,EAAE;QACzD,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE;QAC3D,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,EAAE;KAClE,CAAC;IACF,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACzD,KAAK,CAAC,IAAI,CAAC;YACT,IAAI,EAAE,mBAAmB;YACzB,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAC;SACpC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,KAAK,CAAC,IAAI,CAAC;YACT,IAAI,EAAE,sBAAsB;YAC5B,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC;SAC7B,CAAC,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/ir/schema.d.ts

@@ -0,0 +1,11 @@
+import type { IR } from "@hey-api/shared";
+import { type KtDecl } from "../kt-dsl/index.js";
+/**
+ * Translate `IR.Model.components.schemas` into Kotlin decls. Object schemas
+ * with properties become `@Serializable` data classes; `enum` schemas
+ * become `String`-raw `@Serializable` enums; primitives/arrays/unions
+ * become typealiases. Inline nested objects/enums are promoted to
+ * top-level synthetic decls (`Owner_PropertyName`).
+ */
+export declare function schemasToDecls(schemas: Record<string, IR.SchemaObject>): KtDecl[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/ir/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/ir/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAG1C,OAAO,EACL,KAAK,MAAM,EAMZ,MAAM,oBAAoB,CAAC;AAG5B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,GACvC,MAAM,EAAE,CA6CV"}