@ir-kit/openapi 0.1.0

package/dist/operation/template.d.ts

@@ -0,0 +1,30 @@
+import type { IR } from "@hey-api/shared";
+/**
+ * One part of a parsed URL path template segment.
+ *  - `literal` — a literal substring with no `{...}` placeholder
+ *  - `param`   — a `{name}` placeholder, with the matched
+ *                `ParameterObject` if found in the supplied path
+ *                params (callers typically need the schema to decide
+ *                stringification, plus the raw name to feed their
+ *                language-specific identifier transform).
+ */
+export type TemplatePart = {
+    kind: "literal";
+    text: string;
+} | {
+    kind: "param";
+    name: string;
+    param: IR.ParameterObject | undefined;
+};
+/**
+ * Split a single path segment containing zero or more `{name}` template
+ * placeholders into ordered literal/param parts. The regex (`/\{([^}]+)\}/g`)
+ * + lastEnd cursor walk was open-coded identically in every emitter's
+ * `impl/url.ts`; here once, in one place.
+ *
+ * `pathParams` is the operation's path-located params; resolved
+ * placeholders carry the matched `ParameterObject` so emitters can
+ * read its schema (e.g. for stringification decisions).
+ */
+export declare function parseTemplatedSegment(seg: string, pathParams: ReadonlyArray<IR.ParameterObject>): TemplatePart[];
+//# sourceMappingURL=template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/operation/template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,eAAe,GAAG,SAAS,CAAA;CAAE,CAAC;AAE3E;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,aAAa,CAAC,EAAE,CAAC,eAAe,CAAC,GAC5C,YAAY,EAAE,CAqBhB"}

package/dist/operation/template.js

@@ -0,0 +1,33 @@
+/**
+ * Split a single path segment containing zero or more `{name}` template
+ * placeholders into ordered literal/param parts. The regex (`/\{([^}]+)\}/g`)
+ * + lastEnd cursor walk was open-coded identically in every emitter's
+ * `impl/url.ts`; here once, in one place.
+ *
+ * `pathParams` is the operation's path-located params; resolved
+ * placeholders carry the matched `ParameterObject` so emitters can
+ * read its schema (e.g. for stringification decisions).
+ */
+export function parseTemplatedSegment(seg, pathParams) {
+    const re = /\{([^}]+)\}/g;
+    const parts = [];
+    let lastEnd = 0;
+    let m;
+    while ((m = re.exec(seg)) !== null) {
+        if (m.index > lastEnd) {
+            parts.push({ kind: "literal", text: seg.slice(lastEnd, m.index) });
+        }
+        const name = m[1];
+        parts.push({
+            kind: "param",
+            name,
+            param: pathParams.find((p) => p.name === name),
+        });
+        lastEnd = m.index + m[0].length;
+    }
+    if (lastEnd < seg.length) {
+        parts.push({ kind: "literal", text: seg.slice(lastEnd) });
+    }
+    return parts;
+}
+//# sourceMappingURL=template.js.map

