@ir-kit/openapi 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,131 @@
+# `@ir-kit/openapi`
+
+Language-agnostic IR-walking primitives for OpenAPI codegen. This package owns all the **pre-work** every native-SDK emitter needs (parsing the spec into shape, classifying schemas / responses / bodies, iterating paths × methods, deriving canonical names, walking template strings). Per-language emitters (`@ir-kit/openapi-{go,kotlin,swift}`) consume these primitives + provide their own **render** layer, never re-walking the spec themselves.
+
+The shape of the consolidation:
+
+```
+                 IR.SchemaObject / IR.OperationObject (hey-api shared types)
+                                    │
+                                    ▼
+                       @ir-kit/openapi (this package)
+                       ┌────────────────────────────┐
+                       │ pure walks:                │
+                       │   iterOperations           │
+                       │   collectLocatedParams     │
+                       │   classifyBody             │
+                       │   classifyReturnShape      │
+                       │   classifyUnion            │
+                       │   classifyObjectShape      │
+                       │   classifyEnumLiterals     │
+                       │   iterateObjectProperties  │
+                       │   parseTemplatedSegment    │
+                       │   splitPathSegments        │
+                       │   deriveBaseName           │
+                       │   ...                      │
+                       │                            │
+                       │ generic dispatchers:       │
+                       │   schemaToType<T,D>(...)   │
+                       │   unionToType<T,D>(...)    │
+                       │   inlineObjectType<T,D>(.) │
+                       └────────────┬───────────────┘
+                                    │ ops: SchemaToTypeOps<T, D>
+              ┌─────────────────────┼─────────────────────┐
+              ▼                     ▼                     ▼
+     @ir-kit/openapi-go    @ir-kit/openapi-kotlin   @ir-kit/openapi-swift
+     ┌──────────────────┐  ┌──────────────────┐    ┌──────────────────┐
+     │ goOps (renders): │  │ ktOps (renders): │    │ swOps (renders): │
+     │  • goPtr/goSlice │  │  • ktNullable    │    │  • swOptional    │
+     │  • goStruct      │  │  • ktDataClass   │    │  • swStruct      │
+     │  • const blocks  │  │  • @Serializable │    │  • CodingKeys    │
+     │  • net/http      │  │  • OkHttp        │    │  • URLSession    │
+     └──────────────────┘  └──────────────────┘    └──────────────────┘
+```
+
+## Why a shared dispatcher
+
+Before this package existed, each of the three native emitters had a full copy of `schemaToType`, `unionToType`, `inlineObjectType`, `buildEnumFromIR`, `typeForPrimitive` — plus their own walks over the spec. About 900 LOC of nearly-identical control flow per emitter (~2.7k total) drifted constantly: one emitter would gain a fix the others missed; one would use `pascal(jsonKey)` and another would use `safeIdent(jsonKey)` for the same role.
+
+Consolidating into `@ir-kit/openapi` + a per-emitter `SchemaToTypeOps<T, D>` record means:
+
+- **One source of truth for spec walks.** Adding a new OpenAPI feature (e.g. handling `discriminator`) lands in one file; all emitters pick it up.
+- **Per-target rendering stays per-target.** Go's pointer-wrap is in `goOps.wrapForUnionSingle`; Kotlin's nullable wrap is in `ktOps.wrapForUnionSingle`. Neither leaks into the other; the dispatcher doesn't care which one is "right".
+- **Type-safety on the contract.** `SchemaToTypeOps<T, D>` is generic over the target type `T` (`GoType` / `KtType` / `SwType`) and decl type `D`. Each emitter gets type errors at compile time if it omits a hook or returns the wrong shape.
+
+## The `SchemaToTypeOps<T, D>` interface
+
+Every emitter implements ~13 hooks in one record (`packages/openapi/<lang>/src/ir/type-ops.ts`):
+
+```ts
+interface SchemaToTypeOps<T, D> {
+  // Leaf constructors
+  refType(name: string): T;
+  arrayType(elem: T): T;
+  mapType(value: T): T;
+  voidType(): T;
+  anyType(): T;
+  nullableAnyType(): T;
+  wrapForUnionSingle(inner: T, nullable: boolean): T;
+  unionFallback(nullable: boolean): T;
+  primitiveType(schema: IR.SchemaObject): T | undefined;
+
+  // Naming
+  synthName(ownerName: string, propPath: ReadonlyArray<string>): string;
+
+  // Composites (the dispatcher calls these when it sees the matching shape)
+  buildStructDecl(
+    name: string,
+    properties: ReadonlyArray<ObjectProperty>,
+    ctx: TypeCtx<D>,
+    dispatch: (s: IR.SchemaObject, c: TypeCtx<D>) => T,
+  ): D;
+  emitStringEnum(
+    name: string,
+    raws: ReadonlyArray<string>,
+    emit: (d: D) => void,
+  ): T;
+  emitIntegerEnum(
+    name: string,
+    raws: ReadonlyArray<number>,
+    emit: (d: D) => void,
+  ): T;
+}
+```
+
+Hooks receive `dispatch` so they can recurse back into `schemaToType` when they need an inner type — e.g. `buildStructDecl` calls `dispatch(propSchema, childCtx)` for every property.
+
+## Reading order
+
+If you're picking up this package for the first time:
+
+1. **`src/type/dispatch.ts`** — the `schemaToType<T, D>` function and the `SchemaToTypeOps<T, D>` interface. Start here.
+2. **`packages/openapi/go/src/ir/type-ops.ts`** — concrete implementation of every hook. Smallest of the three emitters; the simplest read.
+3. **`src/type/{union,object,enum}.ts`** — the classifiers the dispatcher uses (`classifyUnion`, `classifyObjectShape`, `classifyEnumLiterals`, `iterateObjectProperties`, `assertNoEnumCollisions`). Pure functions over hey-api's IR.
+4. **`src/operation/*`** — operation-level walks (`iterOperations`, `collectLocatedParams`, `successResponses`, `classifyReturnShape`, `parseTemplatedSegment`, `deriveBaseName`, etc.). Each emitter's per-tag method generation calls into these.
+
+## Conventions
+
+- **Pre-work belongs here. Render belongs per-emitter.** When you find a `Object.entries(schema.properties).filter(...)` chain open-coded in two emitters, it goes here. When you find a `goPtr` / `ktNullable` / `swOptional` choice, it stays per-emitter.
+
+- **Classifiers return tagged-union shapes.** `classifyBody(body) → BodyShape`, `classifyUnion(schema) → UnionShape`, `classifyReturnShape(op) → ReturnShape`. Callers switch on `kind`. Adding a new variant ripples through the type checker so every consumer either handles it or fails to compile.
+
+- **Walks are generators, not arrays.** `iterOperations`, `iterateObjectProperties`. Lets callers short-circuit or filter without paying for a full list build. Callers that need an array do `Array.from(...)`.
+
+- **No target imports.** This package depends on `@hey-api/shared` (for IR types), `@ir-kit/openapi-core` (for ref / security / constants), and `@ir-kit/codegen-core` (for `pascal`, `synthName`). It does NOT depend on any go-dsl / kt-dsl / sw-dsl module.
+
+## Adding a new shared walk
+
+When you spot duplication in `@ir-kit/openapi-{go,kotlin,swift}`:
+
+1. Identify the **pre-work** (what does the IR walk produce that's target-neutral?) vs the **render** (what's the target-specific shape it gets wrapped in?).
+2. Add the pre-work helper to this package — pure function, generator, or classifier.
+3. Update each emitter to consume it. Verify the petstore SDK regen is byte-identical (the repo's `examples/petstore-sdk/` is the canonical fixture).
+4. Land in one commit per emitter pass for clean git history.
+
+If the duplication is in render — different code paths producing structurally-different target code — it stays per-emitter. Push back on consolidating principled language differences just because they look similar.
+
+## Status
+
+`0.1.0` ships the dispatcher + ~16 pre-work helpers + the `SchemaToTypeOps` interface. The three native SDK emitters (`@ir-kit/openapi-{go,kotlin,swift}`) consume it; the TypeScript emitter (`@ir-kit/openapi-typescript`) wraps `@hey-api/openapi-ts` and bypasses the dispatcher entirely (hey-api owns its own IR walk).
+
+Petstore SDK output for go + swift is byte-identical pre- and post-consolidation across all dispatcher migrations — this is the regression bar.

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export type { BodyShape } from "./operation/body.js";
+export { classifyBody, isOpaqueJsonBody } from "./operation/body.js";
+export type { IteratedOperation } from "./operation/iter.js";
+export { iterOperations } from "./operation/iter.js";
+export type { LocatedParam, ParamLocation } from "./operation/params.js";
+export { collectLocatedParams, PARAM_LOCATIONS, paramsAt, } from "./operation/params.js";
+export type { ResponseCase, ReturnShape } from "./operation/responses.js";
+export { classifyReturnShape, isSuccessStatus, successResponses, } from "./operation/responses.js";
+export { deriveBaseName, operationDocLine, splitPathSegments, } from "./operation/signature.js";
+export type { TemplatePart } from "./operation/template.js";
+export { parseTemplatedSegment } from "./operation/template.js";
+export type { TypeCtx } from "./type/context.js";
+export type { SchemaToTypeOps } from "./type/dispatch.js";
+export { schemaToType } from "./type/dispatch.js";
+export type { EnumEntryIdent, EnumKind, EnumLiteral } from "./type/enum.js";
+export { assertNoEnumCollisions, classifyEnumLiterals, } from "./type/enum.js";
+export type { ObjectProperty, ObjectShape } from "./type/object.js";
+export { classifyObjectShape, iterateObjectProperties, } from "./type/object.js";
+export type { UnionShape } from "./type/union.js";
+export { classifyUnion } from "./type/union.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,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACrE,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,QAAQ,GACT,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EACL,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+export { classifyBody, isOpaqueJsonBody } from "./operation/body.js";
+export { iterOperations } from "./operation/iter.js";
+export { collectLocatedParams, PARAM_LOCATIONS, paramsAt, } from "./operation/params.js";
+export { classifyReturnShape, isSuccessStatus, successResponses, } from "./operation/responses.js";
+export { deriveBaseName, operationDocLine, splitPathSegments, } from "./operation/signature.js";
+export { parseTemplatedSegment } from "./operation/template.js";
+export { schemaToType } from "./type/dispatch.js";
+export { assertNoEnumCollisions, classifyEnumLiterals, } from "./type/enum.js";
+export { classifyObjectShape, iterateObjectProperties, } from "./type/object.js";
+export { classifyUnion } from "./type/union.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":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,QAAQ,GACT,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EACL,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/operation/body.d.ts

@@ -0,0 +1,45 @@
+import type { IR } from "@hey-api/shared";
+/**
+ * `true` when a JSON-typed body has no concrete `type` but carries an
+ * `items[]` (typical of bare `oneOf`/`anyOf` schemas) — there's no
+ * cleanly-typed structure to bind to, so each emitter falls back to a
+ * raw byte buffer (`[]byte` / `ByteArray` / `Data`).
+ */
+export declare function isOpaqueJsonBody(schema: IR.SchemaObject): boolean;
+/**
+ * Outcome of inspecting `IR.BodyObject`'s media type + schema shape.
+ * Each emitter switches on `kind` to pick its body-param strategy.
+ */
+export type BodyShape = 
+/** `application/json` with a meaningful schema. */
+{
+    kind: "json-typed";
+}
+/** `application/json` whose schema collapses to opaque (oneOf/anyOf
+ *  without a single shared shape). Each emitter falls back to bytes. */
+ | {
+    kind: "json-opaque";
+}
+/** `multipart/form-data` whose schema is an object — flatten props
+ *  into one func param each. */
+ | {
+    kind: "multipart-object";
+}
+/** `application/x-www-form-urlencoded` whose schema is an object —
+ *  flatten props into one func param each. */
+ | {
+    kind: "form-urlencoded-object";
+}
+/** Empty / octet-stream / image/* / unknown — caller pre-encodes a
+ *  single bytes param. */
+ | {
+    kind: "opaque";
+};
+/**
+ * Classify a body by its media type + schema shape so emitters can
+ * dispatch identically on `kind`. The media-type matching rules are
+ * the same ones the generators agreed on (`@ir-kit/openapi-core`
+ * constants) — single source of truth.
+ */
+export declare function classifyBody(body: IR.BodyObject): BodyShape;
+//# sourceMappingURL=body.d.ts.map

package/dist/operation/body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/operation/body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAO1C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,GAAG,OAAO,CAEjE;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS;AACnB,mDAAmD;AACjD;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE;AACxB;wEACwE;GACtE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE;AACzB;gCACgC;GAC9B;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE;AAC9B;8CAC8C;GAC5C;IAAE,IAAI,EAAE,wBAAwB,CAAA;CAAE;AACpC;0BAC0B;GACxB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,CAiB3D"}

package/dist/operation/body.js

@@ -0,0 +1,34 @@
+import { FORM_URLENCODED_MEDIA, JSON_MEDIA_RE, MULTIPART_FORM_MEDIA, } from "@ir-kit/openapi-core";
+/**
+ * `true` when a JSON-typed body has no concrete `type` but carries an
+ * `items[]` (typical of bare `oneOf`/`anyOf` schemas) — there's no
+ * cleanly-typed structure to bind to, so each emitter falls back to a
+ * raw byte buffer (`[]byte` / `ByteArray` / `Data`).
+ */
+export function isOpaqueJsonBody(schema) {
+    return !schema.type && Array.isArray(schema.items) && schema.items.length > 0;
+}
+/**
+ * Classify a body by its media type + schema shape so emitters can
+ * dispatch identically on `kind`. The media-type matching rules are
+ * the same ones the generators agreed on (`@ir-kit/openapi-core`
+ * constants) — single source of truth.
+ */
+export function classifyBody(body) {
+    const mt = (body.mediaType ?? "").toLowerCase();
+    const schema = body.schema;
+    const isObject = schema.type === "object" && Boolean(schema.properties);
+    if (mt && JSON_MEDIA_RE.test(mt)) {
+        return isOpaqueJsonBody(schema)
+            ? { kind: "json-opaque" }
+            : { kind: "json-typed" };
+    }
+    if (mt.startsWith(MULTIPART_FORM_MEDIA) && isObject) {
+        return { kind: "multipart-object" };
+    }
+    if (mt.startsWith(FORM_URLENCODED_MEDIA) && isObject) {
+        return { kind: "form-urlencoded-object" };
+    }
+    return { kind: "opaque" };
+}
+//# sourceMappingURL=body.js.map

package/dist/operation/body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.js","sourceRoot":"","sources":["../../src/operation/body.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,aAAa,EACb,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAuB;IACtD,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AAChF,CAAC;AAsBD;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,IAAmB;IAC9C,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAChD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;QACjC,OAAO,gBAAgB,CAAC,MAAM,CAAC;YAC7B,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE;YACzB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;IAC7B,CAAC;IACD,IAAI,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,IAAI,QAAQ,EAAE,CAAC;QACpD,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;IACtC,CAAC;IACD,IAAI,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC,IAAI,QAAQ,EAAE,CAAC;QACrD,OAAO,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC"}

package/dist/operation/iter.d.ts

@@ -0,0 +1,22 @@
+import type { IR } from "@hey-api/shared";
+import { type HttpMethod } from "@ir-kit/openapi-core";
+export interface IteratedOperation {
+    pathStr: string;
+    method: HttpMethod;
+    op: IR.OperationObject;
+    /** Security-scheme names resolved for this operation. Empty when no
+     *  `schemeNames` map was passed or no entry matches `securityKey`. */
+    schemeNames: ReadonlyArray<string>;
+}
+/**
+ * Walk `IR.PathsObject` and yield one entry per `(path, method)` that
+ * carries an operation, with security-scheme names resolved up-front.
+ *
+ * Centralises the path × method nested loop, the `op = pathItem[method]`
+ * narrowing, and the `securityKey(pathStr, method)` lookup that every
+ * emitter (`operations.ts` in go / kotlin / swift) was open-coding
+ * identically. Order is `Object.entries(paths)` → `HTTP_METHODS` —
+ * stable and matches the existing emit order.
+ */
+export declare function iterOperations(paths: IR.PathsObject | undefined, schemeNames?: ReadonlyMap<string, ReadonlyArray<string>>): Generator<IteratedOperation>;
+//# sourceMappingURL=iter.d.ts.map

package/dist/operation/iter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iter.d.ts","sourceRoot":"","sources":["../../src/operation/iter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAEL,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC;IACvB;0EACsE;IACtE,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAiB,cAAc,CAC7B,KAAK,EAAE,EAAE,CAAC,WAAW,GAAG,SAAS,EACjC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,GACvD,SAAS,CAAC,iBAAiB,CAAC,CAa9B"}

package/dist/operation/iter.js

@@ -0,0 +1,27 @@
+import { HTTP_METHODS, securityKey, } from "@ir-kit/openapi-core";
+/**
+ * Walk `IR.PathsObject` and yield one entry per `(path, method)` that
+ * carries an operation, with security-scheme names resolved up-front.
+ *
+ * Centralises the path × method nested loop, the `op = pathItem[method]`
+ * narrowing, and the `securityKey(pathStr, method)` lookup that every
+ * emitter (`operations.ts` in go / kotlin / swift) was open-coding
+ * identically. Order is `Object.entries(paths)` → `HTTP_METHODS` —
+ * stable and matches the existing emit order.
+ */
+export function* iterOperations(paths, schemeNames) {
+    for (const [pathStr, pathItem] of Object.entries(paths ?? {})) {
+        for (const method of HTTP_METHODS) {
+            const op = pathItem[method];
+            if (!op)
+                continue;
+            yield {
+                pathStr,
+                method: method,
+                op,
+                schemeNames: schemeNames?.get(securityKey(pathStr, method)) ?? [],
+            };
+        }
+    }
+}
+//# sourceMappingURL=iter.js.map

package/dist/operation/iter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iter.js","sourceRoot":"","sources":["../../src/operation/iter.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EAEZ,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAW9B;;;;;;;;;GASG;AACH,MAAM,SAAS,CAAC,CAAC,cAAc,CAC7B,KAAiC,EACjC,WAAwD;IAExD,KAAK,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,CAAC;QAC9D,KAAK,MAAM,MAAM,IAAI,YAAY,EAAE,CAAC;YAClC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAmC,CAAC;YAC9D,IAAI,CAAC,EAAE;gBAAE,SAAS;YAClB,MAAM;gBACJ,OAAO;gBACP,MAAM,EAAE,MAAoB;gBAC5B,EAAE;gBACF,WAAW,EAAE,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE;aAClE,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/operation/params.d.ts

@@ -0,0 +1,27 @@
+import type { IR } from "@hey-api/shared";
+export type ParamLocation = "path" | "query" | "header" | "cookie";
+export declare const PARAM_LOCATIONS: ReadonlyArray<ParamLocation>;
+export interface LocatedParam {
+    param: IR.ParameterObject;
+    loc: ParamLocation;
+}
+/**
+ * Flatten `op.parameters.{path,query,header,cookie}` into a single
+ * array, preserving the location each came from. Result order follows
+ * `PARAM_LOCATIONS` (path → query → header → cookie), and within each
+ * bucket follows `Object.values` iteration order.
+ *
+ * Emitters typically further filter (e.g. Go drops cookies) and sort
+ * (required-first); those decisions stay per-target.
+ */
+export declare function collectLocatedParams(op: IR.OperationObject): LocatedParam[];
+/**
+ * Extract just the `IR.ParameterObject`s at a given location from a
+ * pre-collected `LocatedParam[]` (typically the `located` from
+ * `operationSignature`'s return value). The pattern
+ * `located.filter((l) => l.loc === "<loc>").map((l) => l.param)`
+ * appeared in every emitter's `impl/url.ts` (path + query) and
+ * `impl/headers.ts` (header) — 9 callsites total.
+ */
+export declare function paramsAt(located: ReadonlyArray<LocatedParam>, loc: ParamLocation): IR.ParameterObject[];
+//# sourceMappingURL=params.d.ts.map

package/dist/operation/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/operation/params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE1C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEnE,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,aAAa,CAKxD,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC;IAC1B,GAAG,EAAE,aAAa,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,GAAG,YAAY,EAAE,CAQ3E;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,GAAG,EAAE,aAAa,GACjB,EAAE,CAAC,eAAe,EAAE,CAEtB"}

package/dist/operation/params.js

@@ -0,0 +1,38 @@
+export const PARAM_LOCATIONS = [
+    "path",
+    "query",
+    "header",
+    "cookie",
+];
+/**
+ * Flatten `op.parameters.{path,query,header,cookie}` into a single
+ * array, preserving the location each came from. Result order follows
+ * `PARAM_LOCATIONS` (path → query → header → cookie), and within each
+ * bucket follows `Object.values` iteration order.
+ *
+ * Emitters typically further filter (e.g. Go drops cookies) and sort
+ * (required-first); those decisions stay per-target.
+ */
+export function collectLocatedParams(op) {
+    const out = [];
+    for (const loc of PARAM_LOCATIONS) {
+        const bucket = op.parameters?.[loc];
+        if (!bucket)
+            continue;
+        for (const param of Object.values(bucket))
+            out.push({ param, loc });
+    }
+    return out;
+}
+/**
+ * Extract just the `IR.ParameterObject`s at a given location from a
+ * pre-collected `LocatedParam[]` (typically the `located` from
+ * `operationSignature`'s return value). The pattern
+ * `located.filter((l) => l.loc === "<loc>").map((l) => l.param)`
+ * appeared in every emitter's `impl/url.ts` (path + query) and
+ * `impl/headers.ts` (header) — 9 callsites total.
+ */
+export function paramsAt(located, loc) {
+    return located.filter((l) => l.loc === loc).map((l) => l.param);
+}
+//# sourceMappingURL=params.js.map

package/dist/operation/params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.js","sourceRoot":"","sources":["../../src/operation/params.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,eAAe,GAAiC;IAC3D,MAAM;IACN,OAAO;IACP,QAAQ;IACR,QAAQ;CACT,CAAC;AAOF;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,EAAsB;IACzD,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,MAAM;YAAE,SAAS;QACtB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CACtB,OAAoC,EACpC,GAAkB;IAElB,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC"}

package/dist/operation/responses.d.ts

@@ -0,0 +1,58 @@
+import type { IR } from "@hey-api/shared";
+/**
+ * Match a 3-digit HTTP status code in the 2xx range. Treats string
+ * codes only (matching hey-api's IR shape) so `"default"` and `"4XX"`
+ * style buckets don't accidentally classify as success.
+ */
+export declare const isSuccessStatus: (code: string) => boolean;
+/**
+ * Return the operation's 2xx responses as `[code, response]` tuples,
+ * sorted by code for stable per-target emission order.
+ *
+ * Common pattern across emitters: 0 → no return, 1 → decode straight,
+ * 2+ → emit a sum-type return that dispatches on the status code.
+ */
+export declare function successResponses(op: IR.OperationObject): Array<readonly [string, IR.ResponseObject]>;
+/**
+ * One arm of a multi-2xx sum-type return. Each emitter parameterises
+ * `T` with its own target type (`GoType`, `KtType`, `SwType`) for the
+ * decoded payload. `payloadType` is omitted for empty bodies (e.g. 204).
+ */
+export interface ResponseCase<T> {
+    statusCode: string;
+    caseName: string;
+    payloadType?: T;
+}
+/**
+ * Shape of an operation's success return, normalised so each emitter
+ * can switch on `kind` instead of re-deriving the same 4-way logic
+ * (no successes, single empty, single typed, multi-case) from the
+ * `successResponses` array.
+ */
+export type ReturnShape = 
+/** Either no 2xx responses at all, or a single 2xx whose schema is
+ *  empty / meaningless. Caller renders its Unit / Void analog. */
+{
+    kind: "void";
+}
+/** Single 2xx response with a non-empty schema. Caller calls
+ *  `schemaToType(schema)` and uses the result as the return. */
+ | {
+    kind: "single";
+    schema: IR.SchemaObject;
+}
+/** Multiple 2xx responses. Caller emits a sum-type (Go interface,
+ *  Kotlin sealed class, Swift enum) and dispatches on status. */
+ | {
+    kind: "multi";
+    cases: ReadonlyArray<readonly [string, IR.ResponseObject]>;
+};
+/**
+ * Classify the success-path return for an operation. Folds the
+ * "0 success → void / 1 success with empty schema → void / 1 success
+ * with schema → single / 2+ success → multi" decision tree into one
+ * tagged union so each emitter just switches on `kind` and applies
+ * its target rendering.
+ */
+export declare function classifyReturnShape(op: IR.OperationObject): ReturnShape;
+//# sourceMappingURL=responses.d.ts.map

package/dist/operation/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../src/operation/responses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAG1C;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,OAA+B,CAAC;AAE/E;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,EAAE,CAAC,eAAe,GACrB,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAM7C;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,CAAC,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW;AACrB;kEACkE;AAChE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB;gEACgE;GAC9D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAA;CAAE;AAC7C;iEACiE;GAC/D;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;CAC5D,CAAC;AAEN;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,GAAG,WAAW,CASvE"}

package/dist/operation/responses.js

@@ -0,0 +1,39 @@
+import { isMeaningless } from "@ir-kit/openapi-core";
+/**
+ * Match a 3-digit HTTP status code in the 2xx range. Treats string
+ * codes only (matching hey-api's IR shape) so `"default"` and `"4XX"`
+ * style buckets don't accidentally classify as success.
+ */
+export const isSuccessStatus = (code) => /^2\d\d$/.test(code);
+/**
+ * Return the operation's 2xx responses as `[code, response]` tuples,
+ * sorted by code for stable per-target emission order.
+ *
+ * Common pattern across emitters: 0 → no return, 1 → decode straight,
+ * 2+ → emit a sum-type return that dispatches on the status code.
+ */
+export function successResponses(op) {
+    return Object.entries(op.responses ?? {})
+        .filter(([k]) => isSuccessStatus(k))
+        .sort(([a], [b]) => a.localeCompare(b));
+}
+/**
+ * Classify the success-path return for an operation. Folds the
+ * "0 success → void / 1 success with empty schema → void / 1 success
+ * with schema → single / 2+ success → multi" decision tree into one
+ * tagged union so each emitter just switches on `kind` and applies
+ * its target rendering.
+ */
+export function classifyReturnShape(op) {
+    const success = successResponses(op);
+    if (success.length === 0)
+        return { kind: "void" };
+    if (success.length === 1) {
+        const [, resp] = success[0];
+        if (!resp?.schema || isMeaningless(resp.schema))
+            return { kind: "void" };
+        return { kind: "single", schema: resp.schema };
+    }
+    return { kind: "multi", cases: success };
+}
+//# sourceMappingURL=responses.js.map

package/dist/operation/responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.js","sourceRoot":"","sources":["../../src/operation/responses.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAE/E;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,EAAsB;IAEtB,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC;SACtC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;SACnC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAEvC,CAAC;AACJ,CAAC;AAiCD;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAsB;IACxD,MAAM,OAAO,GAAG,gBAAgB,CAAC,EAAE,CAAC,CAAC;IACrC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAClD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAE,CAAC;QAC7B,IAAI,CAAC,IAAI,EAAE,MAAM,IAAI,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QACzE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IACjD,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAC3C,CAAC"}

package/dist/operation/signature.d.ts

@@ -0,0 +1,29 @@
+import type { IR } from "@hey-api/shared";
+import { type HttpMethod } from "@ir-kit/openapi-core";
+/**
+ * Derive the canonical *base* name for an operation — the unstyled
+ * identifier each emitter then runs through its own case transform
+ * (`exportedIdent` for Go, `camel` + `pascal` for Kotlin / Swift).
+ *
+ *  - When `op.operationId` is present, prefer it verbatim. Producers
+ *    are expected to write it in a sensible casing already; let the
+ *    emitter normalise.
+ *  - Otherwise, derive from `<method>_<segments...>` with curly braces
+ *    stripped from path templates. Underscore form is the lowest
+ *    common denominator: PascalCase / camelCase / snake_case can all
+ *    be re-derived from it.
+ */
+export declare function deriveBaseName(op: IR.OperationObject, method: HttpMethod, path: string): string;
+/**
+ * Standard one-line doc comment every emitter puts on a generated
+ * operation method: `<METHOD> <path>`.
+ */
+export declare function operationDocLine(method: HttpMethod, pathStr: string): string;
+/**
+ * Split a templated OpenAPI path (`/pets/{id}/photos`) into its
+ * non-empty segments (`["pets", "{id}", "photos"]`), trimming a
+ * leading `/`. Each emitter's URL builder iterates these to append
+ * to the target's URL/baseURL value.
+ */
+export declare function splitPathSegments(pathStr: string): string[];
+//# sourceMappingURL=signature.d.ts.map

package/dist/operation/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src/operation/signature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,EAAE,CAAC,eAAe,EACtB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,GACX,MAAM,CAOR;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAG3D"}

package/dist/operation/signature.js

@@ -0,0 +1,41 @@
+import { HTTP_METHOD_LITERAL } from "@ir-kit/openapi-core";
+/**
+ * Derive the canonical *base* name for an operation — the unstyled
+ * identifier each emitter then runs through its own case transform
+ * (`exportedIdent` for Go, `camel` + `pascal` for Kotlin / Swift).
+ *
+ *  - When `op.operationId` is present, prefer it verbatim. Producers
+ *    are expected to write it in a sensible casing already; let the
+ *    emitter normalise.
+ *  - Otherwise, derive from `<method>_<segments...>` with curly braces
+ *    stripped from path templates. Underscore form is the lowest
+ *    common denominator: PascalCase / camelCase / snake_case can all
+ *    be re-derived from it.
+ */
+export function deriveBaseName(op, method, path) {
+    if (op.operationId)
+        return op.operationId;
+    const segments = path
+        .split("/")
+        .filter(Boolean)
+        .map((s) => s.replace(/[{}]/g, ""));
+    return [method, ...segments].join("_") || method;
+}
+/**
+ * Standard one-line doc comment every emitter puts on a generated
+ * operation method: `<METHOD> <path>`.
+ */
+export function operationDocLine(method, pathStr) {
+    return `${HTTP_METHOD_LITERAL[method]} ${pathStr}`;
+}
+/**
+ * Split a templated OpenAPI path (`/pets/{id}/photos`) into its
+ * non-empty segments (`["pets", "{id}", "photos"]`), trimming a
+ * leading `/`. Each emitter's URL builder iterates these to append
+ * to the target's URL/baseURL value.
+ */
+export function splitPathSegments(pathStr) {
+    const stripped = pathStr.startsWith("/") ? pathStr.slice(1) : pathStr;
+    return stripped.split("/").filter((s) => s.length > 0);
+}
+//# sourceMappingURL=signature.js.map

package/dist/operation/signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.js","sourceRoot":"","sources":["../../src/operation/signature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAmB,MAAM,sBAAsB,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAC5B,EAAsB,EACtB,MAAkB,EAClB,IAAY;IAEZ,IAAI,EAAE,CAAC,WAAW;QAAE,OAAO,EAAE,CAAC,WAAW,CAAC;IAC1C,MAAM,QAAQ,GAAG,IAAI;SAClB,KAAK,CAAC,GAAG,CAAC;SACV,MAAM,CAAC,OAAO,CAAC;SACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACtC,OAAO,CAAC,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC;AACnD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAkB,EAAE,OAAe;IAClE,OAAO,GAAG,mBAAmB,CAAC,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;AACrD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAe;IAC/C,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IACtE,OAAO,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACzD,CAAC"}