@f3liz/rescript-autogen-openapi 0.1.6 → 0.1.7

package/README.md

@@ -9,12 +9,25 @@ Generate ReScript code with [Sury](https://github.com/DZakh/rescript-schema) sch
 *   **Multi-Fork Support**: Intelligently handles multiple API forks (like Misskey, Cherrypick, Firefish) by extracting shared code and generating fork-specific extensions.
 *   **Unified IR Pipeline**: Advanced type inference with a unified intermediate representation that generates both types and schemas.
 *   **Diff & Merge**: Compare specs, generate diff reports, and optimize code reuse across variants.
-*   **TypeScript Support**: Generates `.d.ts` files and TypeScript wrappers for idiomatic use in JS/TS projects.
+*   **TypeScript Support**: First-class TypeScript support via `genType`. Exported functions and types are idiomatic and fully typed for use in TypeScript projects.
 
 ## 📦 Installation
 
 ```bash
-npm install @f3liz/rescript-autogen-openapi sury @readme/openapi-parser
+npm install @f3liz/rescript-autogen-openapi sury
+```
+
+**Important**: This library has a peer dependency on `sury` (ReScript Schema). You must install it in your project because the generated code directly depends on it for runtime validation.
+
+### Configure `rescript.json`
+
+Add `sury` to your project dependencies:
+
+```json
+{
+  "name": "my-project",
+  "dependencies": ["sury"]
+}
 ```
 
 Ensure you have `rescript` (^12.0.0) installed.

package/lib/es6/src/Codegen.d.ts

@@ -0,0 +1,28 @@
+import type { codegenError as Types_codegenError } from './Types';
+import type { forkSpec as Types_forkSpec } from './Types';
+import type { generationConfig as Types_generationConfig } from './Types';
+import type { generationResult as Types_generationResult } from './Types';
+import type { openAPISpec as Types_openAPISpec } from './Types';
+import type { specDiff as Types_specDiff } from './Types';
+import type { t as Pipeline_t } from './core/Pipeline';
+export declare const generateSingleSpecPure: (spec: Types_openAPISpec, config: Types_generationConfig) => {
+    TAG: "Ok";
+    _0: Pipeline_t;
+} | {
+    TAG: "Error";
+    _0: Types_codegenError;
+};
+export declare const generateSingleSpec: (spec: Types_openAPISpec, config: Types_generationConfig) => Promise<Types_generationResult>;
+export declare const generateMultiSpecPure: (baseSpec: Types_openAPISpec, forkSpecs: Types_forkSpec[], config: Types_generationConfig) => {
+    TAG: "Ok";
+    _0: Pipeline_t;
+} | {
+    TAG: "Error";
+    _0: Types_codegenError;
+};
+export declare const generateMultiSpec: (baseSpec: Types_openAPISpec, forkSpecs: Types_forkSpec[], config: Types_generationConfig) => Promise<Types_generationResult>;
+export declare const compareSpecs: (baseSpec: Types_openAPISpec, forkSpec: Types_openAPISpec, baseName: (undefined | string), forkName: (undefined | string), outputPath: (undefined | string)) => Promise<Types_specDiff>;
+export declare const generate: (config: Types_generationConfig) => Promise<Types_generationResult>;
+export declare const createDefaultConfig: (url: string, outputDir: string) => Types_generationConfig;
+export declare const generateFromUrl: (url: string, outputDir: string, config: (undefined | Types_generationConfig)) => Promise<Types_generationResult>;
+export declare const generateFromFile: (filePath: string, outputDir: string, config: (undefined | Types_generationConfig)) => Promise<Types_generationResult>;

package/lib/es6/src/Types.d.ts

@@ -0,0 +1,286 @@
+import type { t as Config_t } from './types/Config';
+export type jsonSchemaType = "String" | "Number" | "Integer" | "Boolean" | "Object" | "Null" | "Unknown" | {
+    TAG: "Array";
+    _0: jsonSchemaType;
+};
+export type jsonSchema = {
+    readonly type: (undefined | jsonSchemaType);
+    readonly properties: (undefined | {
+        [id: string]: jsonSchema;
+    });
+    readonly items: (undefined | jsonSchema);
+    readonly required: (undefined | string[]);
+    readonly enum: (undefined | unknown[]);
+    readonly "$ref": (undefined | string);
+    readonly allOf: (undefined | jsonSchema[]);
+    readonly oneOf: (undefined | jsonSchema[]);
+    readonly anyOf: (undefined | jsonSchema[]);
+    readonly description: (undefined | string);
+    readonly format: (undefined | string);
+    readonly minLength: (undefined | number);
+    readonly maxLength: (undefined | number);
+    readonly minimum: (undefined | number);
+    readonly maximum: (undefined | number);
+    readonly pattern: (undefined | string);
+    readonly nullable: (undefined | boolean);
+};
+export type httpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+export type mediaType = {
+    readonly schema: (undefined | jsonSchema);
+    readonly example: (undefined | unknown);
+    readonly examples: (undefined | {
+        [id: string]: unknown;
+    });
+};
+export type requestBody = {
+    readonly description: (undefined | string);
+    readonly content: {
+        [id: string]: mediaType;
+    };
+    readonly required: (undefined | boolean);
+};
+export type response = {
+    readonly description: string;
+    readonly content: (undefined | {
+        [id: string]: mediaType;
+    });
+};
+export type parameter = {
+    readonly name: string;
+    readonly in: string;
+    readonly description: (undefined | string);
+    readonly required: (undefined | boolean);
+    readonly schema: (undefined | jsonSchema);
+};
+export type operation = {
+    readonly operationId: (undefined | string);
+    readonly summary: (undefined | string);
+    readonly description: (undefined | string);
+    readonly tags: (undefined | string[]);
+    readonly requestBody: (undefined | requestBody);
+    readonly responses: {
+        [id: string]: response;
+    };
+    readonly parameters: (undefined | parameter[]);
+};
+export type endpoint = {
+    readonly path: string;
+    readonly method: string;
+    readonly operationId: (undefined | string);
+    readonly summary: (undefined | string);
+    readonly description: (undefined | string);
+    readonly tags: (undefined | string[]);
+    readonly requestBody: (undefined | requestBody);
+    readonly responses: {
+        [id: string]: response;
+    };
+    readonly parameters: (undefined | parameter[]);
+};
+export type pathItem = {
+    readonly get: (undefined | operation);
+    readonly post: (undefined | operation);
+    readonly put: (undefined | operation);
+    readonly patch: (undefined | operation);
+    readonly delete: (undefined | operation);
+    readonly head: (undefined | operation);
+    readonly options: (undefined | operation);
+    readonly parameters: (undefined | parameter[]);
+};
+export type components = {
+    readonly schemas: (undefined | {
+        [id: string]: jsonSchema;
+    });
+};
+export type info = {
+    readonly title: string;
+    readonly version: string;
+    readonly description: (undefined | string);
+};
+export type openAPISpec = {
+    readonly openapi: string;
+    readonly info: info;
+    readonly paths: {
+        [id: string]: pathItem;
+    };
+    readonly components: (undefined | components);
+};
+export type generationStrategy = "Separate" | "SharedBase";
+export type breakingChangeHandling = "Error" | "Warn" | "Ignore";
+export type forkSpecConfig = {
+    readonly name: string;
+    readonly specPath: string;
+};
+export type generationTargets = {
+    readonly rescriptApi: boolean;
+    readonly rescriptWrapper: boolean;
+    readonly typescriptDts: boolean;
+    readonly typescriptWrapper: boolean;
+};
+export type generationConfig = Config_t;
+export type forkSpec = {
+    readonly name: string;
+    readonly spec: openAPISpec;
+};
+export type errorContext = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type codegenError = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: errorContext;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: errorContext;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | errorContext);
+};
+export type warning = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: errorContext;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};
+export type endpointDiff = {
+    readonly path: string;
+    readonly method: string;
+    readonly requestBodyChanged: boolean;
+    readonly responseChanged: boolean;
+    readonly breakingChange: boolean;
+};
+export type schemaDiff = {
+    readonly name: string;
+    readonly breakingChange: boolean;
+};
+export type specDiff = {
+    readonly addedEndpoints: endpoint[];
+    readonly removedEndpoints: endpoint[];
+    readonly modifiedEndpoints: endpointDiff[];
+    readonly addedSchemas: string[];
+    readonly removedSchemas: string[];
+    readonly modifiedSchemas: schemaDiff[];
+};
+export type generationSuccess = {
+    readonly generatedFiles: string[];
+    readonly diff: (undefined | specDiff);
+    readonly warnings: warning[];
+};
+export type generationResult = {
+    TAG: "Ok";
+    _0: generationSuccess;
+} | {
+    TAG: "Error";
+    _0: codegenError;
+};
+export type CodegenError_context = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type CodegenError_t = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: CodegenError_context;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: CodegenError_context;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | CodegenError_context);
+};
+export type Warning_t = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: CodegenError_context;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};

