@ir-kit/openapi-kotlin 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ahmed Rowaihi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,259 @@
+# @ir-kit/openapi-kotlin
+
+Generate idiomatic Android / JVM Kotlin client SDKs from an OpenAPI 3.x spec — `@Serializable` data classes, `String`-raw enums, per-tag interfaces with `suspend` functions, and an OkHttp + kotlinx-serialization impl class. Per-call `RequestOptions`, composable interceptors, typed `APIError`, multipart + form-urlencoded wire encoding, multi-2xx sum-type returns, and per-op security auto-wiring all included.
+
+Built on the [`@hey-api`](https://github.com/hey-api/openapi-ts) toolchain (`@hey-api/json-schema-ref-parser` for spec loading, `@hey-api/shared` IR for normalization). 2.0 / 3.0 / 3.1 inputs all produce the same output.
+
+Sibling package to [`@ir-kit/openapi-swift`](../openapi-swift). Part of [ir-kit](https://github.com/ir-kit/ir-kit). Companion to the [`petstore-sdk` example](../../examples/petstore-sdk).
+
+## Install
+
+```bash
+pnpm add @ir-kit/openapi-kotlin @ir-kit/openapi-tools @hey-api/shared @hey-api/spec-types
+```
+
+## Usage
+
+```ts
+import { generate } from "@ir-kit/openapi-kotlin";
+
+await generate({
+  input: "https://api.example.com/openapi.json",
+  output: "./sdk-kotlin",
+  packageName: "com.example.petstore",
+});
+```
+
+Reads any of: a filesystem path, an http(s) URL, or a pre-parsed object. YAML and JSON are both supported. External `$ref`s are bundled inline.
+
+## Output
+
+### Schemas → `@Serializable` data classes / enums / typealiases
+
+```kotlin
+@Serializable
+public data class Pet(
+    public val id: Long? = null,
+    public val name: String,
+    public val category: Category? = null,
+    public val photoUrls: List<String>,
+    public val tags: List<Tag>? = null,
+    public val status: Pet_Status? = null,
+)
+
+@Serializable
+public enum class Pet_Status(public val raw: String) {
+    @SerialName("available") AVAILABLE("available"),
+    @SerialName("pending") PENDING("pending"),
+    @SerialName("sold") SOLD("sold"),
+}
+```
+
+Inline enums on a property get promoted to a top-level `Owner_Property` enum class. Renamed JSON keys (snake_case → camelCase) get a `@SerialName` so the wire format stays untouched.
+
+### Operations → interfaces + impls
+
+For each tag the generator emits:
+
+- `interface <Tag>Api` with `suspend fun` requirements
+- top-level `<Tag>Api.<op>(…)` extension funs as no-options convenience overloads (forward to the with-options form using `RequestOptions()` defaults)
+- `class OkHttp<Tag>Api(client: APIClient) : <Tag>Api` with the wire impl
+
+```kotlin
+public interface PetApi {
+    /** GET /pet/{petId} */
+    public suspend fun getPetById(petId: Long, options: RequestOptions): Pet
+    public suspend fun getPetByIdWithResponse(petId: Long, options: RequestOptions): Pair<Pet, Response>
+    // …
+}
+
+public suspend fun PetApi.getPetById(petId: Long): Pet =
+    getPetById(petId = petId, options = RequestOptions())
+
+public class OkHttpPetApi(public val client: APIClient) : PetApi {
+    public override suspend fun getPetById(petId: Long, options: RequestOptions): Pet { /* … */ }
+    // …
+}
+```
+
+Every operation also emits a sibling `*WithResponse` overload that returns `Pair<T, Response>` — for callers that need response headers (pagination cursors, `ETag`, rate limits). Void-returning operations get `*WithResponse(): Response` instead.
+
+### Per-call control via `RequestOptions`
+
+```kotlin
+public data class RequestOptions(
+    public val client: APIClient? = null,
+    public val baseUrl: HttpUrl? = null,
+    public val timeout: Long? = null,                                    // milliseconds
+    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,
+)
+```
+
+```kotlin
+pets.getPetById(1)                                                       // defaults
+pets.getPetById(1, RequestOptions(client = customClient))                // swap transport
+pets.getPetById(1, RequestOptions(headers = mapOf("X-Trace" to id)))     // extra headers
+pets.getPetById(1, RequestOptions(baseUrl = stagingUrl))                 // hit staging
+pets.getPetById(1, RequestOptions(timeout = 60_000))                     // long-poll override
+```
+
+### Composable interceptors + auth
+
+The runtime `APIClient` carries an `interceptors.request` list that runs against every outgoing request. Interceptors compose — auth, logging, tracing all coexist:
+
+```kotlin
+val client = APIClient(baseUrl = "https://api.example.com/".toHttpUrl())
+client.interceptors.request += { request ->
+    request.newBuilder()
+        .header("Authorization", "Bearer ${TokenStore.access()}")
+        .build()
+}
+```
+
+When the spec declares any `securitySchemes`, the generator additionally emits an `Auth` sealed class (with `Bearer`, `ApiKey`, `Basic` subclasses — `ApiKey` carries an `APIKeyLocation` of `HEADER` / `QUERY` / `COOKIE`) and the client gains a `var auth: MutableMap<String, Auth>` keyed by scheme name. Operations with `security:` requirements walk the map and apply the matching scheme automatically:
+
+```kotlin
+client.auth["bearerAuth"] = Auth.Bearer(token)
+client.auth["xApiKey"] = Auth.ApiKey("X-API-Key", key, APIKeyLocation.HEADER)
+```
+
+### Body media-type dispatch
+
+| Input media type | Generated parameter shape | Wire encoding |
+|---|---|---|
+| `application/json` (and `+json`) | `body: T` | `Json.encodeToString(<ser>, body).toRequestBody("application/json".toMediaType())` |
+| `multipart/form-data` (object schema) | one param per property; binary fields → `ByteArray` | emitted `MultipartFormBody` helper (wraps `MultipartBody.Builder`) |
+| `application/x-www-form-urlencoded` (object schema) | one param per property | `FormBody.Builder()` |
+| `application/octet-stream`, image, etc. | `body: ByteArray` | raw bytes via `toRequestBody("<mt>".toMediaType())` |
+| `oneOf` / unresolvable JSON | `body: ByteArray` | raw bytes (caller pre-encodes) |
+
+### Typed errors
+
+Every non-2xx response funnels into `APIError`:
+
+```kotlin
+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(/* … */)   // 4XX
+    public class ServerError(public val statusCode: Int, public val body: ByteArray) : APIError(/* … */)   // 5XX
+    public class UnexpectedStatus(public val statusCode: Int, public val body: ByteArray) : APIError(/* … */) // 1XX/3XX/etc.
+    public class DecodingFailed(cause: Throwable) : APIError(/* … */)                                       // kotlinx-serialization threw
+    public class Transport(cause: Throwable) : APIError(/* … */)                                            // OkHttp/network layer
+}
+```
+
+### Multi-2xx → sum-type return
+
+When an operation declares more than one 2xx response code with distinct schemas, the generator emits a sealed-class hierarchy and the impl dispatches on `response.code`:
+
+```kotlin
+public sealed class SubmitJob_Response {
+    public data class Status200(public val value: JobResult) : SubmitJob_Response()
+    public data class Status202(public val value: Pending) : SubmitJob_Response()
+    public object Status204 : SubmitJob_Response()
+}
+```
+
+## Generator options
+
+Every option is optional. Pass them to `generate({ ... })`:
+
+| Option | Purpose |
+|---|---|
+| `input` / `output` | Spec source (path / URL / object) and SDK output dir. |
+| `packageName` | Kotlin package every file declares. Default `"com.example.api"`. |
+| `clean` | Wipe `output` before writing. Default `true`. Refuses to wipe cwd or filesystem root. |
+| `gradle` | Emit `build.gradle.kts` + `settings.gradle.kts` for standalone-module mode. `true` → defaults. Object → custom `group`, `version`, plugin/dependency versions, JVM target. Omit → mode 1 (raw kotlin source tree only). |
+| `defaultTag` | Tag to use when an op has none. Default `"Default"`. |
+| `interfaceName` | `(tag) => string`. Default `(tag) => `${PascalCase(tag)}Api``. |
+| `clientClassName` | `(interfaceName) => string`. Default `(p) => `OkHttp${p}``. |
+| `interfaceOnly` | Skip impl class emission. Default `false`. |
+| `openImpl` | Emit impl class as `open` so consumers can subclass. Default `false`. |
+| `layout` | `"split"` (default — `api/` + `models/` sub-packages) or `"flat"` (one package). |
+| `fileLocation` | `(decl) => { dir }` — full per-decl override. Rejects `..` traversal and absolute paths. |
+
+```ts
+generate({
+    input,
+    output,
+    packageName: "com.example.petstore",
+    gradle: { group: "com.example", version: "1.0.0" },
+    openImpl: true,
+});
+```
+
+## Two consumption modes
+
+| Mode | Setup | When |
+|---|---|---|
+| **Drop into an existing Gradle module** | Paste the package directory (e.g. `com/example/petstore/`) into your module's `src/main/kotlin/` tree. The surrounding module must apply `kotlin("plugin.serialization")` and depend on OkHttp + kotlinx-serialization-json + kotlinx-coroutines-core + kotlinx-datetime. | Adding the SDK directly to one app or library. |
+| **Standalone Gradle module** | Pass `gradle: true` (or an options object) to `generate()`; `build.gradle.kts` + `settings.gradle.kts` are emitted alongside the source. Run `gradle build` from the output dir. | Sharing across multiple modules, publishing privately, or wanting a clean dependency boundary. |
+
+## Output layout
+
+```text
+sdk-kotlin/
+├── com/example/petstore/
+│   ├── api/
+│   │   ├── PetApi.kt                  # interface
+│   │   ├── PetApiExtensions.kt        # convenience overloads (no-options)
+│   │   ├── OkHttpPetApi.kt            # impl class
+│   │   ├── APIClient.kt               # runtime helper (transport, dispatch, decode)
+│   │   ├── APIInterceptors.kt         # interceptor pipeline
+│   │   ├── APIError.kt                # typed errors
+│   │   ├── Auth.kt                    # (when spec has securitySchemes)
+│   │   ├── APIKeyLocation.kt          # (when spec has securitySchemes)
+│   │   ├── MultipartFormBody.kt       # (when any op uses multipart/form-data)
+│   │   ├── URLEncoding.kt             # query helpers
+│   │   ├── QueryStyle.kt              # form / spaceDelimited / pipeDelimited
+│   │   └── RequestOptions.kt
+│   └── models/
+│       ├── Pet.kt                     # @Serializable data classes
+│       ├── Pet_Status.kt              # enum classes
+│       └── …
+└── (build.gradle.kts + settings.gradle.kts when `gradle:` is set)
+```
+
+## Requirements
+
+The generated code uses Kotlin coroutines + kotlinx-serialization, so:
+
+- **Kotlin** 2.0 or newer (with `kotlin("plugin.serialization")` applied)
+- **JVM target** 17 or newer (configurable via the `gradle` option)
+
+Runtime dependencies (set up by the `gradle:` option, or by the consuming module in drop-in mode):
+
+- `org.jetbrains.kotlinx:kotlinx-serialization-json:1.7+`
+- `org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9+`
+- `org.jetbrains.kotlinx:kotlinx-datetime:0.6+` (only if any model uses `Instant` / `LocalDate`)
+- `com.squareup.okhttp3:okhttp:4.12+`
+
+## API surface
+
+| Export | Purpose |
+|---|---|
+| `generate(opts)` | High-level entry: load → IR → decls → files on disk. |
+| `schemasToDecls(schemas)` | `IR.Model.components.schemas` → `KtDecl[]`. |
+| `operationsToDecls(paths, opts?)` | `IR.PathsObject` → `{ decls, needsAuth, needsMultipart }` (interfaces + impls grouped by tag). |
+| `buildKotlinProject(decls, opts?)` | `KtDecl[]` → `{ path, content }[]` with package / import resolution. |
+| `buildRuntimeFiles(opts, pkg)` | Standalone runtime helper files (APIClient, APIError, …) keyed off the consumer's package. |
+| `buildGradleFile(opts?)` | Build a `build.gradle.kts` for a standalone Gradle module wrapping the SDK. |
+| `securityKey(path, method)` | Key into `OperationsOptions.securitySchemeNames`. |
+| `printFile(file)` / `kt*` builders | Lower-level Kotlin AST + printer. |
+
+```text
+src/kt-dsl/                   Kotlin AST: type/, expr/, stmt/, decl/, fun.ts, file.ts
+src/kt-compiler/              AST → string, mirrors the AST tree
+src/ir/
+├── type/                     IR.SchemaObject → KtType
+├── operation/                IR.OperationObject → signature shared by interface + impl
+├── impl/                     OkHttp body builders (url, request, headers, body, decode)
+├── runtime/                  Templated Kotlin source for runtime helpers
+├── schema.ts                 schemasToDecls
+└── operations.ts             paths → interfaces + impl classes (orchestrator)
+```
+
+Adding a new statement / expression node: add to `kt-dsl/{expr,stmt}/types.ts`, builder, one printer case. Per-method bodies are AST-built; runtime helpers (the same Kotlin every time) ship as templated strings in `ir/runtime/templates.ts`.

package/dist/generate.d.ts

@@ -0,0 +1,41 @@
+import { type NormalizeOptions } from "@ir-kit/openapi-core";
+import { type OperationsOptions } from "./ir/index.js";
+import { type BuildOptions, type BuiltFile, type GradleOptions } from "./project/index.js";
+/**
+ * Operations options the consumer can pass through `generate()`. The
+ * orchestrator owns `securitySchemeNames` (extracted from the bundled
+ * spec), so it's stripped from the public surface.
+ */
+type ForwardedOperationsOptions = Omit<OperationsOptions, "securitySchemeNames">;
+export interface GenerateOptions extends BuildOptions, ForwardedOperationsOptions {
+    /**
+     * The OpenAPI spec source: a filesystem path, http(s) URL, or a
+     * pre-parsed object. YAML and JSON inputs both work. External
+     * `$ref`s are bundled inline; the spec is normalized to hey-api IR
+     * before generation, so 2.0 / 3.0 / 3.1 inputs all produce the same
+     * output shape.
+     */
+    input: string | Record<string, unknown>;
+    /** Directory the SDK is written to (created if missing). */
+    output: string;
+    /** Wipe `output` before writing. Default: `true`. */
+    clean?: boolean;
+    /**
+     * When set, emit a `build.gradle.kts` + `settings.gradle.kts` at the
+     * output root so the SDK is a self-contained Gradle library. Pass
+     * `true` for sensible defaults (project name keyed off the output
+     * dir basename) or a `GradleOptions` object for fine-grained
+     * control. Default: omitted — the output is just the Kotlin source
+     * tree, ready to drop into an existing Gradle module.
+     */
+    gradle?: boolean | GradleOptions;
+    /** Pre-codegen spec normalization. `true` enables the safe preset. */
+    normalize?: boolean | NormalizeOptions;
+}
+export interface GenerateResult {
+    files: BuiltFile[];
+    output: string;
+}
+export declare function generate(opts: GenerateOptions): Promise<GenerateResult>;
+export {};
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,SAAS,EAGd,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,KAAK,0BAA0B,GAAG,IAAI,CACpC,iBAAiB,EACjB,qBAAqB,CACtB,CAAC;AAEF,MAAM,WAAW,eACf,SAAQ,YAAY,EAClB,0BAA0B;IAC5B;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC;IACjC,sEAAsE;IACtE,SAAS,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAqD7E"}

package/dist/generate.js

@@ -0,0 +1,64 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { assertSafeOutputDir, defaultProjectName } from "@ir-kit/codegen-core";
+import { extractSecuritySchemeNames, } from "@ir-kit/openapi-core";
+import { loadSpec } from "@ir-kit/openapi-tools";
+import { parseSpec } from "@ir-kit/openapi-tools/parse";
+import { operationsToDecls, schemasToDecls, } from "./ir/index.js";
+import { buildRuntimeFiles } from "./ir/runtime/index.js";
+import { buildGradleFile, buildKotlinProject, settingsGradleFile, } from "./project/index.js";
+export async function generate(opts) {
+    const bundled = await loadSpec({
+        input: opts.input,
+        normalize: opts.normalize,
+    });
+    const ir = parseSpec(bundled);
+    const schemaDecls = schemasToDecls(ir.components?.schemas ?? {});
+    const opsResult = operationsToDecls(ir.paths, {
+        defaultTag: opts.defaultTag,
+        interfaceName: opts.interfaceName,
+        clientClassName: opts.clientClassName,
+        interfaceOnly: opts.interfaceOnly,
+        openImpl: opts.openImpl,
+        securitySchemeNames: extractSecuritySchemeNames(bundled),
+    });
+    const decls = [...schemaDecls, ...opsResult.decls];
+    const sdkFiles = buildKotlinProject(decls, opts);
+    const pkg = opts.packageName ?? "com.example.api";
+    const apiSubDir = (opts.layout ?? "split") === "flat" ? "" : "api";
+    const runtimeFiles = buildRuntimeFiles({
+        hasAuth: opsResult.needsAuth,
+        hasMultipart: opsResult.needsMultipart,
+        hasFormUrlEncoded: false,
+    }, runtimeSubPackage(pkg, apiSubDir)).map((rf) => ({
+        path: runtimePath(pkg, apiSubDir, rf.name),
+        content: rf.content,
+    }));
+    const files = [...sdkFiles, ...runtimeFiles];
+    const out = resolve(opts.output);
+    if (opts.gradle) {
+        const gradleOpts = typeof opts.gradle === "object" ? opts.gradle : {};
+        files.push(buildGradleFile(gradleOpts));
+        files.push(settingsGradleFile(defaultProjectName(out)));
+    }
+    if (opts.clean !== false) {
+        assertSafeOutputDir(out);
+        await rm(out, { recursive: true, force: true });
+    }
+    for (const file of files) {
+        const full = join(out, file.path);
+        await mkdir(dirname(full), { recursive: true });
+        await writeFile(full, file.content);
+    }
+    return { files, output: out };
+}
+function runtimeSubPackage(rootPkg, dir) {
+    if (dir === "")
+        return rootPkg;
+    return `${rootPkg}.${dir}`;
+}
+function runtimePath(rootPkg, dir, name) {
+    const pkgPath = rootPkg.replace(/\./g, "/");
+    return dir === "" ? `${pkgPath}/${name}` : `${pkgPath}/${dir}/${name}`;
+}
+//# sourceMappingURL=generate.js.map

package/dist/generate.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./generate.js";
+export * from "./ir/index.js";
+export * from "./kt-compiler/index.js";
+export * from "./kt-dsl/index.js";
+export * from "./project/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./generate.js";
+export * from "./ir/index.js";
+export * from "./kt-compiler/index.js";
+export * from "./kt-dsl/index.js";
+export * from "./project/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/ir/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default Kotlin package name when the consumer doesn't override
+ * `packageName` on the build options.
+ */
+export declare const DEFAULT_PACKAGE = "com.example.api";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/ir/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,eAAe,oBAAoB,CAAC"}

package/dist/ir/constants.js

@@ -0,0 +1,6 @@
+/**
+ * Default Kotlin package name when the consumer doesn't override
+ * `packageName` on the build options.
+ */
+export const DEFAULT_PACKAGE = "com.example.api";
+//# sourceMappingURL=constants.js.map

package/dist/ir/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/ir/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAC"}

package/dist/ir/identifiers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Kotlin-specific identifier transforms. Generic case helpers
+ * (`pascal`, `camel`, `safeIdent`, `safeCaseName`, `synthName`,
+ * `softCamel`, `escapeIfReserved`, `avoidLeadingDigit`) live in
+ * `@ir-kit/codegen-core`. The exports here cover what's unique to
+ * Kotlin: reserved-keyword backtick-escaping and SCREAMING_SNAKE
+ * enum entry names.
+ */
+/**
+ * Translate an arbitrary string to a Kotlin identifier safe to use as
+ * a parameter / property name. Reserved keywords are escaped with
+ * backticks (Kotlin's syntax for arbitrary identifiers). Uses
+ * `softCamel` (preserves first-letter casing) so PascalCase inputs
+ * pass through unchanged.
+ */
+export declare function paramIdent(name: string): string;
+/**
+ * Constant-style identifier for enum entries — `SCREAMING_SNAKE_CASE`.
+ * Kotlin convention for `enum class` entry names. Falls back to a
+ * leading underscore if the result starts with a digit.
+ */
+export declare function enumEntryIdent(s: string): string;
+//# sourceMappingURL=identifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../src/ir/identifiers.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAShD"}

package/dist/ir/identifiers.js

@@ -0,0 +1,71 @@
+import { avoidLeadingDigit, escapeIfReserved, softCamel, } from "@ir-kit/codegen-core";
+/**
+ * Kotlin-specific identifier transforms. Generic case helpers
+ * (`pascal`, `camel`, `safeIdent`, `safeCaseName`, `synthName`,
+ * `softCamel`, `escapeIfReserved`, `avoidLeadingDigit`) live in
+ * `@ir-kit/codegen-core`. The exports here cover what's unique to
+ * Kotlin: reserved-keyword backtick-escaping and SCREAMING_SNAKE
+ * enum entry names.
+ */
+/**
+ * Translate an arbitrary string to a Kotlin identifier safe to use as
+ * a parameter / property name. Reserved keywords are escaped with
+ * backticks (Kotlin's syntax for arbitrary identifiers). Uses
+ * `softCamel` (preserves first-letter casing) so PascalCase inputs
+ * pass through unchanged.
+ */
+export function paramIdent(name) {
+    return escapeIfReserved(avoidLeadingDigit(softCamel(name)), KOTLIN_RESERVED_KEYWORDS, (s) => `\`${s}\``);
+}
+/**
+ * Constant-style identifier for enum entries — `SCREAMING_SNAKE_CASE`.
+ * Kotlin convention for `enum class` entry names. Falls back to a
+ * leading underscore if the result starts with a digit.
+ */
+export function enumEntryIdent(s) {
+    const cleaned = s.replace(/[^a-zA-Z0-9]+/g, "_");
+    // Split on case boundaries so "firstName" -> ["first", "Name"] -> FIRST_NAME.
+    const parts = cleaned
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .split(/_+/)
+        .filter(Boolean);
+    const upper = parts.join("_").toUpperCase();
+    return avoidLeadingDigit(upper) || "EMPTY";
+}
+/**
+ * Kotlin's hard keywords (the ones that can't be used as identifiers
+ * unbacktick-escaped). Picked from the Kotlin reference's "Keywords
+ * and operators" section. Soft keywords (`override`, `data`, `inline`,
+ * `suspend`, etc.) are valid identifiers and don't need escaping.
+ */
+const KOTLIN_RESERVED_KEYWORDS = new Set([
+    "as",
+    "break",
+    "class",
+    "continue",
+    "do",
+    "else",
+    "false",
+    "for",
+    "fun",
+    "if",
+    "in",
+    "interface",
+    "is",
+    "null",
+    "object",
+    "package",
+    "return",
+    "super",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typealias",
+    "typeof",
+    "val",
+    "var",
+    "when",
+    "while",
+]);
+//# sourceMappingURL=identifiers.js.map

package/dist/ir/identifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.js","sourceRoot":"","sources":["../../src/ir/identifiers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,GACV,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,gBAAgB,CACrB,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAClC,wBAAwB,EACxB,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAClB,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;IACjD,8EAA8E;IAC9E,MAAM,KAAK,GAAG,OAAO;SAClB,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC;SACtC,KAAK,CAAC,IAAI,CAAC;SACX,MAAM,CAAC,OAAO,CAAC,CAAC;IACnB,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,iBAAiB,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC;AAC7C,CAAC;AAED;;;;;GAKG;AACH,MAAM,wBAAwB,GAAwB,IAAI,GAAG,CAAC;IAC5D,IAAI;IACJ,OAAO;IACP,OAAO;IACP,UAAU;IACV,IAAI;IACJ,MAAM;IACN,OAAO;IACP,KAAK;IACL,KAAK;IACL,IAAI;IACJ,IAAI;IACJ,WAAW;IACX,IAAI;IACJ,MAAM;IACN,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,OAAO;IACP,MAAM;IACN,OAAO;IACP,MAAM;IACN,KAAK;IACL,WAAW;IACX,QAAQ;IACR,KAAK;IACL,KAAK;IACL,MAAM;IACN,OAAO;CACR,CAAC,CAAC"}

package/dist/ir/impl/body.d.ts

@@ -0,0 +1,30 @@
+import type { IR } from "@hey-api/shared";
+import type { HttpMethod } from "@ir-kit/openapi-core";
+import type { KtType } from "../../kt-dsl/index.js";
+import { type KtStmt } from "../../kt-dsl/index.js";
+export interface BodyResult {
+    stmts: ReadonlyArray<KtStmt>;
+    /** Set when the body builder uses `MultipartFormBody` so the
+     *  orchestrator emits that runtime helper. */
+    needsMultipart: boolean;
+}
+/**
+ * Build the request body and re-set the HTTP method on `builder` to
+ * carry it. Dispatches on media type:
+ *
+ *  - `application/json` (and `+json`) → `client.json.encodeToString(<ser>, body)`
+ *    becomes a `RequestBody` via `.toRequestBody("application/json".toMediaType())`.
+ *    For opaque bodies (oneOf/anyOf), the impl receives `body: ByteArray`
+ *    and ships it raw.
+ *  - `multipart/form-data` (object schema) → assemble a
+ *    `MultipartFormBody`, append text/file fields per property, take
+ *    `multipart.build()` as the RequestBody.
+ *  - `application/x-www-form-urlencoded` (object schema) → build a
+ *    `FormBody.Builder()`, `add(name, value)` per property, take
+ *    `formBody.build()` as the RequestBody.
+ *  - octet-stream / image / etc. → `body.toRequestBody("<mt>".toMediaType())`.
+ *
+ * Optional fields are wrapped in `if (<id> != null)`.
+ */
+export declare function buildBodyStmts(body: IR.BodyObject, method: HttpMethod, bodyType: KtType): BodyResult;
+//# sourceMappingURL=body.d.ts.map

package/dist/ir/impl/body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../../src/ir/impl/body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAEL,KAAK,MAAM,EAYZ,MAAM,uBAAuB,CAAC;AAK/B,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7B;kDAC8C;IAC9C,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GACf,UAAU,CA6BZ"}