@ir-kit/kit 0.0.1 → 1.0.0

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

@@ -0,0 +1,37 @@
+import type { IR } from "../../ir/index.js";
+import { type Schema } from "../../schema/index.js";
+/**
+ * `true` when a JSON-typed body has no concrete `type` but carries
+ * `oneOf`/`anyOf` branches — 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: Schema): boolean;
+/**
+ * Outcome of inspecting a body's media type + schema shape. Each
+ * emitter switches on `kind` to pick its body-param strategy.
+ */
+export type BodyShape = {
+    kind: "json-typed";
+} | {
+    kind: "json-opaque";
+} | {
+    kind: "multipart-object";
+} | {
+    kind: "form-urlencoded-object";
+} | {
+    kind: "opaque";
+};
+export interface ClassifiedBody {
+    shape: BodyShape;
+    /** The body's schema in canonical form, ready to feed `schemaToType`
+     *  or `iterateObjectProperties`. */
+    schema: Schema;
+}
+/**
+ * Classify a body by media type + schema shape and return the schema
+ * pre-converted to canonical form so each emitter can dispatch on
+ * `shape.kind` without re-converting.
+ */
+export declare function classifyBody(body: IR.Body): ClassifiedBody;
+//# sourceMappingURL=body.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../../src/openapi/operation/body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAQpD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,wBAAwB,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvB,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,CAAC;IACjB;wCACoC;IACpC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,cAAc,CAkB1D"}

package/dist/openapi/operation/body.js

@@ -0,0 +1,40 @@
+import {} from "../../schema/index.js";
+import { FORM_URLENCODED_MEDIA, JSON_MEDIA_RE, MULTIPART_FORM_MEDIA, } from "../spec/constants.js";
+/**
+ * `true` when a JSON-typed body has no concrete `type` but carries
+ * `oneOf`/`anyOf` branches — 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) {
+    if (schema.type)
+        return false;
+    return Boolean(schema.oneOf?.length || schema.anyOf?.length);
+}
+/**
+ * Classify a body by media type + schema shape and return the schema
+ * pre-converted to canonical form so each emitter can dispatch on
+ * `shape.kind` without re-converting.
+ */
+export function classifyBody(body) {
+    const mt = (body.mediaType ?? "").toLowerCase();
+    const schema = body.schema;
+    const isObject = schema.type === "object" && Boolean(schema.properties);
+    let shape;
+    if (mt && JSON_MEDIA_RE.test(mt)) {
+        shape = isOpaqueJsonBody(schema)
+            ? { kind: "json-opaque" }
+            : { kind: "json-typed" };
+    }
+    else if (mt.startsWith(MULTIPART_FORM_MEDIA) && isObject) {
+        shape = { kind: "multipart-object" };
+    }
+    else if (mt.startsWith(FORM_URLENCODED_MEDIA) && isObject) {
+        shape = { kind: "form-urlencoded-object" };
+    }
+    else {
+        shape = { kind: "opaque" };
+    }
+    return { shape, schema };
+}
+//# sourceMappingURL=body.js.map

package/dist/openapi/operation/body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.js","sourceRoot":"","sources":["../../../src/openapi/operation/body.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EACL,qBAAqB,EACrB,aAAa,EACb,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,IAAI,MAAM,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9B,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAC/D,CAAC;AAoBD;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,IAAa;IACxC,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,KAAgB,CAAC;IACrB,IAAI,EAAE,IAAI,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;QACjC,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC;YAC9B,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE;YACzB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;IAC7B,CAAC;SAAM,IAAI,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,IAAI,QAAQ,EAAE,CAAC;QAC3D,KAAK,GAAG,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;IACvC,CAAC;SAAM,IAAI,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC,IAAI,QAAQ,EAAE,CAAC;QAC5D,KAAK,GAAG,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC;IAC7C,CAAC;SAAM,CAAC;QACN,KAAK,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAC7B,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAC3B,CAAC"}

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

