osury 0.29.0 → 1.0.1

package/README.md

@@ -6,23 +6,33 @@ Generate ReScript types with [Sury](https://github.com/DZakh/sury) schemas from
 
 Huge thanks to the [ReScript](https://rescript-lang.org/) team for an amazing language, and special thanks to [@DZakh](https://github.com/DZakh) for the incredible [Sury](https://github.com/DZakh/sury) library that made this project possible.
 
-## Early Stage Warning
+## Project Status
 
-This project is in a very early stage of development and is tailored to my specific needs. It comes with **no guarantees** of stability, correctness, or completeness.
-
-**Suggestions and contributions are very welcome!** Feel free to open issues or submit PRs.
+Now at **v1.0.0**. The codegen is in production use against real-world OpenAPI specs
+(both Pydantic/FastAPI and Django/DRF generated). The pipeline is feature-complete
+for the OpenAPI 3.x patterns most code-first generators emit; edge cases beyond that
+are added on demand. Issues and PRs welcome.
 
 ## Features
 
-- OpenAPI 3.x → ReScript types
-- `@schema` annotations for Sury PPX validation
-- `@genType` for TypeScript interop
-- Union types extracted as proper variants with `@tag("_tag")`
-- Automatic deduplication of identical union structures
-- Generates `module S = Sury` alias (required by sury-ppx)
-- Generates helper shims for TypeScript interop (`Dict.gen.ts`, `Nullable.shim.ts`)
-- Proper JSON `null` support via `Nullable.t<T>` (maps to `T | null` in TypeScript)
-- Path response types generation from `paths.*.responses`
+- **OpenAPI 3.x → ReScript types** with full discriminated-union support
+- **`@schema`** annotations for Sury PPX runtime validation
+- **`@genType`** for TypeScript interop with type-safe literal unions
+- **Discriminated unions** via `discriminator.mapping` (OpenAPI-standard, primary)
+  with fallback to `_tag.const` (Effect-style convention)
+- **Custom discriminator property names** via `discriminator.propertyName`
+  (`@tag("type")`, `@tag("kind")`, etc., not just `_tag`)
+- **Inline enum auto-promotion** to named top-level types with field-based naming
+  and structural deduplication
+- **Path operation types** — both `Response` types from `responses[200]` and `Params`
+  types from query/path `parameters[]`
+- **JSON `null` support** via `Nullable.t<T>` (maps to `T | null` in TypeScript,
+  distinct from `option<T>` for `undefined`)
+- **Untyped/Unknown handling** via `JSON.t` with `@s.matches(S.json)` so untyped
+  fields don't poison `@schema` propagation through enclosing types
+- **Automatic deduplication** of identical union/enum structures
+- **TypeScript shims** generated alongside (`Dict.gen.ts`, `JSON.gen.ts`,
+  `Nullable.res`, `Nullable.shim.ts`)
 
 ## Installation
 
@@ -40,10 +50,14 @@ npx osury openapi.json
 
 # Generate to specific directory
 npx osury openapi.json src/API.res
-# Creates: src/API.res, src/Dict.gen.ts, src/Nullable.res, src/Nullable.shim.ts
+# Creates: src/API.res, src/Dict.gen.ts, src/JSON.gen.ts,
+#         src/Nullable.res, src/Nullable.shim.ts
 
 # With explicit output flag
 npx osury generate openapi.json -o src/Schema.res
+
+# Show help
+npx osury --help
 ```
 
 ### Full Example: OpenAPI → ReScript → TypeScript
@@ -179,14 +193,19 @@ Open [http://localhost:4173/demo/](http://localhost:4173/demo/).
 
 ### Helper Files
 
-Also generates helper files:
+Generated alongside the main `Schema.res`:
 
 **Dict.gen.ts** — TypeScript shim for dictionaries:
 ```typescript
 export type t<T> = { [key: string]: T };
 ```
 
-**Nullable.res** — ReScript nullable type:
+**JSON.gen.ts** — TypeScript shim for untyped/Unknown fields:
+```typescript
+export type t = unknown;
+```
+
+**Nullable.res** — ReScript nullable type (`option<T>` with `T | null` TS mapping):
 ```rescript
 @genType.import(("./Nullable.shim.ts", "t"))
 type t<'a> = option<'a>
@@ -203,8 +222,9 @@ export type t<T> = T | null;
 |------------|---------|
 | `@genType` | TypeScript type generation |
 | `@schema` | Sury PPX validation schema |
-| `@tag("_tag")` | Discriminated union support (Effect TS compatible) |
-| `@s.null` | Field-level JSON `null` support |
+| `@tag("_tag")` | Discriminated union tag — default Effect TS convention; overridable via `discriminator.propertyName` (e.g. `@tag("type")`) |
+| `@s.null` | Field-level JSON `null` support (for `Nullable.t<T>` fields) |
+| `@s.matches(S.json)` | Per-field synthesizer for `JSON.t` so untyped fields don't poison enclosing `@schema` |
 | `@unboxed` | Primitive-only union optimization |
 | `@as("name")` | Reserved keyword field mapping |
 
@@ -227,20 +247,71 @@ For the generated code to compile, your project needs:
 | `boolean` | `bool` |
 | `null` | `unit` |
 | `array` | `array<T>` |
-| `object` | `{ field: T }` |
+| `object` | record `{ field: T }` |
 | `$ref` | type reference |
-| `enum` | poly variant `[#A \| #B]` |
-| `const` | single-value enum (for `_tag`) |
-| `anyOf` (nullable) | `Nullable.t<T>` → `T \| null` in TS |
-| `anyOf` (union) | variant type with `@tag("_tag")` |
-| `oneOf` (discriminated) | poly variant with `_tag.const` extraction |
+| `enum` (inline) | extracted to named `type sortDirection = [#asc \| #desc]` |
+| `enum` (top-level) | poly variant `[#A \| #B]` |
+| `const` (single string) | one-element enum (used for discriminator tags) |
+| schema with no `type` | `JSON.t` (TS: `unknown`) with `@s.matches(S.json)` |
+| `anyOf: [T, null]` | `Nullable.t<T>` (TS: `T \| null`) |
+| `anyOf: [A, B, ...]` (no discriminator) | extracted variant type with structural name |
+| `oneOf` + `discriminator` | poly variant with tags from `discriminator.mapping` |
 | `allOf` | merged object type |
 | `additionalProperties` | `Dict.t<T>` |
 | `default` value | field becomes required |
+| `parameters[]` (query + path) | synthetic `<method><Path>Params` record |
+| `responses[200].schema` | `<method><Path>Response` type |
+
+## Discriminated Unions
+
+osury resolves variant case tags through a three-level priority chain, so the
+ReScript-side tag always matches the **wire-format truth**, never the class name
+on the backend:
+
+1. **`discriminator.mapping`** — OpenAPI 3.x standard, primary source. Works with
+   any property name (`_tag`, `tag`, `type`, `kind`, …).
+2. **`_tag.const`** — fallback when no explicit mapping is declared (Effect-style
+   implicit convention).
+3. **Ref name** — last-resort default for `$ref` items with no const information.
+
+The practical effect: **class names on the backend can diverge from wire-format
+discriminator values without breaking osury**. Pydantic's natural style
+(`class MetricGridBlock` ↔ `_tag: "MetricGrid"`) works out of the box as long as
+the discriminator mapping is declared in the schema.
+
+```yaml
+Block:
+  oneOf:
+    - { $ref: "#/components/schemas/MetricGridBlock" }
+    - { $ref: "#/components/schemas/ProseBlock" }
+  discriminator:
+    propertyName: _tag
+    mapping:
+      MetricGrid: "#/components/schemas/MetricGridBlock"
+      Prose:      "#/components/schemas/ProseBlock"
+```
+
+Generates:
+
+```rescript
+@genType @tag("_tag") @schema
+type block = MetricGrid({
+  metrics: array<string>
+}) | Prose({
+  text: string
+})
+```
+
+Note the case names (`MetricGrid`, `Prose`) come from the **mapping keys**, not
+from the schema class names (`MetricGridBlock`, `ProseBlock`). Case payloads
+are inlined records — fields are copied from the referenced schema and the
+discriminator property is filtered out to avoid duplication with `@tag`.
 
-## Path Responses
+## Path Types
 
-Types are also generated from path responses:
+Types are generated from both `responses` and `parameters` of each path operation.
+
+### Response types
 
 ```json
 {
@@ -264,6 +335,45 @@ Types are also generated from path responses:
 
 Generates: `type getUsersResponse = userList`
 
+### Params types
+
+Query and path parameters are folded into a synthetic object schema and pushed
+through the same parsing pipeline (so all rules — `default → required`,
+`anyOf [T, null] → Nullable.t<T>`, inline enum → named type — apply uniformly).
+
+```json
+{
+  "paths": {
+    "/products": {
+      "get": {
+        "parameters": [
+          { "in": "query", "name": "sort_field",
+            "schema": { "type": "string", "enum": ["sales", "clicks", "impressions"] } },
+          { "in": "query", "name": "limit",
+            "schema": { "type": "integer", "default": 50 } }
+        ]
+      }
+    }
+  }
+}
+```
+
+Generates:
+
+```rescript
+@genType @schema
+type sortField = [#sales | #clicks | #impressions]  // promoted from inline enum
+
+@genType @schema
+type getProductsParams = {
+  sort_field: option<sortField>,
+  limit: int,  // has default → required
+}
+```
+
+Headers and serialization details (`style`/`explode`) are intentionally excluded —
+they belong to the HTTP client layer, not the schema contract.
+
 ## License
 
 MIT

package/package.json

@@ -2,7 +2,7 @@
   "name": "osury",
   "type": "module",
   "description": "Generate ReScript types with Sury schemas from OpenAPI specifications",
-  "version": "0.29.0",
+  "version": "1.0.1",
   "license": "MIT",
   "bin": {
     "osury": "bin/osury.mjs"

package/src/BackendReScript.res.mjs

@@ -4,7 +4,7 @@ import * as Core__Array from "@rescript/core/src/Core__Array.res.mjs";
 import * as Core__Option from "@rescript/core/src/Core__Option.res.mjs";
 
 function quoteTag(tag) {
-  let needsQuoting = tag.split("").some(c => {
+  let needsQuoting = tag === "" || tag.split("").some(c => {
     let code = c.charCodeAt(0);
     return !(code >= 97.0 && code <= 122.0 || code >= 65.0 && code <= 90.0 || code >= 48.0 && code <= 57.0 || code === 95.0);
   });

package/src/Codegen.res.mjs

@@ -60,6 +60,16 @@ let hasUnion = CodegenHelpers.hasUnion;
 
 let isPrimitiveOnlyUnion = CodegenHelpers.isPrimitiveOnlyUnion;
 
+let collectInlineEnums = CodegenTransforms.collectInlineEnums;
+
+let resolveEnumNames = CodegenTransforms.resolveEnumNames;
+
+let camelize = CodegenTransforms.camelize;
+
+let replaceInlineEnums = CodegenTransforms.replaceInlineEnums;
+
+let buildExtractedEnumSchemas = CodegenTransforms.buildExtractedEnumSchemas;
+
 let isRefPlusDictUnion = CodegenTransforms.isRefPlusDictUnion;
 
 let isPrimitivePlusDictUnion = CodegenTransforms.isPrimitivePlusDictUnion;
@@ -116,6 +126,11 @@ export {
   getTagForType,
   hasUnion,
   isPrimitiveOnlyUnion,
+  collectInlineEnums,
+  resolveEnumNames,
+  camelize,
+  replaceInlineEnums,
+  buildExtractedEnumSchemas,
   isRefPlusDictUnion,
   isPrimitivePlusDictUnion,
   getUnionName,

package/src/CodegenTransforms.res.mjs

@@ -4,6 +4,246 @@ import * as Errors from "./Errors.res.mjs";
 import * as Core__Array from "@rescript/core/src/Core__Array.res.mjs";
 import * as Core__Option from "@rescript/core/src/Core__Option.res.mjs";
 import * as CodegenHelpers from "./CodegenHelpers.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function collectEnumsFromType(parentType, fieldPath, _schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return [];
+    }
+    switch (schema._tag) {
+      case "Object" :
+        return schema._0.flatMap(f => collectEnumsFromType(parentType, fieldPath.concat([f.name]), f.type));
+      case "Enum" :
+        if (fieldPath.length > 0) {
+          return [{
+              parentType: parentType,
+              fieldPath: fieldPath,
+              values: schema._0
+            }];
+        } else {
+          return [];
+        }
+      case "PolyVariant" :
+        return schema._0.flatMap(c => collectEnumsFromType(parentType, fieldPath, c.payload));
+      case "Optional" :
+      case "Nullable" :
+      case "Array" :
+      case "Dict" :
+        break;
+      case "Union" :
+        return schema._0.flatMap(t => collectEnumsFromType(parentType, fieldPath, t));
+      default:
+        return [];
+    }
+    _schema = schema._0;
+    continue;
+  };
+}
+
+function collectInlineEnums(schemas) {
+  return schemas.flatMap(s => {
+    let match = s.schema;
+    if (typeof match !== "object") {
+      return collectEnumsFromType(s.name, [], s.schema);
+    } else if (match._tag === "Enum") {
+      return [];
+    } else {
+      return collectEnumsFromType(s.name, [], s.schema);
+    }
+  });
+}
+
+function camelize(s) {
+  let parts = s.replace(/-/g, "_").split("_").filter(p => p !== "");
+  let first = parts[0];
+  if (first === undefined) {
+    return s;
+  }
+  let rest = parts.slice(1);
+  return CodegenHelpers.lcFirst(first) + rest.map(CodegenHelpers.ucFirst).join("");
+}
+
+function occurrenceKey(occ) {
+  return occ.parentType + "::" + occ.fieldPath.join("/");
+}
+
+function valuesCanonicalKey(values) {
+  let cmp = (a, b) => {
+    if (Primitive_object.lessthan(a, b)) {
+      return -1.0;
+    } else if (Primitive_object.greaterthan(a, b)) {
+      return 1.0;
+    } else {
+      return 0.0;
+    }
+  };
+  return values.toSorted(cmp).join("");
+}
+
+function leafFieldName(occ) {
+  let s = occ.fieldPath[occ.fieldPath.length - 1 | 0];
+  if (s !== undefined) {
+    return s;
+  } else {
+    return "unknown";
+  }
+}
+
+function replaceEnumsInType(parentType, fieldPath, names, schema) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional" :
+      return {
+        _tag: "Optional",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Nullable" :
+      return {
+        _tag: "Nullable",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Object" :
+      return {
+        _tag: "Object",
+        _0: schema._0.map(f => {
+          let newType = replaceEnumsInType(parentType, fieldPath.concat([f.name]), names, f.type);
+          return {
+            name: f.name,
+            type: newType,
+            required: f.required
+          };
+        })
+      };
+    case "Array" :
+      return {
+        _tag: "Array",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Enum" :
+      if (fieldPath.length <= 0) {
+        return schema;
+      }
+      let key = parentType + "::" + fieldPath.join("/");
+      let name = names[key];
+      if (name !== undefined) {
+        return {
+          _tag: "Ref",
+          _0: CodegenHelpers.ucFirst(name)
+        };
+      } else {
+        return schema;
+      }
+    case "PolyVariant" :
+      return {
+        _tag: "PolyVariant",
+        _0: schema._0.map(c => {
+          let payload = replaceEnumsInType(parentType, fieldPath, names, c.payload);
+          return {
+            _tag: c._tag,
+            payload: payload
+          };
+        })
+      };
+    case "Dict" :
+      return {
+        _tag: "Dict",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Union" :
+      return {
+        _tag: "Union",
+        _0: schema._0.map(t => replaceEnumsInType(parentType, fieldPath, names, t))
+      };
+    default:
+      return schema;
+  }
+}
+
+function replaceInlineEnums(schemas, names) {
+  return schemas.map(s => {
+    let match = s.schema;
+    let newSchema;
+    let exit = 0;
+    if (typeof match !== "object" || match._tag !== "Enum") {
+      exit = 1;
+    } else {
+      newSchema = s.schema;
+    }
+    if (exit === 1) {
+      newSchema = replaceEnumsInType(s.name, [], names, s.schema);
+    }
+    return {
+      name: s.name,
+      schema: newSchema,
+      discriminatorTag: s.discriminatorTag,
+      discriminatorPropertyName: s.discriminatorPropertyName,
+      fieldDiscriminators: s.fieldDiscriminators
+    };
+  });
+}
+
+function buildExtractedEnumSchemas(occurrences, names) {
+  let seen = {};
+  let result = [];
+  occurrences.forEach(occ => {
+    let key = occurrenceKey(occ);
+    let name = names[key];
+    if (name === undefined) {
+      return;
+    }
+    let typeName = CodegenHelpers.ucFirst(name);
+    if (Core__Option.isNone(seen[typeName])) {
+      seen[typeName] = true;
+      result.push({
+        name: typeName,
+        schema: {
+          _tag: "Enum",
+          _0: occ.values
+        },
+        discriminatorTag: undefined,
+        discriminatorPropertyName: undefined,
+        fieldDiscriminators: undefined
+      });
+      return;
+    }
+  });
+  return result;
+}
+
+function resolveEnumNames(occurrences, topLevelNames) {
+  let topLevelSet = {};
+  topLevelNames.forEach(n => {
+    topLevelSet[CodegenHelpers.lcFirst(n)] = true;
+  });
+  let buckets = {};
+  occurrences.forEach(occ => {
+    let leaf = leafFieldName(occ);
+    let vKey = valuesCanonicalKey(occ.values);
+    let set = buckets[leaf];
+    if (set !== undefined) {
+      set[vKey] = true;
+      return;
+    }
+    let set$1 = {};
+    set$1[vKey] = true;
+    buckets[leaf] = set$1;
+  });
+  let result = {};
+  occurrences.forEach(occ => {
+    let leaf = leafFieldName(occ);
+    let camelized = camelize(leaf);
+    let distinctSets = Core__Option.mapOr(buckets[leaf], 1, set => Object.keys(set).length);
+    let collidesTopLevel = Core__Option.isSome(topLevelSet[camelized]);
+    let baseName = distinctSets > 1 || collidesTopLevel ? CodegenHelpers.lcFirst(occ.parentType) + CodegenHelpers.ucFirst(camelized) : camelized;
+    let name = CodegenHelpers.isReservedKeyword(baseName) ? baseName + "_" : baseName;
+    result[occurrenceKey(occ)] = name;
+  });
+  return result;
+}
 
 function isRefPlusDictUnion(types) {
   if (types.length !== 2) {
@@ -527,6 +767,16 @@ function validateUnionDiscriminators(schemas) {
 }
 
 export {
+  collectEnumsFromType,
+  collectInlineEnums,
+  camelize,
+  occurrenceKey,
+  valuesCanonicalKey,
+  leafFieldName,
+  replaceEnumsInType,
+  replaceInlineEnums,
+  buildExtractedEnumSchemas,
+  resolveEnumNames,
   isRefPlusDictUnion,
   isPrimitivePlusDictUnion,
   getUnionName,

package/src/IRGen.res.mjs

@@ -301,7 +301,13 @@ function generate(schemas) {
     };
   }
   let warnings = CodegenTransforms.collectUnionWarnings(schemas);
-  let extractedUnions = schemas.flatMap(s => CodegenTransforms.extractUnions(s.name, s.schema).map(extracted => {
+  let enumOccurrences = CodegenTransforms.collectInlineEnums(schemas);
+  let topLevelNames = schemas.map(s => s.name);
+  let enumNames = CodegenTransforms.resolveEnumNames(enumOccurrences, topLevelNames);
+  let enumSchemas = CodegenTransforms.buildExtractedEnumSchemas(enumOccurrences, enumNames);
+  let schemasAfterEnumPromotion = CodegenTransforms.replaceInlineEnums(schemas, enumNames);
+  let schemas$1 = enumSchemas.concat(schemasAfterEnumPromotion);
+  let extractedUnions = schemas$1.flatMap(s => CodegenTransforms.extractUnions(s.name, s.schema).map(extracted => {
     let dict = s.fieldDiscriminators;
     let discriminatorPropertyName = dict !== undefined ? dict[extracted.name] : undefined;
     return {
@@ -321,7 +327,7 @@ function generate(schemas) {
       return true;
     }
   });
-  let modifiedSchemas = schemas.map(s => ({
+  let modifiedSchemas = schemas$1.map(s => ({
     name: s.name,
     schema: CodegenTransforms.replaceUnions(s.name, s.schema),
     discriminatorTag: s.discriminatorTag,

package/src/OpenAPIParser.res.mjs

@@ -516,6 +516,138 @@ function parsePathParameters(pathsJson) {
   };
 }
 
+function extractAllDiscriminatorMappings(json) {
+  let result = {};
+  let walk = j => {
+    if (Array.isArray(j)) {
+      j.forEach(walk);
+      return;
+    }
+    switch (typeof j) {
+      case "object" :
+        let match = j["oneOf"];
+        let match$1 = j["discriminator"];
+        if (Array.isArray(match) && typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
+          let match$2 = match$1["mapping"];
+          if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
+            Object.entries(match$2).forEach(param => {
+              let refValue = param[1];
+              if (typeof refValue !== "string") {
+                return;
+              }
+              let parts = refValue.split("/");
+              let schemaName = parts[parts.length - 1 | 0];
+              if (schemaName !== undefined) {
+                result[schemaName] = param[0];
+                return;
+              }
+            });
+          }
+        }
+        Object.entries(j).forEach(param => walk(param[1]));
+        return;
+      default:
+        return;
+    }
+  };
+  walk(json);
+  return result;
+}
+
+function rewriteVariantTagsInType(schema, tagByRef) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional" :
+      return {
+        _tag: "Optional",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Nullable" :
+      return {
+        _tag: "Nullable",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Object" :
+      return {
+        _tag: "Object",
+        _0: schema._0.map(f => ({
+          name: f.name,
+          type: rewriteVariantTagsInType(f.type, tagByRef),
+          required: f.required
+        }))
+      };
+    case "Array" :
+      return {
+        _tag: "Array",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "PolyVariant" :
+      let newCases = schema._0.map(c => {
+        let refName = c.payload;
+        if (typeof refName !== "object") {
+          return {
+            _tag: c._tag,
+            payload: rewriteVariantTagsInType(refName, tagByRef)
+          };
+        }
+        if (refName._tag !== "Ref") {
+          return {
+            _tag: c._tag,
+            payload: rewriteVariantTagsInType(refName, tagByRef)
+          };
+        }
+        let actualTag = tagByRef[refName._0];
+        if (actualTag !== undefined && actualTag !== c._tag) {
+          return {
+            _tag: actualTag,
+            payload: c.payload
+          };
+        } else {
+          return c;
+        }
+      });
+      return {
+        _tag: "PolyVariant",
+        _0: newCases
+      };
+    case "Dict" :
+      return {
+        _tag: "Dict",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Union" :
+      return {
+        _tag: "Union",
+        _0: schema._0.map(t => rewriteVariantTagsInType(t, tagByRef))
+      };
+    default:
+      return schema;
+  }
+}
+
+function resolveRefTagsInPolyVariants(schemas, mappingByRef) {
+  let tagByRef = {};
+  schemas.forEach(s => {
+    let tag = s.discriminatorTag;
+    if (tag !== undefined) {
+      tagByRef[s.name] = tag;
+      return;
+    }
+  });
+  Object.entries(mappingByRef).forEach(param => {
+    tagByRef[param[0]] = param[1];
+  });
+  return schemas.map(s => ({
+    name: s.name,
+    schema: rewriteVariantTagsInType(s.schema, tagByRef),
+    discriminatorTag: s.discriminatorTag,
+    discriminatorPropertyName: s.discriminatorPropertyName,
+    fieldDiscriminators: s.fieldDiscriminators
+  }));
+}
+
 function parseDocument(json) {
   if (typeof json === "object" && json !== null && !Array.isArray(json)) {
     let componentsJson = json["components"];
@@ -533,12 +665,13 @@ function parseDocument(json) {
         TAG: "Ok",
         _0: []
       });
+    let mappingByRef = extractAllDiscriminatorMappings(json);
     let exit = 0;
     if (componentSchemas.TAG === "Ok" && pathSchemas.TAG === "Ok") {
       if (paramSchemas.TAG === "Ok") {
         return {
           TAG: "Ok",
-          _0: componentSchemas._0.concat(pathSchemas._0).concat(paramSchemas._0)
+          _0: resolveRefTagsInPolyVariants(componentSchemas._0.concat(pathSchemas._0).concat(paramSchemas._0), mappingByRef)
         };
       }
       exit = 2;
@@ -583,6 +716,9 @@ export {
   parseComponentSchemas,
   buildParamsObjectJson,
   parsePathParameters,
+  extractAllDiscriminatorMappings,
+  rewriteVariantTagsInType,
+  resolveRefTagsInPolyVariants,
   parseDocument,
 }
 /* No side effect */