vovk-cli 0.0.1-draft.255 → 0.0.1-draft.256

package/client-templates/cjs/index.d.cts.ejs

@@ -7,7 +7,7 @@ import type { createRPC } from '<%= t.imports.module.createRPC %>';
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
 <% }}) %>
 <% if (t.hasMixins) { %>
-import type { Controllers as MixinControllers } from "./mixins";
+import type { Controllers as MixinControllers, Mixins } from "./mixins";
 <% } %>
 
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
@@ -16,4 +16,7 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 export const <%= rpcModuleName %>: ReturnType<typeof createRPC<<%= segment.segmentType === 'mixin' ? `MixinControllers` : `Controllers${i}` %>["<%= rpcModuleName %>"], Options>>;
   <% }) 
 }) %>
-export { schema } from './schema.cjs';
+export { schema } from './schema.cjs';
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/client-templates/mixins/mixins.d.ts.ejs

@@ -1,27 +1,64 @@
 <%- `// auto-generated by Vovk.ts ${new Date().toISOString()}` %>
 import type { VovkRequest, VovkStreamAsyncIterable, KnownAny } from 'vovk';
 
-<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType === 'mixin').forEach((segment, i) => {
-  Object.values(segment.controllers).forEach((controllerSchema) => {
-      Object.entries(controllerSchema.handlers).forEach(([handlerName, handlerSchema]) => { 
-            ['body', 'query', 'params', 'output', 'iteration'].forEach((type) => {
-              if (handlerSchema.validation?.[type]?.$defs || handlerSchema.validation?.[type]?.definitions) { %>
-<%- t.convertJSONSchemaToTypeScriptDef(handlerSchema.validation?.[type], `$defs__${controllerSchema.rpcModuleName}__${handlerName}__${type}`).$defs %>
-              <% }
-            }) 
-        }) 
-    }) 
-}); %>
+<% const mixins = Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType === 'mixin'); %>
+
+export namespace Mixins {
+  <% for (const segment of mixins) { %>
+    <% console.log(segment); if(segment.meta?.components?.schemas) { %>
+      export namespace <%= t._.upperFirst(t._.camelCase(segment.segmentName)) %> {
+        <% for (const [componentName, componentSchema] of Object.entries(segment.meta.components.schemas)) { %>
+          <%- await t.compileJSONSchemaToTypeScriptType(componentSchema, componentName, segment.meta.components) %>
+        <% } %>
+      }
+    <% } %>
+  <% } %>
+}
+
+export namespace Types {
+  <% for (const segment of mixins) { %>
+    export namespace <%= t._.upperFirst(t._.camelCase(segment.segmentName)) %> {
+      <% for (const [controllerName, controllerSchema] of Object.entries(segment.controllers)) { %>
+        export namespace <%= controllerSchema.rpcModuleName %> {
+          <% for (const [handlerName, handlerSchema] of Object.entries(controllerSchema.handlers)) { %>
+            export namespace <%= t._.upperFirst(handlerName) %> {
+            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.body, 'Body') %>
+            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.query, 'Query') %>
+            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.params, 'Params') %>
+            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.output, 'Output') %>
+            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.iteration,  'Iteration') %>
+            }
+          <% } %>
+        }
+      <% } %>
+    }
+  <% } %>
+}
+
+<% const getType = (segment, controllerSchema, handlerName, validationType) => {
+  const segmentNs = t._.upperFirst(t._.camelCase(segment.segmentName));
+  const controllerNs = controllerSchema.rpcModuleName;
+  const handlerNs = t._.upperFirst(handlerName);
+  const typeName = t._.upperFirst(validationType);
+  const handlerSchema = controllerSchema.handlers[handlerName];
+  if(handlerSchema.validation?.[validationType] ) {
+    return 'Types.' + segmentNs + '.' + controllerNs + '.' + handlerNs + '.' + typeName;
+  }
+  return 'null';
+} %>
 
 export type Controllers = {
-    <% Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType === 'mixin').forEach((segment, i) => {%>
-      <% Object.values(segment.controllers).forEach((controllerSchema) => { %>
+    <% for (const segment of Object.values(t.schema.segments).filter((segment) => segment.emitSchema && segment.segmentType === 'mixin')) { %>
+      <% for (const controllerSchema of Object.values(segment.controllers)) { %>
       <%= controllerSchema.rpcModuleName %>: {
-        <% Object.entries(controllerSchema.handlers).forEach(([handlerName, handlerSchema]) => { %>
-          <%= handlerName %>: (req: VovkRequest<<%- t.convertJSONSchemaToTypeScriptDef(handlerSchema.validation?.body, `$defs__${controllerSchema.rpcModuleName}__${handlerName}__body`).$type %>, <%- t.convertJSONSchemaToTypeScriptDef(handlerSchema.validation?.query, `$defs__${controllerSchema.rpcModuleName}__${handlerName}__query`).$type %>, <%- t.convertJSONSchemaToTypeScriptDef(handlerSchema.validation?.params, `$defs__${controllerSchema.rpcModuleName}__${handlerName}__params`).$type %>>) => <%- handlerSchema.validation?.output ? `Promise<${t.convertJSONSchemaToTypeScriptDef(handlerSchema.validation?.output, `$defs__${controllerSchema.rpcModuleName}__${handlerName}__output`).$type}>` : handlerSchema.validation?.iteration ? `Promise<VovkStreamAsyncIterable<${t.convertJSONSchemaToTypeScriptDef(handlerSchema.validation?.iteration, `$defs__${controllerSchema.rpcModuleName}__${handlerName}__iteration`).$type}>>` : 'Promise<KnownAny>' %>,
-        <% }) %>
+        <% for (const [handlerName, handlerSchema] of Object.entries(controllerSchema.handlers)) { %>
+          <%= handlerName %>: (req: VovkRequest<
+          <%- getType(segment, controllerSchema, handlerName, 'body') %>, 
+          <%- getType(segment, controllerSchema, handlerName, 'query') %>, 
+          <%- getType(segment, controllerSchema, handlerName, 'params')  %>
+          >) => <%- handlerSchema.validation?.output ? `Promise<${getType(segment, controllerSchema, handlerName, 'output')}>` : handlerSchema.validation?.iteration ? `Promise<VovkStreamAsyncIterable<${getType(segment, controllerSchema, handlerName, 'iteration')}>` : 'Promise<KnownAny>' %>,
+        <% } %>
       };
-     <% }) %>
-    <% }); %>
-};
-
+     <% } %>
+    <% } %>
+};