package/lib/es6/src/core/FileSystem.d.ts

@@ -0,0 +1,4 @@
+export type fileToWrite = {
+    readonly path: string;
+    readonly content: string;
+};

package/lib/es6/src/core/Pipeline.d.ts

@@ -0,0 +1,6 @@
+import type { fileToWrite as FileSystem_fileToWrite } from './FileSystem';
+import type { warning as Types_warning } from '../../src/Types';
+export type t = {
+    readonly files: FileSystem_fileToWrite[];
+    readonly warnings: Types_warning[];
+};

package/lib/es6/src/types/CodegenError.d.ts

@@ -0,0 +1,66 @@
+export type context = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type t = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: context;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: context;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | context);
+};
+export type Warning_t = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: context;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};

package/lib/es6/src/types/Config.d.ts

@@ -0,0 +1,31 @@
+export type generationStrategy = "Separate" | "SharedBase";
+export type breakingChangeHandling = "Error" | "Warn" | "Ignore";
+export type forkSpecConfig = {
+    readonly name: string;
+    readonly specPath: string;
+};
+export type generationTargets = {
+    readonly rescriptApi: boolean;
+    readonly rescriptWrapper: boolean;
+    readonly typescriptDts: boolean;
+    readonly typescriptWrapper: boolean;
+};
+export type t = {
+    readonly specPath: string;
+    readonly forkSpecs: (undefined | forkSpecConfig[]);
+    readonly outputDir: string;
+    readonly strategy: generationStrategy;
+    readonly modulePerTag: boolean;
+    readonly includeTags: (undefined | string[]);
+    readonly excludeTags: (undefined | string[]);
+    readonly generateDiffReport: boolean;
+    readonly breakingChangeHandling: breakingChangeHandling;
+    readonly generateDocOverrides: (undefined | boolean);
+    readonly docOverrideDir: (undefined | string);
+    readonly targets: (undefined | generationTargets);
+    readonly dtsOutputDir: (undefined | string);
+    readonly wrapperOutputDir: (undefined | string);
+    readonly baseInstanceName: (undefined | string);
+    readonly baseModulePrefix: (undefined | string);
+};
+export declare const make: (specPath: string, outputDir: string, strategy: (undefined | generationStrategy), modulePerTag: (undefined | boolean), includeTags: (undefined | string[]), excludeTags: (undefined | string[]), generateDiffReport: (undefined | boolean), breakingChangeHandling: (undefined | breakingChangeHandling), forkSpecs: (undefined | forkSpecConfig[]), generateDocOverrides: (undefined | boolean), docOverrideDir: (undefined | string), targets: (undefined | generationTargets), dtsOutputDir: (undefined | string), wrapperOutputDir: (undefined | string), baseInstanceName: (undefined | string), baseModulePrefix: (undefined | string), _17: void) => t;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-autogen-openapi",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Generate ReScript code with Sury schemas from OpenAPI 3.1 specs. Supports multiple forks with diff/merge capabilities.",
   "keywords": [
     "rescript",
@@ -16,7 +16,8 @@
   "license": "MPL-2.0",
   "files": [
     "src/**/*.res",
-    "lib/es6/**/*.mjs",
+    "lib/es6/src/**/*.mjs",
+    "lib/es6/src/**/*.d.ts",
     "rescript.json",
     "README.md",
     "LICENSE"
@@ -25,23 +26,26 @@
     "url": "https://github.com/f3liz-dev/rescript-autogen-openapi"
   },
   "scripts": {
-    "build": "rescript",
+    "build": "rescript && node scripts/generate-dts.mjs",
     "clean": "rescript clean",
     "watch": "rescript build -w",
     "test": "node --test"
   },
   "main": "lib/es6/src/Codegen.mjs",
+  "types": "lib/es6/src/Codegen.d.ts",
   "type": "module",
   "dependencies": {
     "@readme/openapi-parser": "^5.5.0",
     "js-convert-case": "^4.2.0",
-    "pathe": "^2.0.3",
-    "sury": "11.0.0-alpha.4"
+    "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "rescript": "^12.1.0"
+    "rescript": "^12.1.0",
+    "sury": "11.0.0-alpha.4",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "rescript": "^12.0.0"
+    "rescript": "^12.0.0",
+    "sury": ">=11.0.0-alpha.4"
   }
 }