@@ -0,0 +1,19 @@
+import type { IR } from "../../ir/index.js";
+import { type HttpMethod } from "../spec/constants.js";
+export interface IteratedOperation {
+    pathStr: string;
+    method: HttpMethod;
+    op: IR.Operation;
+}
+/**
+ * Walk `IR.Paths` and yield one entry per `(path, method)` that
+ * carries an operation. Order is `Object.entries(paths)` → `HTTP_METHODS` —
+ * stable and matches the existing emit order.
+ */
+export declare function iterOperations(paths: IR.Paths | undefined): Generator<IteratedOperation>;
+/**
+ * Group every operation under its first tag (or `defaultTag`), mapped
+ * through `sign`. Tags keep first-seen order; operations keep walk order.
+ */
+export declare function groupOperationsByTag<S>(paths: IR.Paths | undefined, defaultTag: string, sign: (operation: IteratedOperation) => S): Map<string, S[]>;
+//# sourceMappingURL=iter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iter.d.ts","sourceRoot":"","sources":["../../../src/openapi/operation/iter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAErE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,EAAE,CAAC,SAAS,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAiB,cAAc,CAC7B,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,SAAS,GAC1B,SAAS,CAAC,iBAAiB,CAAC,CAY9B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,SAAS,EAC3B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,CAAC,GACxC,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAUlB"}

package/dist/openapi/operation/iter.js

@@ -0,0 +1,38 @@
+import { HTTP_METHODS } from "../spec/constants.js";
+/**
+ * Walk `IR.Paths` and yield one entry per `(path, method)` that
+ * carries an operation. Order is `Object.entries(paths)` → `HTTP_METHODS` —
+ * stable and matches the existing emit order.
+ */
+export function* iterOperations(paths) {
+    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,
+            };
+        }
+    }
+}
+/**
+ * Group every operation under its first tag (or `defaultTag`), mapped
+ * through `sign`. Tags keep first-seen order; operations keep walk order.
+ */
+export function groupOperationsByTag(paths, defaultTag, sign) {
+    const byTag = new Map();
+    for (const operation of iterOperations(paths)) {
+        const tag = operation.op.tags?.[0] ?? defaultTag;
+        const signed = sign(operation);
+        const list = byTag.get(tag);
+        if (list)
+            list.push(signed);
+        else
+            byTag.set(tag, [signed]);
+    }
+    return byTag;
+}
+//# sourceMappingURL=iter.js.map