package/client-templates/mjs/index.d.mts.ejs

@@ -7,7 +7,7 @@ import type { createRPC } from '<%= t.imports.module.createRPC %>';
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
 <% }}) %>
 <% if (t.hasMixins) { %>
-import type { Controllers as MixinControllers } from "./mixins";
+import type { Controllers as MixinControllers, Mixins } from "./mixins";
 <% } %>
 
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
@@ -16,4 +16,7 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 export const <%= rpcModuleName %>: ReturnType<typeof createRPC<<%= segment.segmentType === 'mixin' ? `MixinControllers` : `Controllers${i}` %>["<%= rpcModuleName %>"], Options>>;
   <% }) 
 }) %>
-export { schema } from './schema.cjs';
+export { schema } from './schema.cjs';
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/client-templates/schemaTs/schema.ts.ejs

@@ -4,6 +4,7 @@ import meta from './<%= t.schemaOutDir %>/_meta.json' with { type: "json" };
 <% } %>
 <% if(t.hasMixins) { %>
 import mixins from './mixins.json' with { type: "json" };
+import type { Mixins } from './mixins.d.ts';
 <% } %>
 <% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { if(segment.segmentType !== 'mixin') { %>
 import segment<%= i %> from './<%= t.schemaOutDir %>/<%= segment.segmentName || t.ROOT_SEGMENT_FILE_NAME %>.json' with { type: "json" };
@@ -28,3 +29,7 @@ export const schema = {
     <% } %>
   }
 };
+
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/client-templates/ts/index.ts.ejs

@@ -8,7 +8,7 @@ import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segme
 <% }
 });
 if (t.hasMixins) { %>
-import type { Controllers as MixinControllers } from "./mixins.d.ts";
+import type { Controllers as MixinControllers, Mixins } from "./mixins.d.ts";
 <% } 
 if (t.imports.validateOnClient) { %>
 import { validateOnClient } from '<%= t.imports.validateOnClient %>';
@@ -24,4 +24,7 @@ export const <%= rpcModuleName %> = createRPC<<%= segment.segmentType === 'mixin
 );
 <% }) 
 }) %>