package/rescript.json

@@ -13,6 +13,12 @@
     }
   ],
   "suffix": ".mjs",
+  "gentypeconfig": {
+    "language": "typescript",
+    "module": "es6",
+    "importPath": "relative",
+    "generatedFileExtension": ".gen.ts"
+  },
   "dependencies": [],
   "warnings": {
     "number": "-44-102"

package/src/Codegen.res

@@ -7,6 +7,7 @@ open Types
 @val external promiseAll: array<promise<'a>> => promise<array<'a>> = "Promise.all"
 
 // Generate code from a single spec (pure - returns data)
+@genType
 let generateSingleSpecPure = (~spec: openAPISpec, ~config: generationConfig): result<Pipeline.t, codegenError> => {
   try {
     let targets = config.targets->Option.getOr(Config.defaultTargets())
@@ -54,6 +55,7 @@ let generateSingleSpecPure = (~spec: openAPISpec, ~config: generationConfig): re
 }
 
 // Generate code from a single spec (with side effects)
+@genType
 let generateSingleSpec = async (~spec: openAPISpec, ~config: generationConfig): generationResult => {
   switch generateSingleSpecPure(~spec, ~config) {
   | Result.Error(err) => Result.Error(err)
@@ -140,6 +142,7 @@ let processForkPure = (~baseSpec: openAPISpec, ~baseEndpoints: array<endpoint>,
 }
 
 // Generate code from multiple specs (pure - returns data)
+@genType
 let generateMultiSpecPure = (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpec>, ~config: generationConfig): result<Pipeline.t, codegenError> => {
   try {
     let baseEndpoints = OpenAPIParser.getAllEndpoints(baseSpec)
@@ -169,6 +172,7 @@ let generateMultiSpecPure = (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpec>
 }
 
 // Generate code from multiple specs (with side effects)
+@genType
 let generateMultiSpec = async (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpec>, ~config: generationConfig): generationResult =>
   switch generateMultiSpecPure(~baseSpec, ~forkSpecs, ~config) {
   | Result.Error(err) => Result.Error(err)
@@ -179,6 +183,7 @@ let generateMultiSpec = async (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpe
   }
 
 // Compare two specs and generate diff report
+@genType
 let compareSpecs = async (~baseSpec, ~forkSpec, ~baseName="base", ~forkName="fork", ~outputPath=?) => {
   let diff = SpecDiffer.generateDiff(~baseSpec, ~forkSpec, ~baseEndpoints=OpenAPIParser.getAllEndpoints(baseSpec), ~forkEndpoints=OpenAPIParser.getAllEndpoints(forkSpec))
   outputPath->Option.forEach(path => {
@@ -188,6 +193,7 @@ let compareSpecs = async (~baseSpec, ~forkSpec, ~baseName="base", ~forkName="for
 }
 
 // Main generation function
+@genType
 let generate = async (config: generationConfig): generationResult => {
   switch await SchemaRefResolver.resolve(config.specPath) {
   | Result.Error(message) => Result.Error(SpecResolutionError({url: config.specPath, message}))
@@ -207,6 +213,7 @@ let generate = async (config: generationConfig): generationResult => {
   }
 }
 
+@genType
 let createDefaultConfig = (url, outputDir): generationConfig => ({
   specPath: url, outputDir, strategy: SharedBase, includeTags: None, excludeTags: None,
   modulePerTag: true, generateDiffReport: true, breakingChangeHandling: Warn,
@@ -215,8 +222,10 @@ let createDefaultConfig = (url, outputDir): generationConfig => ({
   baseInstanceName: None, baseModulePrefix: None,
 })
 
+@genType
 let generateFromUrl = async (~url, ~outputDir, ~config=?) => 
   await generate({...config->Option.getOr(createDefaultConfig(url, outputDir)), specPath: url})
 
+@genType
 let generateFromFile = async (~filePath, ~outputDir, ~config=?) => 
   await generate({...config->Option.getOr(createDefaultConfig(filePath, outputDir)), specPath: filePath})

package/src/Types.res

@@ -3,6 +3,7 @@
 // Types.res - Core OpenAPI and generation types (refactored & compact)
 
 // ============= JSON Schema Types =============
+@genType
 type rec jsonSchemaType =
   | String
   | Number
@@ -13,6 +14,7 @@ type rec jsonSchemaType =
   | Null
   | Unknown
 
+@genType
 and jsonSchema = {
   @as("type") type_: option<jsonSchemaType>,
   properties: option<dict<jsonSchema>>,
@@ -34,25 +36,30 @@ and jsonSchema = {
 }
 
 // ============= OpenAPI 3.1 Types =============
+@genType
 type httpMethod = [#GET | #POST | #PUT | #PATCH | #DELETE | #HEAD | #OPTIONS]
 
+@genType
 type mediaType = {
   schema: option<jsonSchema>,
   example: option<JSON.t>,
   examples: option<dict<JSON.t>>,
 }
 
+@genType
 type requestBody = {
   description: option<string>,
   content: dict<mediaType>,
   required: option<bool>,
 }
 
+@genType
 type response = {
   description: string,
   content: option<dict<mediaType>>,
 }
 
+@genType
 type parameter = {
   name: string,
   @as("in") in_: string,
@@ -61,6 +68,7 @@ type parameter = {
   schema: option<jsonSchema>,
 }
 
+@genType
 type operation = {
   operationId: option<string>,
   summary: option<string>,
@@ -71,6 +79,7 @@ type operation = {
   parameters: option<array<parameter>>,
 }
 
+@genType
 type endpoint = {
   path: string,
   method: string,
@@ -83,6 +92,7 @@ type endpoint = {
   parameters: option<array<parameter>>,
 }
 
+@genType
 type pathItem = {
   get: option<operation>,
   post: option<operation>,
@@ -94,14 +104,17 @@ type pathItem = {
   parameters: option<array<parameter>>,
 }
 
+@genType
 type components = {schemas: option<dict<jsonSchema>>}
 
+@genType
 type info = {
   title: string,
   version: string,
   description: option<string>,
 }
 
+@genType
 type openAPISpec = {
   openapi: string,
   info: info,
@@ -111,32 +124,40 @@ type openAPISpec = {
 
 // ============= Re-exports from focused modules =============
 // Config types
+@genType
 type generationStrategy = Config.generationStrategy =
   | Separate
   | SharedBase
 
+@genType
 type breakingChangeHandling = Config.breakingChangeHandling = | Error | Warn | Ignore
+@genType
 type forkSpecConfig = Config.forkSpecConfig = {name: string, specPath: string}
+@genType
 type generationTargets = Config.generationTargets = {
   rescriptApi: bool,
   rescriptWrapper: bool,
   typescriptDts: bool,
   typescriptWrapper: bool,
 }
+@genType
 type generationConfig = Config.t
 
+@genType
 type forkSpec = {
   name: string,
   spec: openAPISpec,
 }
 
 // Error types - use `=` syntax to re-export constructors
+@genType
 type errorContext = CodegenError.context = {
   path: string,
   operation: string,
   schema: option<JSON.t>,
 }
 
+@genType
 type codegenError = CodegenError.t =
   | SpecResolutionError({url: string, message: string})
   | SchemaParseError({context: errorContext, reason: string})
@@ -147,6 +168,7 @@ type codegenError = CodegenError.t =
   | InvalidConfigError({field: string, message: string})
   | UnknownError({message: string, context: option<errorContext>})
 
+@genType
 type warning = CodegenError.Warning.t =
   | FallbackToJson({reason: string, context: errorContext})
   | UnsupportedFeature({feature: string, fallback: string, location: string})
@@ -156,6 +178,7 @@ type warning = CodegenError.Warning.t =
   | ComplexUnionSimplified({location: string, types: string})
 
 // ============= Diff Types =============
+@genType
 type endpointDiff = {
   path: string,
   method: string,
@@ -164,11 +187,13 @@ type endpointDiff = {
   breakingChange: bool,
 }
 
+@genType
 type schemaDiff = {
   name: string,
   breakingChange: bool,
 }
 
+@genType
 type specDiff = {
   addedEndpoints: array<endpoint>,
   removedEndpoints: array<endpoint>,
@@ -179,12 +204,14 @@ type specDiff = {
 }
 
 // ============= Generation Result Types =============
+@genType
 type generationSuccess = {
   generatedFiles: array<string>,
   diff: option<specDiff>,
   warnings: array<warning>,
 }
 
+@genType
 type generationResult = result<generationSuccess, codegenError>
 
 // ============= Re-export helper modules =============

package/src/core/FileSystem.res

@@ -8,6 +8,7 @@
 @module("pathe") external dirname: string => string = "dirname"
 
 // Represents a file to be written
+@genType
 type fileToWrite = {
   path: string,
   content: string,

package/src/core/Pipeline.res

@@ -3,6 +3,7 @@
 // Pipeline.res - Compact data transformation pipeline
 open Types
 
+@genType
 type t = {
   files: array<FileSystem.fileToWrite>,
   warnings: array<warning>,

package/src/types/CodegenError.res

@@ -3,6 +3,7 @@
 // Error.res - Compact error and warning types with helpers
 
 // Error context for debugging (defined here to avoid circular dependency)
+@genType
 type context = {
   path: string,
   operation: string,
@@ -10,6 +11,7 @@ type context = {
 }
 
 // Structured error types (keep original names for backward compat)
+@genType
 type t =
   | SpecResolutionError({url: string, message: string})
   | SchemaParseError({context: context, reason: string})
@@ -22,6 +24,7 @@ type t =
 
 // Warning types
 module Warning = {
+  @genType
   type t =
     | FallbackToJson({reason: string, context: context})
     | UnsupportedFeature({feature: string, fallback: string, location: string})

package/src/types/Config.res

@@ -2,20 +2,24 @@
 
 // Config.res - Generation configuration types
 
+@genType
 type generationStrategy =
   | Separate
   | SharedBase
 
+@genType
 type breakingChangeHandling =
   | Error
   | Warn
   | Ignore
 
+@genType
 type forkSpecConfig = {
   name: string,
   specPath: string,
 }
 
+@genType
 type generationTargets = {
   rescriptApi: bool,              // Generate base ReScript API (always true by default)
   rescriptWrapper: bool,          // Generate ReScript thin wrapper (pipe-first)
@@ -23,6 +27,7 @@ type generationTargets = {
   typescriptWrapper: bool,        // Generate TypeScript/JavaScript wrapper
 }
 
+@genType
 type t = {
   specPath: string,
   forkSpecs: option<array<forkSpecConfig>>,
@@ -43,6 +48,7 @@ type t = {
 }
 
 // Default configuration
+@genType
 let make = (
   ~specPath,
   ~outputDir,