package/dist/openapi/operation/iter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iter.js","sourceRoot":"","sources":["../../../src/openapi/operation/iter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAmB,MAAM,sBAAsB,CAAC;AAQrE;;;;GAIG;AACH,MAAM,SAAS,CAAC,CAAC,cAAc,CAC7B,KAA2B;IAE3B,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,CAA6B,CAAC;YACxD,IAAI,CAAC,EAAE;gBAAE,SAAS;YAClB,MAAM;gBACJ,OAAO;gBACP,MAAM,EAAE,MAAoB;gBAC5B,EAAE;aACH,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAA2B,EAC3B,UAAkB,EAClB,IAAyC;IAEzC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAe,CAAC;IACrC,KAAK,MAAM,SAAS,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC;QACjD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/B,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5B,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;;YACvB,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,27 @@
+import type { IR } from "../../ir/index.js";
+export type ParamLocation = "path" | "query" | "header" | "cookie";
+export declare const PARAM_LOCATIONS: ReadonlyArray<ParamLocation>;
+export interface LocatedParam {
+    param: IR.Parameter;
+    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.Operation): LocatedParam[];
+/**
+ * Extract just the `IR.Parameter`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.Parameter[];
+//# sourceMappingURL=params.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../../src/openapi/operation/params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAE5C,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,SAAS,CAAC;IACpB,GAAG,EAAE,aAAa,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,GAAG,YAAY,EAAE,CAQrE;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,GAAG,EAAE,aAAa,GACjB,EAAE,CAAC,SAAS,EAAE,CAEhB"}

package/dist/openapi/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.Parameter`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/openapi/operation/params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.js","sourceRoot":"","sources":["../../../src/openapi/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,EAAgB;IACnD,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/openapi/operation/responses.d.ts

@@ -0,0 +1,38 @@
+import type { IR } from "../../ir/index.js";
+import type { Schema } from "../../schema/index.js";
+export declare const isSuccessStatus: (code: string) => boolean;
+/**
+ * Operation's 2xx responses as `[code, response]` tuples, sorted by
+ * code for stable per-target emission order.
+ */
+export declare function successResponses(op: IR.Operation): Array<readonly [string, IR.Response]>;
+/**
+ * One arm of a multi-2xx sum-type return. Status code + payload
+ * schema (canonical, already converted from hey-api).
+ */
+export interface ResponseCase {
+    statusCode: string;
+    /** `undefined` for empty / meaningless responses (e.g. `204`). */
+    schema: Schema | undefined;
+}
+/**
+ * Shape of an operation's success return, normalised so each emitter
+ * can switch on `kind`. Schemas are canonical {@link Schema}.
+ */
+export type ReturnShape = 
+/** No 2xx responses, or a single 2xx with empty schema. */
+{
+    kind: "void";
+}
+/** Single 2xx with non-empty schema. */
+ | {
+    kind: "single";
+    schema: Schema;
+}
+/** Multiple 2xx — emitter renders a sum type. */
+ | {
+    kind: "multi";
+    cases: ReadonlyArray<ResponseCase>;
+};
+export declare function classifyReturnShape(op: IR.Operation): ReturnShape;
+//# sourceMappingURL=responses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../src/openapi/operation/responses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAIpD,eAAO,MAAM,eAAe,SAAU,MAAM,KAAG,OAA+B,CAAC;AAE/E;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,EAAE,CAAC,SAAS,GACf,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAMvC;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW;AACrB,2DAA2D;AACzD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB,wCAAwC;GACtC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACpC,iDAAiD;GAC/C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CAAE,CAAC;AAE1D,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,GAAG,WAAW,CAqBjE"}

package/dist/openapi/operation/responses.js

@@ -0,0 +1,38 @@
+import { isMeaningless } from "../spec/ref.js";
+export const isSuccessStatus = (code) => /^2\d\d$/.test(code);
+/**
+ * Operation's 2xx responses as `[code, response]` tuples, sorted by
+ * code for stable per-target emission order.
+ */
+export function successResponses(op) {
+    return Object.entries(op.responses ?? {})
+        .filter(([k]) => isSuccessStatus(k))
+        .sort(([a], [b]) => a.localeCompare(b));
+}
+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)
+            return { kind: "void" };
+        const schema = resp.schema;
+        if (isMeaningless(schema))
+            return { kind: "void" };
+        return { kind: "single", schema };
+    }
+    return {
+        kind: "multi",
+        cases: success.map(([statusCode, resp]) => {
+            if (!resp?.schema)
+                return { statusCode, schema: undefined };
+            const schema = resp.schema;
+            return {
+                statusCode,
+                schema: isMeaningless(schema) ? undefined : schema,
+            };
+        }),
+    };
+}
+//# sourceMappingURL=responses.js.map

