swagger-typescript-api 13.2.17 → 13.3.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_generate_templates = require('./generate-templates-wjE78AWV.cjs');
+const require_generate_templates = require('./generate-templates-BlSkwa8l.cjs');
 let consola = require("consola");
 
 //#region src/index.ts

package/dist/index.d.cts

@@ -1,22 +1,26 @@
 import { OpenAPI } from "openapi-types";
 import * as typescript from "typescript";
+import { resolve } from "@apidevtools/swagger-parser";
 import * as es_toolkit_compat0 from "es-toolkit/compat";
 import { camelCase } from "es-toolkit/compat";
+import { AnyObject, Maybe, Primitive } from "yummies/types";
 import * as swagger_schema_official0 from "swagger-schema-official";
 import * as es_toolkit0 from "es-toolkit";
 import * as eta from "eta";
+import { PartialDeep } from "type-fest";
 
 //#region \0rolldown/runtime.js
 //#endregion
 //#region src/schema-components-map.d.ts
 declare class SchemaComponentsMap {
-  _data: SchemaComponent[];
   config: CodeGenConfig;
+  _data: SchemaComponent[];
   constructor(config: CodeGenConfig);
   clear(): void;
   createRef: (paths: string[]) => string;
   parseRef: (ref: string) => string[];
-  createComponent($ref: string, rawTypeData: SchemaComponent["rawTypeData"]): SchemaComponent;
+  private createComponentDraft;
+  createComponent($ref: string, rawTypeData: SchemaComponent["rawTypeData"] | SchemaComponent, addAtStart?: boolean): SchemaComponent;
   getComponents(): SchemaComponent[];
   filter(...componentNames: (string[] | string)[]): SchemaComponent[];
   get: ($ref: string) => SchemaComponent | null;
@@ -24,85 +28,6 @@ declare class SchemaComponentsMap {
   discriminatorsFirst(): void;
 }
 //#endregion
-//#region src/util/file-system.d.ts
-declare class FileSystem {
-  getFileContent: (path: string) => string;
-  readDir: (path: string) => string[];
-  pathIsDir: (path: string) => boolean;
-  cropExtension: (fileName: string) => string;
-  removeDir: (path: string) => void;
-  createDir: (path: string) => void;
-  cleanDir: (path: string) => void;
-  pathIsExist: (path: string) => boolean;
-  createFile: ({
-    path: path_,
-    fileName,
-    content,
-    withPrefix
-  }: {
-    path: any;
-    fileName: any;
-    content: any;
-    withPrefix: any;
-  }) => void;
-}
-//#endregion
-//#region src/util/request.d.ts
-declare class Request {
-  config: CodeGenConfig;
-  constructor(config: CodeGenConfig);
-  download({
-    url,
-    authToken,
-    ...options
-  }: {
-    url: string;
-    authToken?: string;
-    options?: Partial<RequestInit>;
-  }): Promise<string>;
-}
-//#endregion
-//#region src/swagger-schema-resolver.d.ts
-declare class SwaggerSchemaResolver {
-  config: CodeGenConfig;
-  fileSystem: FileSystem;
-  request: Request;
-  constructor(config: CodeGenConfig, fileSystem: FileSystem);
-  create(): Promise<{
-    usageSchema: OpenAPI.Document;
-    originalSchema: OpenAPI.Document;
-  }>;
-  convertSwaggerObject(swaggerSchema: OpenAPI.Document, converterOptions: {
-    patch?: boolean;
-  }): Promise<{
-    usageSchema: OpenAPI.Document;
-    originalSchema: OpenAPI.Document;
-  }>;
-  getSwaggerSchemaByPath: (pathToSwagger: string) => string;
-  fetchSwaggerSchemaFile(pathToSwagger: string, urlToSwagger: string, authToken?: string): Promise<string>;
-  processSwaggerSchemaFile(file: string): any;
-  fixSwaggerSchema({
-    usageSchema,
-    originalSchema
-  }: {
-    usageSchema: any;
-    originalSchema: any;
-  }): void;
-}
-//#endregion
-//#region src/schema-walker.d.ts
-declare class SchemaWalker {
-  config: CodeGenConfig;
-  swaggerSchemaResolver: SwaggerSchemaResolver;
-  schemas: Map<string, OpenAPI.Document<{}>>;
-  caches: Map<string, OpenAPI.Document<{}>>;
-  constructor(config: CodeGenConfig, swaggerSchemaResolver: SwaggerSchemaResolver);
-  addSchema: (name: string, schema: OpenAPI.Document) => void;
-  _isLocalRef: (ref: string) => boolean;
-  _isRemoteRef: (ref: string) => boolean;
-  _getRefDataFromSchema: (schema: Record<string, unknown>, ref: string) => any;
-}
-//#endregion
 //#region src/type-name-formatter.d.ts
 type FormattingSchemaType = "enum-key" | "type-name";
 declare class TypeNameFormatter {
@@ -123,18 +48,7 @@ declare class SchemaUtils {
   config: CodeGenConfig;
   schemaComponentsMap: SchemaComponentsMap;
   typeNameFormatter: TypeNameFormatter;
-  schemaWalker: SchemaWalker;
-  constructor({
-    config,
-    schemaComponentsMap,
-    typeNameFormatter,
-    schemaWalker
-  }: {
-    config: any;
-    schemaComponentsMap: any;
-    typeNameFormatter: any;
-    schemaWalker: any;
-  });
+  constructor(config: CodeGenConfig, schemaComponentsMap: SchemaComponentsMap, typeNameFormatter: TypeNameFormatter);
   getRequiredProperties: (schema: any) => unknown[];
   isRefSchema: (schema: any) => boolean;
   getEnumNames: (schema: any) => any;
@@ -167,26 +81,6 @@ declare class SchemaUtils {
   formatJsValue: (value: any) => string;
 }
 //#endregion
-//#region src/schema-parser/schema-formatters.d.ts
-declare class SchemaFormatters {
-  config: CodeGenConfig;
-  templatesWorker: TemplatesWorker;
-  schemaUtils: SchemaUtils;
-  constructor(schemaParser: SchemaParser | SchemaParserFabric);
-  base: {
-    enum: (parsedSchema: any) => any;
-    object: (parsedSchema: any) => any;
-    primitive: (parsedSchema: any) => any;
-  };
-  inline: {
-    enum: (parsedSchema: any) => any;
-    object: (parsedSchema: any) => any;
-  };
-  formatSchema: (parsedSchema: Record<string, any>, formatType?: "base" | "inline") => any;
-  formatDescription: (description: string | undefined, inline?: boolean) => string;
-  formatObjectContent: (content: any) => string;
-}
-//#endregion
 //#region src/schema-parser/schema-parser-fabric.d.ts
 declare class SchemaParserFabric {
   config: CodeGenConfig;
@@ -195,17 +89,12 @@ declare class SchemaParserFabric {
   schemaFormatters: SchemaFormatters;
   templatesWorker: TemplatesWorker;
   schemaUtils: SchemaUtils;
-  schemaWalker: SchemaWalker;
-  constructor(config: CodeGenConfig, templatesWorker: TemplatesWorker, schemaComponentsMap: SchemaComponentsMap, typeNameFormatter: TypeNameFormatter, schemaWalker: SchemaWalker);
+  constructor(config: CodeGenConfig, templatesWorker: TemplatesWorker, schemaComponentsMap: SchemaComponentsMap, typeNameFormatter: TypeNameFormatter);
   createSchemaParser: ({
     schema,
     typeName,
     schemaPath
-  }: {
-    schema: any;
-    typeName: any;
-    schemaPath: any;
-  }) => SchemaParser;
+  }: SchemaParserConfig) => SchemaParser;
   createSchema: ({
     content,
     linkedSchema,
@@ -213,41 +102,121 @@ declare class SchemaParserFabric {
     schemaPath,
     ...otherSchemaProps
   }: {
-    [x: string]: any;
-    content: any;
-    linkedSchema?: {} | undefined;
-    linkedComponent: any;
-    schemaPath: any;
+    content: unknown;
+    linkedSchema?: Record<string, unknown>;
+    linkedComponent?: SchemaComponent;
+    schemaPath?: string[];
+    [key: string]: unknown;
   }) => any;
   createParsedComponent: ({
     typeName,
     schema,
     schemaPath
-  }: {
-    typeName: any;
-    schema: any;
-    schemaPath: any;
+  }: Required<SchemaParserConfig> & {
+    typeName: string;
   }) => SchemaComponent;
-  parseSchema: (schema: string, typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
-  getInlineParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
-  getParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
+  parseSchema: (schema: SchemaParserConfig["schema"], typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
+  getInlineParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
+  getParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
+}
+//#endregion
+//#region src/schema-parser/schema-formatters.d.ts
+declare class SchemaFormatters {
+  config: CodeGenConfig;
+  templatesWorker: TemplatesWorker;
+  schemaUtils: SchemaUtils;
+  constructor(schemaParser: SchemaParser | SchemaParserFabric);
+  base: {
+    enum: (parsedSchema: any) => any;
+    object: (parsedSchema: any) => any;
+    primitive: (parsedSchema: any) => any;
+  };
+  inline: {
+    enum: (parsedSchema: any) => any;
+    object: (parsedSchema: any) => any;
+  };
+  formatSchema: (parsedSchema: Record<string, any>, formatType?: "base" | "inline") => any;
+  escapeJSDocContent: (content: unknown) => string;
+  formatDescription: (description: string | undefined, inline?: boolean) => string;
+  formatObjectContent: (content: any) => string;
+}
+//#endregion
+//#region src/schema-parser/mono-schema-parser.d.ts
+interface SchemaParserConfig {
+  typeName?: string | null;
+  schema?: any;
+  schemaPath?: string[];
+}
+declare class MonoSchemaParser {
+  schema: any;
+  typeName: string | null;
+  schemaPath: string[];
+  schemaParser: SchemaParser;
+  schemaParserFabric: SchemaParserFabric;
+  typeNameFormatter: TypeNameFormatter;
+  schemaComponentsMap: SchemaComponentsMap;
+  schemaUtils: SchemaUtils;
+  config: CodeGenConfig;
+  schemaFormatters: SchemaFormatters;
+  constructor(schemaParser: SchemaParser, schema: unknown, typeName?: string | null, schemaPath?: string[]);
+  parse(): void;
+  buildTypeNameFromPath: () => Capitalize<string> | null;
+}
+//#endregion
+//#region src/resolved-swagger-schema.d.ts
+interface RefDetails {
+  ref: string;
+  isLocal: boolean;
+  externalUrlOrPath: Maybe<string>;
+  externalOpenapiFileName?: string;
+}
+declare class ResolvedSwaggerSchema {
+  private config;
+  usageSchema: OpenAPI.Document;
+  originalSchema: OpenAPI.Document;
+  private resolvers;
+  private parsedRefsCache;
+  private externalSchemaCache;
+  private httpMethodSegments;
+  private normalizeRef;
+  private createEscapedPathsRefVariant;
+  private isHttpUrl;
+  private getRemoteRequestHeaders;
+  private stripHash;
+  private extractRefsFromSchema;
+  private fetchRemoteSchemaDocument;
+  private warmUpRemoteSchemasCache;
+  private collectRemoteAbsoluteRefCandidates;
+  private resolveFromRemoteSchemaCache;
+  private constructor();
+  getRefDetails(ref: string): RefDetails;
+  isLocalRef(ref: string): boolean;
+  getRef(ref: Maybe<string>): Maybe<AnyObject | Primitive>;
+  private tryToResolveRef;
+  private readExternalSchema;
+  private resolveJsonPointer;
+  private absolutizeLocalRefs;
+  private normalizeResolvedExternalSchemaRef;
+  private collectExternalRefCandidates;
+  private tryToResolveRefFromFile;
+  static create(config: CodeGenConfig, usageSchema: OpenAPI.Document, originalSchema: OpenAPI.Document): Promise<ResolvedSwaggerSchema>;
 }
 //#endregion
 //#region src/schema-routes/schema-routes.d.ts
 declare class SchemaRoutes {
   config: CodeGenConfig;
   schemaParserFabric: SchemaParserFabric;
-  schemaUtils: SchemaUtils;
-  typeNameFormatter: TypeNameFormatter;
   schemaComponentsMap: SchemaComponentsMap;
   templatesWorker: TemplatesWorker;
+  typeNameFormatter: TypeNameFormatter;
+  schemaUtils: SchemaUtils;
   FORM_DATA_TYPES: string[];
   routes: ParsedRoute[];
   hasSecurityRoutes: boolean;
   hasQueryRoutes: boolean;
   hasFormDataRoutes: boolean;
   constructor(config: CodeGenConfig, schemaParserFabric: SchemaParserFabric, schemaComponentsMap: SchemaComponentsMap, templatesWorker: TemplatesWorker, typeNameFormatter: TypeNameFormatter);
-  createRequestsMap: (routesByMethod: any) => {};
+  createRequestsMap: (resolvedSwaggerSchema: ResolvedSwaggerSchema, routesByMethod: any) => {};
   parseRouteName: (rawRoute: any) => {
     originalRoute: any;
     route: any;
@@ -283,16 +252,20 @@ declare class SchemaRoutes {
     requestInfos,
     parsedSchemas,
     operationId,
-    defaultType
+    defaultType,
+    resolvedSwaggerSchema
   }: {
     requestInfos: any;
     parsedSchemas: any;
     operationId: any;
     defaultType: any;
+    resolvedSwaggerSchema: any;
   }) => any[];
-  getResponseBodyInfo: (routeInfo: any, parsedSchemas: any) => {
+  getRouteLinksFromResponse: (resolvedSwaggerSchema: ResolvedSwaggerSchema, responseInfo: AnyObject, status: string) => RouteLinkInfo[];
+  getResponseBodyInfo: (routeInfo: any, parsedSchemas: any, resolvedSwaggerSchema: any) => {
     contentTypes: any[];
     responses: any[];
+    links: any[];
     success: {
       schema: any;
       type: any;
@@ -323,14 +296,8 @@ declare class SchemaRoutes {
   extractResponseBodyIfItNeeded: (routeInfo: any, responseBodyInfo: any, routeName: any) => void;
   extractResponseErrorIfItNeeded: (routeInfo: any, responseBodyInfo: any, routeName: any) => void;
   getRouteName: (rawRouteInfo: any) => RouteNameInfo;
-  parseRouteInfo: (rawRouteName: any, routeInfo: any, method: any, usageSchema: any, parsedSchemas: any) => ParsedRoute;
-  attachSchema: ({
-    usageSchema,
-    parsedSchemas
-  }: {
-    usageSchema: any;
-    parsedSchemas: any;
-  }) => void;
+  parseRouteInfo: (rawRouteName: any, routeInfo: any, method: any, resolvedSwaggerSchema: ResolvedSwaggerSchema, parsedSchemas: any) => ParsedRoute;
+  attachSchema: (resolvedSwaggerSchema: ResolvedSwaggerSchema, parsedSchemas: ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>[]) => void;
   getGroupedRoutes: () => {
     outOfModule: ParsedRoute[];
     combined?: {
@@ -341,6 +308,66 @@ declare class SchemaRoutes {
   sortRoutes: (routes: ParsedRoute[]) => ParsedRoute[];
 }
 //#endregion
+//#region src/util/file-system.d.ts
+declare class FileSystem {
+  getFileContent: (path: string) => string;
+  readDir: (path: string) => string[];
+  pathIsDir: (path: string) => boolean;
+  cropExtension: (fileName: string) => string;
+  removeDir: (path: string) => void;
+  createDir: (path: string) => void;
+  cleanDir: (path: string) => void;
+  pathIsExist: (path: string) => boolean;
+  createFile: ({
+    path: path_,
+    fileName,
+    content,
+    withPrefix
+  }: {
+    path: any;
+    fileName: any;
+    content: any;
+    withPrefix: any;
+  }) => void;
+}
+//#endregion
+//#region src/util/request.d.ts
+declare class Request {
+  config: CodeGenConfig;
+  constructor(config: CodeGenConfig);
+  download({
+    url,
+    authToken,
+    ...options
+  }: {
+    url: string;
+    authToken?: string;
+    options?: Partial<RequestInit>;
+  }): Promise<string>;
+}
+//#endregion
+//#region src/swagger-schema-resolver.d.ts
+interface SwaggerSchemas {
+  usageSchema: OpenAPI.Document;
+  originalSchema: OpenAPI.Document;
+}
+declare class SwaggerSchemaResolver {
+  config: CodeGenConfig;
+  fileSystem: FileSystem;
+  request: Request;
+  constructor(config: CodeGenConfig, fileSystem: FileSystem);
+  create(): Promise<ResolvedSwaggerSchema>;
+  convertSwaggerObject(swaggerSchema: OpenAPI.Document, converterOptions: {
+    patch?: boolean;
+  }): Promise<SwaggerSchemas>;
+  getSwaggerSchemaByPath: (pathToSwagger: string) => string;
+  fetchSwaggerSchemaFile(pathToSwagger: string, urlToSwagger: string, authToken?: string): Promise<string>;
+  processSwaggerSchemaFile(file: string): any;
+  private normalizeRefValue;
+  private normalizeRefsInSchema;
+  private fixSwaggerSchemas;
+}
+//#endregion
 //#region src/translators/javascript.d.ts
 declare class JavascriptTranslator extends Translator {
   compileTSCode: (input: TranslatorIO) => Record<string, string>;
@@ -378,8 +405,8 @@ declare class CodeGenProcess {
   fileSystem: FileSystem;
   codeFormatter: CodeFormatter;
   templatesWorker: TemplatesWorker;
-  schemaWalker: SchemaWalker;
   javascriptTranslator: JavascriptTranslator;
+  swaggerRefs: Awaited<ReturnType<typeof resolve>> | undefined | null;
   constructor(config: Partial<GenerateApiConfiguration["config"]>);
   start(): Promise<{
     files: TranslatorIO[];
@@ -463,13 +490,14 @@ declare class CodeGenProcess {
           Tuple: (values: unknown[]) => string;
         };
         formatDescription: (description: string | undefined, inline?: boolean) => string;
+        escapeJSDocContent: (content: unknown) => string;
         internalCase: typeof camelCase;
         classNameCase: typeof pascalCase;
         pascalCase: typeof pascalCase;
-        getInlineParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
-        getParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
+        getInlineParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
+        getParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
         getComponentByRef: ($ref: string) => SchemaComponent | null;
-        parseSchema: (schema: string, typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
+        parseSchema: (schema: SchemaParserConfig["schema"], typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
         checkAndAddNull: (schema: any, type: any) => any;
         safeAddNullToType: (schema: any, type: any) => any;
         isNeedToAddNull: (schema: any, type: any) => any;
@@ -568,13 +596,14 @@ declare class CodeGenProcess {
         Tuple: (values: unknown[]) => string;
       };
       formatDescription: (description: string | undefined, inline?: boolean) => string;
+      escapeJSDocContent: (content: unknown) => string;
       internalCase: typeof camelCase;
       classNameCase: typeof pascalCase;
       pascalCase: typeof pascalCase;
-      getInlineParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
-      getParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
+      getInlineParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
+      getParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
       getComponentByRef: ($ref: string) => SchemaComponent | null;
-      parseSchema: (schema: string, typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
+      parseSchema: (schema: SchemaParserConfig["schema"], typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
       checkAndAddNull: (schema: any, type: any) => any;
       safeAddNullToType: (schema: any, type: any) => any;
       isNeedToAddNull: (schema: any, type: any) => any;
@@ -653,15 +682,18 @@ declare class SchemaParser {
   schemaFormatters: SchemaFormatters;
   schemaUtils: SchemaUtils;
   templatesWorker: TemplatesWorker;
-  schemaWalker: SchemaWalker;
-  typeName: any;
+  typeName: string | null;
   schema: any;
-  schemaPath: never[];
-  constructor(schemaParserFabric: any, {
+  schemaPath: string[];
+  constructor(schemaParserFabric: SchemaParserFabric, {
     typeName,
     schema,
     schemaPath
-  }?: {});
+  }?: {
+    typeName?: string | null;
+    schema?: any;
+    schemaPath?: string[];
+  });
   _complexSchemaParsers: {
     oneOf: (schema: any) => any;
     allOf: (schema: any) => any;
@@ -719,23 +751,6 @@ declare const SCHEMA_TYPES$1: {
   readonly COMPLEX_UNKNOWN: "__unknown";
 };
 //#endregion
-//#region src/schema-parser/mono-schema-parser.d.ts
-declare class MonoSchemaParser {
-  schema: any;
-  typeName: any;
-  schemaPath: never[];
-  schemaParser: SchemaParser;
-  schemaParserFabric: SchemaParserFabric;
-  typeNameFormatter: TypeNameFormatter;
-  schemaComponentsMap: SchemaComponentsMap;
-  schemaUtils: SchemaUtils;
-  config: CodeGenConfig;
-  schemaFormatters: SchemaFormatters;
-  constructor(schemaParser: SchemaParser, schema: any, typeName?: null, schemaPath?: never[]);
-  parse(): void;
-  buildTypeNameFromPath: () => Capitalize<string> | null;
-}
-//#endregion
 //#region types/index.d.ts
 type HttpClientType = (typeof HTTP_CLIENT)[keyof typeof HTTP_CLIENT];
 type CodeGenConstruct = {
@@ -849,6 +864,8 @@ interface Hooks {
   onFormatTypeName?: (typeName: string, rawTypeName?: string, schemaType?: "type-name" | "enum-key") => string | undefined;
   /** customize name of route (operationId), you can do it with using onCreateRouteName too */
   onFormatRouteName?: (routeInfo: RawRouteInfo, templateRouteName: string) => string | undefined;
+  onFormatExternalTypeName?: (typeName: string, refInfo: RefDetails) => string | undefined;
+  onFixDuplicateExternalTypeName?: (typeName: string, refInfo: RefDetails, existedTypeNames: string[]) => string | undefined;
 }
 type RouteNameRouteInfo = Record<string, unknown>;
 type RouteNameInfo = {
@@ -934,6 +951,14 @@ interface RequestResponseInfo {
   description: string;
   status: string | number;
   isSuccess: boolean;
+  links?: RouteLinkInfo[];
+}
+interface RouteLinkInfo {
+  status: string | number;
+  name: string;
+  operationId?: string;
+  operationRef?: string;
+  parameters?: Record<string, string>;
 }
 type RawRouteInfo = {
   operationId: string;
@@ -941,6 +966,7 @@ type RawRouteInfo = {
   route: string;
   moduleName: string;
   responsesTypes: RequestResponseInfo[];
+  links?: RouteLinkInfo[];
   description?: string;
   tags?: string[];
   summary?: string;
@@ -992,6 +1018,7 @@ interface ParsedRoute {
   responseBodyInfo?: {
     contentTypes: any[];
     responses: any[];
+    links?: RouteLinkInfo[];
     success?: Record<string, any>;
     error?: Record<string, any>;
     full?: Record<string, any>;
@@ -1125,8 +1152,8 @@ interface GenerateApiConfiguration {
     extractRequestBody: boolean; /** generated http client type */
     httpClientType: "axios" | "fetch"; /** generate readonly properties */
     addReadonly: boolean; /** customise primitive type mappings */
-    primitiveTypeConstructs?: (struct: PrimitiveTypeStruct) => Partial<PrimitiveTypeStruct>; /** customise code generation constructs */
-    codeGenConstructs?: (struct: CodeGenConstruct) => Partial<CodeGenConstruct>; /** extract response body type to data contract */
+    primitiveTypeConstructs?: ((struct: PrimitiveTypeStruct) => PartialDeep<PrimitiveTypeStruct>) | PartialDeep<PrimitiveTypeStruct>; /** customise code generation constructs */
+    codeGenConstructs?: ((struct: CodeGenConstruct) => PartialDeep<CodeGenConstruct>) | PartialDeep<CodeGenConstruct>; /** extract response body type to data contract */
     extractResponseBody: boolean; /** extract response error type to data contract */
     extractResponseError: boolean; /** extract all enums from nested types/interfaces to `enum` construction */
     extractEnums: boolean; /** extract all enums from inline interface/type content to typescript enum construction */
@@ -1332,6 +1359,7 @@ declare class CodeGenConfig {
   };
   routeNameDuplicatesMap: Map<any, any>;
   hooks: Hooks;
+  resolvedSwaggerSchema: ResolvedSwaggerSchema;
   defaultResponseType: string;
   singleHttpClient: boolean;
   httpClientType: "fetch";
@@ -1384,7 +1412,7 @@ declare class CodeGenConfig {
   spec: OpenAPI.Document | null;
   fileName: string;
   authorizationToken: string | undefined;
-  requestOptions: null;
+  requestOptions: Record<string, any> | null;
   jsPrimitiveTypes: string[];
   jsEmptyTypes: string[];
   fixInvalidTypeNamePrefix: string;
@@ -1540,7 +1568,9 @@ declare class CodeGenConfig {
     hooks,
     ...otherConfig
   }: Partial<GenerateApiConfiguration["config"]>);
-  update: (update: Partial<GenerateApiConfiguration["config"]>) => void;
+  update: (update: Partial<GenerateApiConfiguration["config"] & {
+    resolvedSwaggerSchema: ResolvedSwaggerSchema;
+  }>) => void;
 }
 //#endregion
 //#region src/code-formatter.d.ts
@@ -1657,13 +1687,14 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
         Tuple: (values: unknown[]) => string;
       };
       formatDescription: (description: string | undefined, inline?: boolean) => string;
+      escapeJSDocContent: (content: unknown) => string;
       internalCase: typeof es_toolkit_compat0.camelCase;
       classNameCase: typeof pascalCase;
       pascalCase: typeof pascalCase;
-      getInlineParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
-      getParseContent: (schema: string, typeName: string | null, schemaPath: string[]) => Record<string, any>;
+      getInlineParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
+      getParseContent: (schema: SchemaParserConfig["schema"], typeName: string | null, schemaPath: string[]) => Record<string, any>;
       getComponentByRef: ($ref: string) => SchemaComponent | null;
-      parseSchema: (schema: string, typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
+      parseSchema: (schema: SchemaParserConfig["schema"], typeName?: string | null, schemaPath?: string[]) => ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
       checkAndAddNull: (schema: any, type: any) => any;
       safeAddNullToType: (schema: any, type: any) => any;
       isNeedToAddNull: (schema: any, type: any) => any;
@@ -1711,5 +1742,5 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
   }) => Promise<string>;
 }>;
 //#endregion
-export { ExtractingOptions, GenerateApiConfiguration, GenerateApiOutput, GenerateApiParams, GenerateTemplatesOutput, GenerateTemplatesParams, Hooks, HttpClientType, ModelType, ParsedRoute, ParsedRouteRequest, ParsedRouteResponse, ParsedSchema, PathArgInfo, RawRouteInfo, RequestContentKind, RequestResponseInfo, RouteNameInfo, RouteNameRouteInfo, SCHEMA_TYPES, SchemaComponent, SchemaTypeEnumContent, SchemaTypeObjectContent, SchemaTypePrimitiveContent, constants_d_exports as constants, generateApi, generateTemplates };
+export { ExtractingOptions, GenerateApiConfiguration, GenerateApiOutput, GenerateApiParams, GenerateTemplatesOutput, GenerateTemplatesParams, Hooks, HttpClientType, ModelType, ParsedRoute, ParsedRouteRequest, ParsedRouteResponse, ParsedSchema, PathArgInfo, RawRouteInfo, RequestContentKind, RequestResponseInfo, RouteLinkInfo, RouteNameInfo, RouteNameRouteInfo, SCHEMA_TYPES, SchemaComponent, SchemaTypeEnumContent, SchemaTypeObjectContent, SchemaTypePrimitiveContent, constants_d_exports as constants, generateApi, generateTemplates };
 //# sourceMappingURL=index.d.cts.map