package/dist/operation/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../src/operation/template.ts"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAW,EACX,UAA6C;IAE7C,MAAM,EAAE,GAAG,cAAc,CAAC;IAC1B,MAAM,KAAK,GAAmB,EAAE,CAAC;IACjC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,CAAyB,CAAC;IAC9B,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QACnC,IAAI,CAAC,CAAC,KAAK,GAAG,OAAO,EAAE,CAAC;YACtB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACrE,CAAC;QACD,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;QACnB,KAAK,CAAC,IAAI,CAAC;YACT,IAAI,EAAE,OAAO;YACb,IAAI;YACJ,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC;SAC/C,CAAC,CAAC;QACH,OAAO,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAClC,CAAC;IACD,IAAI,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/type/context.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared type-walker context, generic over the per-target Decl type.
+ * Each emitter narrows `D` to its own AST node — `GoDecl`, `KtDecl`,
+ * `SwDecl`, etc. — and re-exports a concrete alias.
+ *
+ * The walker uses `emit` to promote synthesised inline types
+ * (objects, enums) to top-level declarations; `ownerName` and
+ * `propPath` drive deterministic names for those synthesised types
+ * (e.g. `Owner_Path`).
+ */
+export interface TypeCtx<D> {
+    emit: (d: D) => void;
+    /** Used to synthesise names for inline objects/enums: `Owner_Path`. */
+    ownerName: string;
+    propPath: ReadonlyArray<string>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/type/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/type/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACrB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjC"}

package/dist/type/context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.js.map

package/dist/type/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/type/context.ts"],"names":[],"mappings":""}

package/dist/type/dispatch.d.ts

@@ -0,0 +1,86 @@
+import type { IR } from "@hey-api/shared";
+import type { TypeCtx } from "./context.js";
+import { assertNoEnumCollisions } from "./enum.js";
+import { classifyObjectShape, iterateObjectProperties, type ObjectProperty } from "./object.js";
+import { classifyUnion } from "./union.js";
+/**
+ * Per-target leaf operations the shared dispatchers (schemaToType,
+ * unionToType, inlineObjectType, buildEnumFromIR) call into. `T` is
+ * the emitter's target type (GoType / KtType / SwType), `D` is its
+ * decl type (GoDecl / KtDecl / SwDecl).
+ *
+ * Each emitter writes one of these records. Per-target rendering
+ * (pointer vs nullable, naming conventions, synthName joiner,
+ * decl-construction call shape) lives entirely here; the dispatchers
+ * stay neutral.
+ */
+export interface SchemaToTypeOps<T, D> {
+    /** `$ref` → named target type. */
+    refType(name: string): T;
+    /** Array element → target array/slice/list type. */
+    arrayType(elem: T): T;
+    /** Open object's value type — target map's value-of-Any. */
+    mapType(valueType: T): T;
+    /** "No return" analog — `goAny` (Go callers drop the result slot),
+     *  `ktUnit`, `swVoid`. */
+    voidType(): T;
+    /** Untyped fallback — `goAny` / `ktAny` / `swAny`. */
+    anyType(): T;
+    /** Standalone nullable-any — what `null`-typed primitives become.
+     *  Go wraps any in pointer; Kotlin / Swift wrap in nullable/optional. */
+    nullableAnyType(): T;
+    /** Wrap a known type in the target's optional wrapper for the
+     *  union "single + nullable" path. Go's choice is conditional
+     *  (`isPointerable` check), so this hook receives both `nullable`
+     *  and the bare inner type and decides. */
+    wrapForUnionSingle(inner: T, nullable: boolean): T;
+    /** Fallback type for unions with 2+ non-null branches.  Go ignores
+     *  the nullable bit (`interface{}` already holds nil); Kotlin /
+     *  Swift wrap if nullable. */
+    unionFallback(nullable: boolean): T;
+    /** Primitive dispatch (string, integer, number, boolean). Returns
+     *  `undefined` for non-primitive schemas so the outer dispatcher
+     *  can fall through to compound handling. */
+    primitiveType(schema: IR.SchemaObject): T | undefined;
+    /** Build a synth name from ctx.ownerName + propPath. Joiner is
+     *  per-target — Go uses `""` to keep `go vet` quiet, Kotlin /
+     *  Swift / TypeScript use `"_"`. */
+    synthName(ownerName: string, propPath: ReadonlyArray<string>): string;
+    /** Build a named struct/data-class/struct decl from an iterated
+     *  property list. Per-target work: property identifier transform,
+     *  optional wrapping, target field construction, annotation /
+     *  coding-key emission. Returns the decl; the caller chooses to
+     *  `emit` it (dispatcher does this; schema.ts also calls this
+     *  directly for top-level component schemas). */
+    buildStructDecl(name: string, properties: ReadonlyArray<ObjectProperty>, ctx: TypeCtx<D>, dispatch: (s: IR.SchemaObject, c: TypeCtx<D>) => T): D;
+    /** Emit a string-typed enum decl and return a ref. Per-target work:
+     *  case-identifier transform (Go `<Type><Raw>`, Kotlin
+     *  `SCREAMING_SNAKE`, Swift `camel`), decl construction, runtime
+     *  bookkeeping (`@SerialName`, `Codable` conformance). */
+    emitStringEnum(name: string, raws: ReadonlyArray<string>, emit: (d: D) => void): T;
+    /** Same for integer-typed enums. */
+    emitIntegerEnum(name: string, raws: ReadonlyArray<number>, emit: (d: D) => void): T;
+}
+/**
+ * Resolve a union-shaped `IR.SchemaObject` to a target type. Wraps
+ * `classifyUnion` with per-target hooks for each branch.
+ */
+export declare function unionToType<T, D>(schema: IR.SchemaObject, ctx: TypeCtx<D>, ops: SchemaToTypeOps<T, D>, dispatch: (s: IR.SchemaObject, c: TypeCtx<D>) => T): T;
+/**
+ * Resolve an inline object schema to a target type. Three-way
+ * dispatch via `classifyObjectShape`, then per-target rendering:
+ *
+ *  - named-struct → synth a name, build + emit struct, return ref
+ *  - map          → wrap value type in the target's map
+ *  - open-map     → map<string, any>
+ */
+export declare function inlineObjectType<T, D>(schema: IR.SchemaObject, ctx: TypeCtx<D>, ops: SchemaToTypeOps<T, D>, dispatch: (s: IR.SchemaObject, c: TypeCtx<D>) => T): T;
+/**
+ * Top-level dispatch from `IR.SchemaObject` to a target type. Routes
+ * each schema shape to the appropriate handler (`unionToType` /
+ * `inlineObjectType` / per-target enum emitter / target leaf
+ * constructor). The per-target leaf decisions live in `ops`.
+ */
+export declare function schemaToType<T, D>(schema: IR.SchemaObject, ctx: TypeCtx<D>, ops: SchemaToTypeOps<T, D>): T;
+export { assertNoEnumCollisions, classifyObjectShape, classifyUnion, iterateObjectProperties, };
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/type/dispatch.d.ts.map

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

package/dist/type/dispatch.js

@@ -0,0 +1,102 @@
+import { refName } from "@ir-kit/openapi-core";
+import { assertNoEnumCollisions, classifyEnumLiterals, } from "./enum.js";
+import { classifyObjectShape, iterateObjectProperties, } from "./object.js";
+import { classifyUnion } from "./union.js";
+/**
+ * Resolve a union-shaped `IR.SchemaObject` to a target type. Wraps
+ * `classifyUnion` with per-target hooks for each branch.
+ */
+export function unionToType(schema, ctx, ops, dispatch) {
+    const shape = classifyUnion(schema);
+    switch (shape.kind) {
+        case "intersection-with-properties":
+            return inlineObjectType(schema, ctx, ops, dispatch);
+        case "intersection-empty":
+            return ops.anyType();
+        case "single":
+            return ops.wrapForUnionSingle(dispatch(shape.inner, ctx), shape.nullable);
+        case "multi":
+            return ops.unionFallback(shape.nullable);
+    }
+}
+/**
+ * Resolve an inline object schema to a target type. Three-way
+ * dispatch via `classifyObjectShape`, then per-target rendering:
+ *
+ *  - named-struct → synth a name, build + emit struct, return ref
+ *  - map          → wrap value type in the target's map
+ *  - open-map     → map<string, any>
+ */
+export function inlineObjectType(schema, ctx, ops, dispatch) {
+    const shape = classifyObjectShape(schema);
+    switch (shape.kind) {
+        case "named-struct": {
+            const name = ops.synthName(ctx.ownerName, ctx.propPath);
+            const properties = Array.from(iterateObjectProperties(schema));
+            ctx.emit(ops.buildStructDecl(name, properties, ctx, dispatch));
+            return ops.refType(name);
+        }
+        case "map":
+            return ops.mapType(dispatch(shape.valueSchema, ctx));
+        case "open-map":
+            return ops.mapType(ops.anyType());
+    }
+}
+/**
+ * Top-level dispatch from `IR.SchemaObject` to a target type. Routes
+ * each schema shape to the appropriate handler (`unionToType` /
+ * `inlineObjectType` / per-target enum emitter / target leaf
+ * constructor). The per-target leaf decisions live in `ops`.
+ */
+export function schemaToType(schema, ctx, ops) {
+    const dispatch = (s, c) => schemaToType(s, c, ops);
+    if (schema.$ref)
+        return ops.refType(refName(schema.$ref));
+    // Untyped item-bearing schema → union (oneOf/anyOf, possibly nullable).
+    if (schema.items && schema.items.length > 0 && !schema.type) {
+        return unionToType(schema, ctx, ops, dispatch);
+    }
+    const primitive = ops.primitiveType(schema);
+    if (primitive !== undefined)
+        return primitive;
+    switch (schema.type) {
+        case "array": {
+            const elem = schema.items?.[0];
+            return ops.arrayType(elem ? dispatch(elem, ctx) : ops.anyType());
+        }
+        case "tuple":
+            return ops.arrayType(ops.anyType());
+        case "enum": {
+            const name = ops.synthName(ctx.ownerName, ctx.propPath);
+            // Caller's emit walks the schema's `items[].const`; we surface
+            // the typed list via the helper rather than re-defining the
+            // literal-extraction here (lives in @ir-kit/openapi-tools).
+            const rawValues = (schema.items ?? [])
+                .map((i) => i.const)
+                .filter((v) => typeof v === "string" ||
+                typeof v === "number" ||
+                typeof v === "boolean");
+            // Collision enforcement is per-target (the identifiers differ),
+            // so we hand off to the target's emitStringEnum / emitIntegerEnum
+            // hook with the raw values; they call assertNoEnumCollisions
+            // internally after computing their identifiers.
+            const kind = classifyEnumLiterals(rawValues, name);
+            if (kind === "integer")
+                return ops.emitIntegerEnum(name, rawValues, ctx.emit);
+            return ops.emitStringEnum(name, rawValues, ctx.emit);
+        }
+        case "object":
+            return inlineObjectType(schema, ctx, ops, dispatch);
+        case "null":
+            return ops.nullableAnyType();
+        case "never":
+        case "void":
+        case "undefined":
+            return ops.voidType();
+        default:
+            return ops.anyType();
+    }
+}
+// Re-export so emitters can import everything from one place.
+export { assertNoEnumCollisions, classifyObjectShape, classifyUnion, iterateObjectProperties, };
+//# sourceMappingURL=dispatch.js.map

package/dist/type/dispatch.js.map

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

package/dist/type/enum.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The supported leaf shape for `IR.SchemaObject` enum values. Mirrors
+ * `EnumLiteral` from `@ir-kit/openapi-tools` — re-declared here to keep
+ * the package's dependency footprint minimal (this is a 3-word union;
+ * a workspace dep just to import it would be heavyweight).
+ */
+export type EnumLiteral = string | number | boolean;
+export type EnumKind = "string" | "integer";
+/**
+ * Classify a set of enum literals as all-string or all-integer. Throws
+ * on mixed (or otherwise unsupported) shapes. Each emitter then picks
+ * its target rendering — Go emits `type ... string` + typed-consts,
+ * Kotlin emits an `enum class(val raw: String)` or a typealias to
+ * `Int`, Swift emits a raw-typed `enum: String, Codable`.
+ *
+ * `name` is woven into the thrown error message so the caller doesn't
+ * have to re-wrap; emitter call-sites previously open-coded the same
+ * `throw new Error(\`Enum ${name}: members must all be strings or all
+ * integers; got ...\`)` line.
+ */
+export declare function classifyEnumLiterals(values: ReadonlyArray<EnumLiteral>, name: string): EnumKind;
+export interface EnumEntryIdent<T extends string | number> {
+    /** The identifier emitted into the target source (Go `StatusAvailable`,
+     *  Kotlin `available`, Swift `available`). */
+    identifier: string;
+    /** The raw enum value the identifier was derived from. */
+    raw: T;
+}
+/**
+ * Detect emitter-side identifier collisions across enum entries and
+ * throw a descriptive error. Each emitter normalises raw enum values
+ * to its own identifier convention (Go `enumEntrySuffix`, Kotlin
+ * `enumEntryIdent`, Swift `safeCaseName`); when two raw values
+ * normalise to the same identifier the emitted source won't compile,
+ * so we throw early with the offending name and the colliding raws.
+ *
+ * `noun` is the label used in the error message — kept per-emitter to
+ * preserve historical wording (Go / Kotlin say `entry name`, Swift
+ * says `case name`); tests pin the exact phrase.
+ */
+export declare function assertNoEnumCollisions<T extends string | number>(schemaName: string, entries: Iterable<EnumEntryIdent<T>>, noun?: "entry name" | "case name"): void;
+//# sourceMappingURL=enum.d.ts.map