-export { schema };
+export { schema };
+<% if (t.hasMixins) { %>
+export { Mixins };
+<% } %>

package/dist/generate/generate.mjs

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import matter from 'gray-matter';
 import _ from 'lodash';
-import { openAPIToVovkSchema, VovkSchemaIdEnum } from 'vovk';
+import { openAPIToVovkSchema } from 'vovk';
 import getClientTemplateFiles from './getClientTemplateFiles.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import pickSegmentFullSchema from '../utils/pickSegmentFullSchema.mjs';
@@ -86,38 +86,19 @@ export async function generate({ isEnsuringClient = false, projectInfo, forceNot
         ...config.openApiMixins,
         ...cliOptionsToOpenAPIMixins(cliGenerateOptions ?? {}),
     };
+    /** @deprecated */
     let hasMixins = false;
     if (Object.keys(allOpenAPIMixins).length) {
-        const mixins = Object.fromEntries(Object.entries(await normalizeOpenAPIMixins({ mixinModules: allOpenAPIMixins })).map(([mixinName, conf]) => {
-            return [
-                mixinName,
-                openAPIToVovkSchema({
-                    ...conf,
-                    mixinName,
-                }).segments[mixinName],
-            ];
-        }));
+        const mixins = Object.fromEntries(Object.entries(await normalizeOpenAPIMixins({ mixinModules: allOpenAPIMixins })).map(([mixinName, conf]) => [
+            mixinName,
+            openAPIToVovkSchema({ ...conf, mixinName }).segments[mixinName],
+        ]));
         hasMixins = true;
         fullSchema = {
             ...fullSchema,
             segments: {
                 ...fullSchema.segments,
-                ...Object.fromEntries(Object.entries(mixins).map(([segmentName, mixin]) => {
-                    return [
-                        segmentName,
-                        {
-                            $schema: VovkSchemaIdEnum.SEGMENT,
-                            emitSchema: true,
-                            segmentType: 'mixin',
-                            segmentName,
-                            forceApiRoot: mixin?.forceApiRoot, // TODO: Merging with existing segments and using apiRoot doesn't make a lot of sense
-                            controllers: {
-                                ...fullSchema.segments[segmentName]?.controllers,
-                                ...mixin?.controllers,
-                            },
-                        },
-                    ];
-                })),
+                ...mixins,
             },
         };
     }

package/dist/generate/getClientTemplateFiles.d.mts

@@ -14,6 +14,7 @@ export default function getClientTemplateFiles({ config, cwd, log, configKey, cl
     log: ProjectInfo['log'];
     configKey: 'composedClient' | 'segmentedClient';
     cliGenerateOptions?: GenerateOptions;
+    /** @deprecated */
     hasMixins: boolean;
 }): Promise<{
     fromTemplates: string[];

package/dist/generate/getClientTemplateFiles.mjs

@@ -31,6 +31,7 @@ export default async function getClientTemplateFiles({ config, cwd, log, configK
         }
         usedTemplateDefs[templateName] = usedDef;
     }
+    // $openapi['github']['components']['schemas']['User'];
     const templateFiles = [];
     const entries = Object.entries(usedTemplateDefs);
     for (let i = 0; i < entries.length; i++) {

package/dist/generate/writeOneClientFile.mjs

@@ -7,7 +7,7 @@ import * as YAML from 'yaml';
 import TOML from '@iarna/toml';
 import prettify from '../utils/prettify.mjs';
 import { ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
-import { convertJSONSchemaToTypeScriptDef } from '../utils/convertJSONSchemaToTypeScriptDef.mjs';
+import { compileJSONSchemaToTypeScriptType } from '../utils/compileJSONSchemaToTypeScriptType.mjs';
 export default async function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, isEnsuringClient, outCwdRelativeDir, origin, templateDef, locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, }) {
     const { config, apiRoot } = projectInfo;
     const { templateFilePath, relativeDir } = clientTemplateFile;
@@ -29,7 +29,7 @@ export default async function writeOneClientFile({ cwd, projectInfo, clientTempl
         schema: fullSchema,
         VovkSchemaIdEnum,
         createCodeExamples,
-        convertJSONSchemaToTypeScriptDef,
+        compileJSONSchemaToTypeScriptType,
         YAML,
         TOML,
         nodeNextResolutionExt: {
@@ -74,8 +74,9 @@ export default async function writeOneClientFile({ cwd, projectInfo, clientTempl
     }
     // Render the template
     let rendered = templateFilePath.endsWith('.ejs')
-        ? ejs.render(content, { t }, {
+        ? await ejs.render(content, { t }, {
             filename: templateFilePath,
+            async: true,
         })
         : templateContent;
     // Optionally prettify

package/dist/utils/compileJSONSchemaToTypeScriptType.d.mts

@@ -0,0 +1,3 @@
+import { JSONSchema } from 'json-schema-to-typescript';
+import { OpenAPIObject } from 'openapi3-ts/oas31';
+export declare function compileJSONSchemaToTypeScriptType(schema: JSONSchema, typeName: string, components?: NonNullable<OpenAPIObject['components']>): Promise<string>;

package/dist/utils/compileJSONSchemaToTypeScriptType.mjs

@@ -0,0 +1,225 @@
+import { compile } from 'json-schema-to-typescript';
+export async function compileJSONSchemaToTypeScriptType(schema, typeName, components = {}) {
+    if (!schema)
+        return '';
+    const tsType = await compile({ ...schema, components }, typeName, {
+        bannerComment: schema.description ? `/**\n * ${schema.description}\n */` : '',
+        style: {
+            bracketSpacing: true,
+            printWidth: 80,
+            semi: true,
+            singleQuote: true,
+            tabWidth: 2,
+            useTabs: false,
+            trailingComma: 'all',
+        },
+        // Don't generate separate interfaces for additionalProperties
+        additionalProperties: false,
+        // Enable strict null checks
+        strictIndexSignatures: true,
+        // Don't add schema as comment
+    });
+    return tsType;
+}
+/*
+// Extend JSONSchema to include custom x-formData property
+interface ExtendedJSONSchema extends JSONSchema {
+  'x-formData'?: boolean;
+  [key: string]: any;
+}
+
+interface OpenAPIDocument {
+  openapi: string;
+  components?: {
+    schemas?: Record<string, ExtendedJSONSchema>;
+  };
+  [key: string]: any;
+}
+
+/**
+ * Converts OpenAPI 3.1 component schemas to TypeScript type definitions
+ * @param oasDoc - The OpenAPI 3.1 document
+ * @param options - Optional configuration for the TypeScript generation
+ * @returns A string containing all TypeScript type definitions
+ * /
+export async function oasToTypeScript(
+  oasDoc: OpenAPIDocument,
+  options?: {
+    bannerComment?: string;
+    style?: {
+      bracketSpacing?: boolean;
+      printWidth?: number;
+      semi?: boolean;
+      singleQuote?: boolean;
+      tabWidth?: number;
+      useTabs?: boolean;
+      trailingComma?: 'all' | 'es5' | 'none';
+    };
+  }
+): Promise<string> {
+  // Validate that this is an OAS 3.1 document
+  if (!oasDoc.openapi || !oasDoc.openapi.startsWith('3.1')) {
+    throw new Error('Document must be an OpenAPI 3.1 specification');
+  }
+
+  // Extract schemas from components
+  const schemas = oasDoc.components?.schemas || {};
+
+  if (Object.keys(schemas).length === 0) {
+    return '// No schemas found in components';
+  }
+
+  const typeDefinitions: string[] = [];
+
+  // Process each schema
+  for (const [schemaName, schema] of Object.entries(schemas)) {
+    try {
+      // Check if schema has x-formData: true
+      if (schema['x-formData'] === true) {
+        // Generate a simple type alias to FormData
+        typeDefinitions.push(`export type ${schemaName} = FormData;\n`);
+        continue;
+      }
+
+      // Handle schema references
+      const resolvedSchema = resolveSchemaReferences(schema, schemas);
+
+      // Compile to TypeScript
+      const tsType = await compile(resolvedSchema as JSONSchema, schemaName, {
+        bannerComment: options?.bannerComment || '',
+        style: options?.style || {
+          bracketSpacing: true,
+          printWidth: 80,
+          semi: true,
+          singleQuote: true,
+          tabWidth: 2,
+          useTabs: false,
+          trailingComma: 'all',
+        },
+        // Don't generate separate interfaces for additionalProperties
+        additionalProperties: false,
+        // Enable strict null checks
+        strictIndexSignatures: true,
+        // Don't add schema as comment
+        $refOptions: {
+          resolve: {
+            // Resolve internal references
+            internal: true,
+            // Add our custom resolver
+            custom: {
+              order: 1,
+              canRead: (ref: string) => ref.startsWith('#/components/schemas/'),
+            },
+          },
+        },
+      });
+
+      typeDefinitions.push(tsType);
+    } catch (error) {
+      console.error(`Error processing schema "${schemaName}":`, error);
+      typeDefinitions.push(`// Error processing schema "${schemaName}": ${error.message}`);
+    }
+  }
+
+  return typeDefinitions.join('\n');
+}
+
+/**
+ * Resolves $ref references within a schema
+ * /
+function resolveSchemaReferences(
+  schema: any,
+  allSchemas: Record<string, ExtendedJSONSchema>,
+  visited = new Set<string>()
+): any {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  // Handle $ref
+  if (schema.$ref && typeof schema.$ref === 'string') {
+    const refPath = schema.$ref.replace('#/components/schemas/', '');
+
+    // Prevent circular references
+    if (visited.has(refPath)) {
+      return { type: 'object', additionalProperties: true };
+    }
+
+    visited.add(refPath);
+    const referencedSchema = allSchemas[refPath];
+
+    if (referencedSchema) {
+      return resolveSchemaReferences(referencedSchema, allSchemas, visited);
+    }
+
+    return schema;
+  }
+
+  // Handle arrays
+  if (Array.isArray(schema)) {
+    return schema.map((item) => resolveSchemaReferences(item, allSchemas, visited));
+  }
+
+  // Handle objects recursively
+  const resolved: any = {};
+  for (const [key, value] of Object.entries(schema)) {
+    resolved[key] = resolveSchemaReferences(value, allSchemas, visited);
+  }
+
+  return resolved;
+}
+
+// Example usage:
+/*
+const oasDoc = {
+  openapi: '3.1.0',
+  info: {
+    title: 'My API',
+    version: '1.0.0'
+  },
+  components: {
+    schemas: {
+      User: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer' },
+          name: { type: 'string' },
+          email: { type: 'string', format: 'email' },
+          roles: {
+            type: 'array',
+            items: { $ref: '#/components/schemas/Role' }
+          }
+        },
+        required: ['id', 'name', 'email']
+      },
+      Role: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer' },
+          name: { type: 'string' },
+          permissions: {
+            type: 'array',
+            items: { type: 'string' }
+          }
+        },
+        required: ['id', 'name']
+      },
+      UploadFileRequest: {
+        'x-formData': true,
+        type: 'object',
+        properties: {
+          file: { type: 'string', format: 'binary' },
+          description: { type: 'string' }
+        }
+      }
+    }
+  }
+};
+
+const types = await oasToTypeScript(oasDoc);
+console.log(types);
+// Output will include:
+// export interface User { ... }
+// export interface Role { ... }
+// export type UploadFileRequest = FormData;
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.255",
+  "version": "0.0.1-draft.256",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -60,6 +60,7 @@
     "glob": "^11.0.2",
     "gray-matter": "^4.0.3",
     "inflection": "^3.0.2",
+    "json-schema-to-typescript": "^15.0.4",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.2",

package/dist/utils/convertJSONSchemaToTypeScriptDef.d.mts

@@ -1,5 +0,0 @@
-import type { JSONSchema7 } from 'json-schema';
-export declare function convertJSONSchemaToTypeScriptDef(schema: JSONSchema7, defsPrefix: string): {
-    $type: string;
-    $defs: string;
-};

package/dist/utils/convertJSONSchemaToTypeScriptDef.mjs

@@ -1,271 +0,0 @@
-export function convertJSONSchemaToTypeScriptDef(schema, defsPrefix) {
-    if (!schema)
-        return { $type: 'null', $defs: 'null' };
-    // Helper function to escape single quotes in string literals
-    const escapeStringLiteral = (str) => {
-        return str.replace(/'/g, "\\'");
-    };
-    // Helper function to escape JSDoc comment closing sequences
-    const escapeJSDocComment = (str) => {
-        return str.replace(/\*\//g, '*\\/');
-    };
-    // Helper function to check if a property name is a valid JavaScript identifier
-    const isValidIdentifier = (name) => {
-        // Check if it matches valid JavaScript identifier pattern and is not a reserved word
-        return (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) &&
-            ![
-                'break',
-                'case',
-                'catch',
-                'class',
-                'const',
-                'continue',
-                'debugger',
-                'default',
-                'delete',
-                'do',
-                'else',
-                'export',
-                'extends',
-                'false',
-                'finally',
-                'for',
-                'function',
-                'if',
-                'import',
-                'in',
-                'instanceof',
-                'new',
-                'null',
-                'return',
-                'super',
-                'switch',
-                'this',
-                'throw',
-                'true',
-                'try',
-                'typeof',
-                'var',
-                'void',
-                'while',
-                'with',
-                'let',
-                'static',
-                'yield',
-                'enum',
-                'await',
-                'implements',
-                'interface',
-                'package',
-                'private',
-                'protected',
-                'public',
-            ].includes(name));
-    };
-    // Helper function to format property name (with quotes if needed)
-    const formatPropertyName = (name) => {
-        if (isValidIdentifier(name)) {
-            return name;
-        }
-        else {
-            return `'${escapeStringLiteral(name)}'`;
-        }
-    };
-    // Helper function to extract type name from $ref
-    const getRefTypeName = (ref) => {
-        if (ref.startsWith('#/definitions/') || ref.startsWith('#/$defs/')) {
-            const path = ref.split('/');
-            return `${defsPrefix}__${path[path.length - 1].replace(/[^a-zA-Z0-9_$]/g, '_')}`;
-        }
-        return 'KnownAny'; // Fallback for external references
-    };
-    // Helper function to get JSDoc from schema
-    const getJSDoc = (schema, indentation = '') => {
-        if (typeof schema === 'boolean') {
-            return '';
-        }
-        const description = schema.description || schema.title;
-        if (!description) {
-            return '';
-        }
-        const safeDescription = escapeJSDocComment(description);
-        return `${indentation}/**\n${indentation} * ${safeDescription}\n${indentation} */`;
-    };
-    // Helper function to convert schema to TypeScript type
-    const schemaToType = (schema, indentation = '  ') => {
-        if (!schema) {
-            return 'null';
-        }
-        if (typeof schema === 'boolean') {
-            return schema ? 'KnownAny' : 'never';
-        }
-        // Handle $ref references - check this first before other properties
-        if (schema.$ref) {
-            return getRefTypeName(schema.$ref);
-        }
-        if ('x-formData' in schema) {
-            return `FormData`; // Special case for form data
-        }
-        if (schema.enum) {
-            return schema.enum
-                .map((value) => {
-                if (typeof value === 'string') {
-                    return `'${escapeStringLiteral(value)}'`;
-                }
-                else if (value === null) {
-                    return 'null';
-                }
-                else {
-                    return String(value);
-                }
-            })
-                .join(' | ');
-        }
-        if (schema.const !== undefined) {
-            if (typeof schema.const === 'string') {
-                return `'${escapeStringLiteral(schema.const)}'`;
-            }
-            else if (schema.const === null) {
-                return 'null';
-            }
-            else {
-                return String(schema.const);
-            }
-        }
-        if (schema.oneOf) {
-            return schema.oneOf.map((s) => schemaToType(s, indentation)).join(' | ');
-        }
-        if (schema.anyOf) {
-            return schema.anyOf.map((s) => schemaToType(s, indentation)).join(' | ');
-        }
-        if (schema.allOf) {
-            return schema.allOf.map((s) => schemaToType(s, indentation)).join(' & ');
-        }
-        if (schema.type === 'object' || schema.properties) {
-            const properties = schema.properties || {};
-            const required = schema.required || [];
-            const propertyEntries = Object.entries(properties);
-            if (propertyEntries.length === 0) {
-                // Handle additional properties
-                if (schema.additionalProperties) {
-                    if (typeof schema.additionalProperties === 'boolean') {
-                        return schema.additionalProperties ? 'Record<string, KnownAny>' : '{}';
-                    }
-                    else {
-                        const valueType = schemaToType(schema.additionalProperties, indentation);
-                        return `Record<string, ${valueType}>`;
-                    }
-                }
-                return '{}';
-            }
-            const props = propertyEntries
-                .map(([propName, propSchema]) => {
-                if (typeof propSchema === 'boolean') {
-                    const type = propSchema ? 'KnownAny' : 'never';
-                    const isOptional = !required.includes(propName);
-                    const jsDoc = getJSDoc(propSchema, indentation);
-                    return `${jsDoc}\n${indentation}${formatPropertyName(propName)}${isOptional ? '?' : ''}: ${type};`;
-                }
-                const isOptional = !required.includes(propName);
-                const defaultValue = propSchema.default !== undefined ? ` // default: ${JSON.stringify(propSchema.default)}` : '';
-                const jsDoc = getJSDoc(propSchema, indentation);
-                const propType = schemaToType(propSchema, indentation + '  ');
-                return [
-                    `${jsDoc}`,
-                    `${indentation}${formatPropertyName(propName)}${isOptional ? '?' : ''}: ${propType};${defaultValue}`,
-                ]
-                    .filter(Boolean)
-                    .join('\n');
-            })
-                .join('\n');
-            // Handle additional properties
-            let additionalPropsType = '';
-            if (schema.additionalProperties) {
-                if (typeof schema.additionalProperties === 'boolean') {
-                    if (schema.additionalProperties) {
-                        additionalPropsType = `\n${indentation}[key: string]: KnownAny;`;
-                    }
-                }
-                else {
-                    const valueType = schemaToType(schema.additionalProperties, indentation + '  ');
-                    additionalPropsType = `\n${indentation}[key: string]: ${valueType};`;
-                }
-            }
-            return `{\n${props}${additionalPropsType}\n${indentation.slice(2)}}`;
-        }
-        if (schema.type === 'array' && schema.items) {
-            if (Array.isArray(schema.items)) {
-                // Tuple
-                const tupleTypes = schema.items.map((item) => schemaToType(item, indentation));
-                let tupleType = `[${tupleTypes.join(', ')}]`;
-                // Handle additional items
-                if (schema.additionalItems === true) {
-                    tupleType += ' & KnownAny[]';
-                }
-                else if (typeof schema.additionalItems === 'object') {
-                    const additionalType = schemaToType(schema.additionalItems, indentation);
-                    tupleType += ` & ${additionalType}[]`;
-                }
-                return tupleType;
-            }
-            else {
-                // Array
-                return `${schemaToType(schema.items, indentation)}[]`;
-            }
-        }
-        // Handle multiple types
-        if (Array.isArray(schema.type)) {
-            return schema.type
-                .map((t) => {
-                const singleTypeSchema = { ...schema, type: t };
-                singleTypeSchema.type = t;
-                return schemaToType(singleTypeSchema, indentation);
-            })
-                .join(' | ');
-        }
-        // Handle primitive types
-        switch (schema.type) {
-            case 'string':
-                return 'string';
-            case 'number':
-            case 'integer':
-                return 'number';
-            case 'boolean':
-                return 'boolean';
-            case 'null':
-                return 'null';
-            case 'array':
-                return 'KnownAny[]'; // For arrays with no items defined
-            default:
-                return 'undefined';
-        }
-    };
-    const defsToType = (defs) => {
-        return Object.entries(defs)
-            .map(([defName, defSchema]) => {
-            if (defSchema) {
-                const jsDoc = getJSDoc(defSchema);
-                const defType = schemaToType(defSchema);
-                return [jsDoc, `type ${defsPrefix}__${defName.replace(/[^a-zA-Z0-9_$]/g, '_')} = ${defType};`]
-                    .filter(Boolean)
-                    .join('\n');
-            }
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n');
-    };
-    // Process definitions from both $defs and definitions properties
-    const allDefs = {
-        ...(schema.definitions || {}),
-        ...(schema.$defs || {}),
-    };
-    // Generate the main type
-    const jsDoc = getJSDoc(schema);
-    const mainType = schemaToType(schema);
-    const defsType = defsToType(allDefs);
-    return {
-        $type: jsDoc ? `${jsDoc}\n${mainType}` : mainType,
-        $defs: defsType,
-    };
-}