package/dist/openapi/operation/responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.js","sourceRoot":"","sources":["../../../src/openapi/operation/responses.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAE/E;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,EAAgB;IAEhB,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;AAwBD,MAAM,UAAU,mBAAmB,CAAC,EAAgB;IAClD,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;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,aAAa,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QACnD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACpC,CAAC;IACD,OAAO;QACL,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE;YACxC,IAAI,CAAC,IAAI,EAAE,MAAM;gBAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;YAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;YAC3B,OAAO;gBACL,UAAU;gBACV,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM;aACnD,CAAC;QACJ,CAAC,CAAC;KACH,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,29 @@
+import type { IR } from "../../ir/index.js";
+import { type HttpMethod } from "../spec/constants.js";
+/**
+ * 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.Operation, 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/openapi/operation/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../src/openapi/operation/signature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,EAAE,CAAC,SAAS,EAChB,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/openapi/operation/signature.js

@@ -0,0 +1,41 @@
+import { HTTP_METHOD_LITERAL } from "../spec/constants.js";
+/**
+ * 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/openapi/operation/signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.js","sourceRoot":"","sources":["../../../src/openapi/operation/signature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAmB,MAAM,sBAAsB,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAC5B,EAAgB,EAChB,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"}

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

@@ -0,0 +1,30 @@
+import type { IR } from "../../ir/index.js";
+/**
+ * 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.Parameter | 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.Parameter>): TemplatePart[];
+//# sourceMappingURL=template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/openapi/operation/template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAE5C;;;;;;;;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,SAAS,GAAG,SAAS,CAAA;CAAE,CAAC;AAErE;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,aAAa,CAAC,EAAE,CAAC,SAAS,CAAC,GACtC,YAAY,EAAE,CAqBhB"}

package/dist/openapi/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/openapi/operation/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/openapi/operation/template.ts"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAW,EACX,UAAuC;IAEvC,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/openapi/spec/constants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * HTTP-method tuple iterated by every operation walker. Ordered to
+ * match the OpenAPI spec's canonical ordering so generated output is
+ * deterministic across runs and across generators.
+ */
+export declare const HTTP_METHODS: readonly ["get", "post", "put", "delete", "patch", "head", "options", "trace"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+/**
+ * Wire-format method literal expected by HTTP clients (`GET` not `get`).
+ */
+export declare const HTTP_METHOD_LITERAL: Record<HttpMethod, string>;
+/**
+ * Match `application/json` and any RFC 6839 structured-syntax suffix
+ * variant (e.g. `application/vnd.api+json`). Tolerant of trailing
+ * `;charset=...` parameters.
+ */
+export declare const JSON_MEDIA_RE: RegExp;
+export declare const FORM_URLENCODED_MEDIA = "application/x-www-form-urlencoded";
+export declare const MULTIPART_FORM_MEDIA = "multipart/form-data";
+//# sourceMappingURL=constants.d.ts.map

package/dist/openapi/spec/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/openapi/spec/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,YAAY,YACvB,KAAK,EACL,MAAM,EACN,KAAK,EACL,QAAQ,EACR,OAAO,EACP,MAAM,EACN,SAAS,EACT,OAAO,CACC,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAS1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAAqD,CAAC;AAEhF,eAAO,MAAM,qBAAqB,sCAAsC,CAAC;AACzE,eAAO,MAAM,oBAAoB,wBAAwB,CAAC"}

package/dist/openapi/spec/constants.js

@@ -0,0 +1,37 @@
+/**
+ * HTTP-method tuple iterated by every operation walker. Ordered to
+ * match the OpenAPI spec's canonical ordering so generated output is
+ * deterministic across runs and across generators.
+ */
+export const HTTP_METHODS = [
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "head",
+    "options",
+    "trace",
+];
+/**
+ * Wire-format method literal expected by HTTP clients (`GET` not `get`).
+ */
+export const HTTP_METHOD_LITERAL = {
+    get: "GET",
+    post: "POST",
+    put: "PUT",
+    delete: "DELETE",
+    patch: "PATCH",
+    head: "HEAD",
+    options: "OPTIONS",
+    trace: "TRACE",
+};
+/**
+ * Match `application/json` and any RFC 6839 structured-syntax suffix
+ * variant (e.g. `application/vnd.api+json`). Tolerant of trailing
+ * `;charset=...` parameters.
+ */
+export const JSON_MEDIA_RE = /^application\/(?:json|[\w.+-]+\+json)(?:\s*;|$)/i;
+export const FORM_URLENCODED_MEDIA = "application/x-www-form-urlencoded";
+export const MULTIPART_FORM_MEDIA = "multipart/form-data";
+//# sourceMappingURL=constants.js.map

package/dist/openapi/spec/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/openapi/spec/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,KAAK;IACL,MAAM;IACN,KAAK;IACL,QAAQ;IACR,OAAO;IACP,MAAM;IACN,SAAS;IACT,OAAO;CACC,CAAC;AAIX;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAA+B;IAC7D,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;CACf,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,kDAAkD,CAAC;AAEhF,MAAM,CAAC,MAAM,qBAAqB,GAAG,mCAAmC,CAAC;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,qBAAqB,CAAC"}

package/dist/openapi/spec/normalize/allOf.d.ts

@@ -0,0 +1,3 @@
+/** Collapse `{ allOf: [X] }` (single-element) into the parent. */
+export declare function collapseSingleAllOf(spec: unknown): void;
+//# sourceMappingURL=allOf.d.ts.map

package/dist/openapi/spec/normalize/allOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allOf.d.ts","sourceRoot":"","sources":["../../../../src/openapi/spec/normalize/allOf.ts"],"names":[],"mappings":"AAEA,kEAAkE;AAClE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAcvD"}

package/dist/openapi/spec/normalize/allOf.js

@@ -0,0 +1,42 @@
+import { walkSchemas } from "./walk.js";
+/** Collapse `{ allOf: [X] }` (single-element) into the parent. */
+export function collapseSingleAllOf(spec) {
+    walkSchemas(spec, ({ node }) => {
+        if (!node || typeof node !== "object")
+            return;
+        const value = node;
+        const allOf = value.allOf;
+        if (!Array.isArray(allOf) || allOf.length !== 1)
+            return;
+        const sole = allOf[0];
+        if (!sole || typeof sole !== "object")
+            return;
+        if (hasMeaningfulSiblings(value))
+            return;
+        delete value.allOf;
+        Object.assign(value, sole);
+    });
+}
+function hasMeaningfulSiblings(value) {
+    for (const key of Object.keys(value)) {
+        if (key === "allOf")
+            continue;
+        if (PRESENTATIONAL.has(key))
+            continue;
+        if (key.startsWith("x-"))
+            continue;
+        return true;
+    }
+    return false;
+}
+const PRESENTATIONAL = new Set([
+    "description",
+    "title",
+    "deprecated",
+    "example",
+    "examples",
+    "externalDocs",
+    "readOnly",
+    "writeOnly",
+]);
+//# sourceMappingURL=allOf.js.map

package/dist/openapi/spec/normalize/allOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allOf.js","sourceRoot":"","sources":["../../../../src/openapi/spec/normalize/allOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,kEAAkE;AAClE,MAAM,UAAU,mBAAmB,CAAC,IAAa;IAC/C,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;QAC7B,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO;QAC9C,MAAM,KAAK,GAAG,IAA+B,CAAC;QAC9C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAExD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO;QAC9C,IAAI,qBAAqB,CAAC,KAAK,CAAC;YAAE,OAAO;QAEzC,OAAO,KAAK,CAAC,KAAK,CAAC;QACnB,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,qBAAqB,CAAC,KAA8B;IAC3D,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,GAAG,KAAK,OAAO;YAAE,SAAS;QAC9B,IAAI,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QACtC,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,SAAS;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC;IAClD,aAAa;IACb,OAAO;IACP,YAAY;IACZ,SAAS;IACT,UAAU;IACV,cAAc;IACd,UAAU;IACV,WAAW;CACZ,CAAC,CAAC"}

package/dist/openapi/spec/normalize/enums.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Algorithm adapted from @hey-api/openapi-ts (MIT) —
+ * `packages/shared/src/openApi/shared/transforms/enums.ts` `rootMode`.
+ * Deviations: signature includes `format`; only the `'root'` direction
+ * is supported; metadata is reconciled across hits (see `metadata.ts`).
+ */
+import type { NamingConfig } from "./name.js";
+export interface EnumPassOptions {
+    naming?: NamingConfig;
+}
+/**
+ * Hoist identical inline enums to `components.schemas` and rewrite each
+ * occurrence as a `$ref`. Returns the set of newly-added schema names.
+ */
+export declare function dedupeInlineEnums(spec: unknown, opts?: EnumPassOptions): Set<string>;
+//# sourceMappingURL=enums.d.ts.map

package/dist/openapi/spec/normalize/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../../src/openapi/spec/normalize/enums.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAS9C,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAOD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,EACb,IAAI,GAAE,eAAoB,GACzB,GAAG,CAAC,MAAM,CAAC,CA2Db"}