package/dist/type/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/type/enum.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEpD,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,EAClC,IAAI,EAAE,MAAM,GACX,QAAQ,CAWV;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACvD;kDAC8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,GAAG,EAAE,CAAC,CAAC;CACR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC9D,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EACpC,IAAI,GAAE,YAAY,GAAG,WAA0B,GAC9C,IAAI,CAiBN"}

package/dist/type/enum.js

@@ -0,0 +1,49 @@
+/**
+ * Classify a set of enum literals as all-string or all-integer. Throws
+ * on mixed (or otherwise unsupported) shapes. Each emitter then picks
+ * its target rendering — Go emits `type ... string` + typed-consts,
+ * Kotlin emits an `enum class(val raw: String)` or a typealias to
+ * `Int`, Swift emits a raw-typed `enum: String, Codable`.
+ *
+ * `name` is woven into the thrown error message so the caller doesn't
+ * have to re-wrap; emitter call-sites previously open-coded the same
+ * `throw new Error(\`Enum ${name}: members must all be strings or all
+ * integers; got ...\`)` line.
+ */
+export function classifyEnumLiterals(values, name) {
+    const allStrings = values.every((v) => typeof v === "string");
+    const allIntegers = values.every((v) => typeof v === "number" && Number.isInteger(v));
+    if (!allStrings && !allIntegers) {
+        throw new Error(`Enum ${name}: members must all be strings or all integers; got ${JSON.stringify(values)}`);
+    }
+    return allIntegers ? "integer" : "string";
+}
+/**
+ * Detect emitter-side identifier collisions across enum entries and
+ * throw a descriptive error. Each emitter normalises raw enum values
+ * to its own identifier convention (Go `enumEntrySuffix`, Kotlin
+ * `enumEntryIdent`, Swift `safeCaseName`); when two raw values
+ * normalise to the same identifier the emitted source won't compile,
+ * so we throw early with the offending name and the colliding raws.
+ *
+ * `noun` is the label used in the error message — kept per-emitter to
+ * preserve historical wording (Go / Kotlin say `entry name`, Swift
+ * says `case name`); tests pin the exact phrase.
+ */
+export function assertNoEnumCollisions(schemaName, entries, noun = "entry name") {
+    const collisions = new Map();
+    for (const { identifier, raw } of entries) {
+        const list = collisions.get(identifier) ?? [];
+        list.push(raw);
+        collisions.set(identifier, list);
+    }
+    for (const [identifier, raws] of collisions) {
+        if (raws.length > 1) {
+            const formatted = raws
+                .map((r) => (typeof r === "string" ? `"${r}"` : String(r)))
+                .join(", ");
+            throw new Error(`Enum ${schemaName}: ${noun} "${identifier}" collides for raw values [${formatted}]`);
+        }
+    }
+}
+//# sourceMappingURL=enum.js.map

package/dist/type/enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/type/enum.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAkC,EAClC,IAAY;IAEZ,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;IAC9D,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CACpD,CAAC;IACF,IAAI,CAAC,UAAU,IAAI,CAAC,WAAW,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,QAAQ,IAAI,sDAAsD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAC3F,CAAC;IACJ,CAAC;IACD,OAAO,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC5C,CAAC;AAUD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,UAAkB,EAClB,OAAoC,EACpC,OAAmC,YAAY;IAE/C,MAAM,UAAU,GAAG,IAAI,GAAG,EAAe,CAAC;IAC1C,KAAK,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,OAAO,EAAE,CAAC;QAC1C,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QAC9C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACf,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IACD,KAAK,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,UAAU,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,MAAM,SAAS,GAAG,IAAI;iBACnB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC1D,IAAI,CAAC,IAAI,CAAC,CAAC;YACd,MAAM,IAAI,KAAK,CACb,QAAQ,UAAU,KAAK,IAAI,KAAK,UAAU,8BAA8B,SAAS,GAAG,CACrF,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/type/object.d.ts

@@ -0,0 +1,53 @@
+import type { IR } from "@hey-api/shared";
+/**
+ * High-level dispatch for inline object schemas. Each emitter then
+ * picks its target rendering:
+ *
+ *  - `named-struct`  → synth a name, emit a struct/data-class/struct,
+ *                      return a ref to it
+ *  - `map`           → render as `map[string]V` / `Map<String, V>` /
+ *                      `[String: V]` over the inner value schema
+ *  - `open-map`      → same map, but value is `any` / `Any` / `Any`
+ *                      since `additionalProperties` was missing or
+ *                      `true`/empty
+ */
+export type ObjectShape = {
+    kind: "named-struct";
+} | {
+    kind: "map";
+    valueSchema: IR.SchemaObject;
+} | {
+    kind: "open-map";
+};
+/**
+ * Classify an object-shaped schema by its property layout. Used by
+ * each emitter's `inlineObjectType` to drive the same three-way
+ * dispatch identically.
+ */
+export declare function classifyObjectShape(schema: IR.SchemaObject): ObjectShape;
+export interface ObjectProperty {
+    jsonKey: string;
+    schema: IR.SchemaObject;
+    /** True when the property name appears in `schema.required`. */
+    required: boolean;
+    /** True when the property is `string` + `format: "binary"`. Common
+     *  enough across emitters (multipart-binary handling) to surface
+     *  alongside the basic iteration. */
+    isBinary: boolean;
+    /** The propPath segment for this property, ready to plug into a
+     *  recursive `schemaToType(propSchema, { ...ctx, propPath: [segment] })`
+     *  call. Pre-computed as `pascal(jsonKey)` since both `synthName`
+     *  variants (codegen-core's `_`-joined and Go's `""`-joined) expect
+     *  PascalCase parts. */
+    propPathSegment: string;
+}
+/**
+ * Walk `schema.properties` in declaration order and yield one
+ * `ObjectProperty` per entry, with the `required` membership,
+ * binary-format detection, and pre-computed propPath segment
+ * surfaced. Used by every emitter's `type/object.ts`
+ * (struct/data-class/struct field generation) and `operation/body.ts`
+ * (multipart / urlencoded flat-param expansion).
+ */
+export declare function iterateObjectProperties(schema: IR.SchemaObject): Generator<ObjectProperty>;
+//# sourceMappingURL=object.d.ts.map

package/dist/type/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/type/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAG1C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,WAAW,EAAE,EAAE,CAAC,YAAY,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAEzB;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,GAAG,WAAW,CAMxE;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC;IACxB,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;IAClB;;yCAEqC;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;4BAIwB;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAiB,uBAAuB,CACtC,MAAM,EAAE,EAAE,CAAC,YAAY,GACtB,SAAS,CAAC,cAAc,CAAC,CAW3B"}

package/dist/type/object.js

@@ -0,0 +1,36 @@
+import { pascal } from "@ir-kit/codegen-core";
+/**
+ * Classify an object-shaped schema by its property layout. Used by
+ * each emitter's `inlineObjectType` to drive the same three-way
+ * dispatch identically.
+ */
+export function classifyObjectShape(schema) {
+    const hasNamedProperties = Object.keys(schema.properties ?? {}).length > 0;
+    if (hasNamedProperties)
+        return { kind: "named-struct" };
+    const ap = schema.additionalProperties;
+    if (ap && typeof ap === "object")
+        return { kind: "map", valueSchema: ap };
+    return { kind: "open-map" };
+}
+/**
+ * Walk `schema.properties` in declaration order and yield one
+ * `ObjectProperty` per entry, with the `required` membership,
+ * binary-format detection, and pre-computed propPath segment
+ * surfaced. Used by every emitter's `type/object.ts`
+ * (struct/data-class/struct field generation) and `operation/body.ts`
+ * (multipart / urlencoded flat-param expansion).
+ */
+export function* iterateObjectProperties(schema) {
+    const required = new Set(schema.required ?? []);
+    for (const [jsonKey, propSchema] of Object.entries(schema.properties ?? {})) {
+        yield {
+            jsonKey,
+            schema: propSchema,
+            required: required.has(jsonKey),
+            isBinary: propSchema.type === "string" && propSchema.format === "binary",
+            propPathSegment: pascal(jsonKey),
+        };
+    }
+}
+//# sourceMappingURL=object.js.map

package/dist/type/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/type/object.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAmB9C;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAuB;IACzD,MAAM,kBAAkB,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3E,IAAI,kBAAkB;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;IACxD,MAAM,EAAE,GAAG,MAAM,CAAC,oBAAoB,CAAC;IACvC,IAAI,EAAE,IAAI,OAAO,EAAE,KAAK,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC;IAC1E,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC9B,CAAC;AAmBD;;;;;;;GAOG;AACH,MAAM,SAAS,CAAC,CAAC,uBAAuB,CACtC,MAAuB;IAEvB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAChD,KAAK,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,EAAE,CAAC;QAC5E,MAAM;YACJ,OAAO;YACP,MAAM,EAAE,UAAU;YAClB,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;YAC/B,QAAQ,EAAE,UAAU,CAAC,IAAI,KAAK,QAAQ,IAAI,UAAU,CAAC,MAAM,KAAK,QAAQ;YACxE,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC;SACjC,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/type/union.d.ts

@@ -0,0 +1,35 @@
+import type { IR } from "@hey-api/shared";
+/**
+ * Outcome of inspecting a union-shaped schema. Pure structural —
+ * caller still needs to decide how to render each kind in its target
+ * language (Go pointer vs Kotlin nullable vs Swift optional, fall-back
+ * to `any` vs `Any` vs language equivalents).
+ */
+export type UnionShape = {
+    kind: "intersection-with-properties";
+} | {
+    kind: "intersection-empty";
+} | {
+    kind: "single";
+    inner: IR.SchemaObject;
+    nullable: boolean;
+} | {
+    kind: "multi";
+    nullable: boolean;
+};
+/**
+ * Classify a union-shaped schema (`logicalOperator: "or" | "and"`)
+ * into one of the cases each emitter handles. hey-api represents
+ * OpenAPI 3.1 nullables as `or` unions with a `{type:"null"}` branch;
+ * `allOf` folds become `and`.
+ *
+ *  - `and` + properties → caller dispatches to its inline-object path.
+ *  - `and` empty        → caller renders its `any` analog.
+ *  - 1 non-null branch  → caller renders the inner, applying its own
+ *                         nullable wrapper iff `nullable === true`.
+ *  - 2+ non-null        → caller falls back to its `any`; `nullable`
+ *                         is reported but caller decides whether to
+ *                         apply it (Go drops it, KT/Swift wrap).
+ */
+export declare function classifyUnion(schema: IR.SchemaObject): UnionShape;
+//# sourceMappingURL=union.d.ts.map

package/dist/type/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../src/type/union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,8BAA8B,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,oBAAoB,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,GAAG,UAAU,CAajE"}

package/dist/type/union.js

@@ -0,0 +1,29 @@
+/**
+ * Classify a union-shaped schema (`logicalOperator: "or" | "and"`)
+ * into one of the cases each emitter handles. hey-api represents
+ * OpenAPI 3.1 nullables as `or` unions with a `{type:"null"}` branch;
+ * `allOf` folds become `and`.
+ *
+ *  - `and` + properties → caller dispatches to its inline-object path.
+ *  - `and` empty        → caller renders its `any` analog.
+ *  - 1 non-null branch  → caller renders the inner, applying its own
+ *                         nullable wrapper iff `nullable === true`.
+ *  - 2+ non-null        → caller falls back to its `any`; `nullable`
+ *                         is reported but caller decides whether to
+ *                         apply it (Go drops it, KT/Swift wrap).
+ */
+export function classifyUnion(schema) {
+    if (schema.logicalOperator === "and") {
+        return schema.properties
+            ? { kind: "intersection-with-properties" }
+            : { kind: "intersection-empty" };
+    }
+    const items = schema.items ?? [];
+    const nonNull = items.filter((i) => i.type !== "null");
+    const nullable = nonNull.length < items.length;
+    if (nonNull.length === 1) {
+        return { kind: "single", inner: nonNull[0], nullable };
+    }
+    return { kind: "multi", nullable };
+}
+//# sourceMappingURL=union.js.map

package/dist/type/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/type/union.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,MAAuB;IACnD,IAAI,MAAM,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;QACrC,OAAO,MAAM,CAAC,UAAU;YACtB,CAAC,CAAC,EAAE,IAAI,EAAE,8BAA8B,EAAE;YAC1C,CAAC,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC;IACrC,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC;IACjC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAE,EAAE,QAAQ,EAAE,CAAC;IAC1D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AACrC,CAAC"}