swagger-typescript-api 13.2.16 → 13.2.18

package/dist/index.d.cts

@@ -1,11 +1,13 @@
 import { OpenAPI } from "openapi-types";
 import * as typescript from "typescript";
-import * as lodash0 from "lodash";
-import lodash from "lodash";
+import * as es_toolkit_compat0 from "es-toolkit/compat";
+import { camelCase } from "es-toolkit/compat";
 import * as swagger_schema_official0 from "swagger-schema-official";
-import * as eta0 from "eta";
+import * as es_toolkit0 from "es-toolkit";
+import * as eta from "eta";
+import { PartialDeep } from "type-fest";
 
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 //#endregion
 //#region src/schema-components-map.d.ts
 declare class SchemaComponentsMap {
@@ -166,26 +168,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: any, inline: any) => any;
-  formatObjectContent: (content: any) => string;
-}
-//#endregion
 //#region src/schema-parser/schema-parser-fabric.d.ts
 declare class SchemaParserFabric {
   config: CodeGenConfig;
@@ -200,11 +182,7 @@ declare class SchemaParserFabric {
     schema,
     typeName,
     schemaPath
-  }: {
-    schema: any;
-    typeName: any;
-    schemaPath: any;
-  }) => SchemaParser;
+  }: SchemaParserConfig) => SchemaParser;
   createSchema: ({
     content,
     linkedSchema,
@@ -212,24 +190,65 @@ 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/schema-routes/schema-routes.d.ts
@@ -246,47 +265,12 @@ declare class SchemaRoutes {
   hasQueryRoutes: boolean;
   hasFormDataRoutes: boolean;
   constructor(config: CodeGenConfig, schemaParserFabric: SchemaParserFabric, schemaComponentsMap: SchemaComponentsMap, templatesWorker: TemplatesWorker, typeNameFormatter: TypeNameFormatter);
-  createRequestsMap: (routeInfoByMethodsMap: any) => {};
-  parseRouteName: (originalRouteName: any) => {
-    originalRoute: string;
-    route: string;
-    pathParams: {
-      $match: string;
-      name: string;
-      required: boolean;
-      type: "string";
-      description: string;
-      schema: {
-        type: string;
-      };
-      in: "path" | "query";
-    }[];
-    queryParams: {
-      $match: string;
-      name: string;
-      required: boolean;
-      type: "string";
-      description: string;
-      schema: {
-        type: string;
-      };
-      in: "path" | "query";
-    }[];
-  } | {
+  createRequestsMap: (routesByMethod: any) => {};
+  parseRouteName: (rawRoute: any) => {
     originalRoute: any;
     route: any;
-    pathParams: never[];
-    queryParams: {
-      $match: unknown;
-      name: string;
-      required: boolean;
-      type: string;
-      description: string;
-      schema: {
-        type: string;
-      };
-      in: string;
-    }[];
+    pathParams: any[];
+    queryParams: any[];
   };
   getRouteParams: (routeInfo: any, pathParamsFromRouteName: any, queryParamsFromRouteName: any) => {
     path: never[];
@@ -323,16 +307,16 @@ declare class SchemaRoutes {
     parsedSchemas: any;
     operationId: any;
     defaultType: any;
-  }) => never[];
+  }) => any[];
   getResponseBodyInfo: (routeInfo: any, parsedSchemas: any) => {
     contentTypes: any[];
-    responses: never[];
+    responses: any[];
     success: {
-      schema: undefined;
+      schema: any;
       type: any;
     };
     error: {
-      schemas: never[];
+      schemas: any[];
       type: string;
     };
     full: {
@@ -385,9 +369,6 @@ declare class JavascriptTranslator extends Translator {
   }[]>;
 }
 //#endregion
-//#region src/util/internal-case.d.ts
-declare function internalCase(value: string): string;
-//#endregion
 //#region src/util/name-resolver.d.ts
 type Resolver = (reserved: string[], extras?: string[]) => string;
 declare class NameResolver {
@@ -499,14 +480,15 @@ declare class CodeGenProcess {
           TypeWithGeneric: (typeName: unknown, genericArgs: unknown[]) => string;
           Tuple: (values: unknown[]) => string;
         };
-        formatDescription: (description: any, inline: any) => any;
-        internalCase: typeof internalCase;
+        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;
@@ -528,7 +510,7 @@ declare class CodeGenProcess {
           eol?: boolean | undefined;
         }) => string;
         NameResolver: typeof NameResolver;
-        _: lodash.LoDashStatic;
+        _: Record<string, unknown>;
         require: (packageOrPath: string) => any;
       };
     };
@@ -604,14 +586,15 @@ declare class CodeGenProcess {
         TypeWithGeneric: (typeName: unknown, genericArgs: unknown[]) => string;
         Tuple: (values: unknown[]) => string;
       };
-      formatDescription: (description: any, inline: any) => any;
-      internalCase: typeof internalCase;
+      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;
@@ -633,7 +616,7 @@ declare class CodeGenProcess {
         eol?: boolean | undefined;
       }) => string;
       NameResolver: typeof NameResolver;
-      _: lodash.LoDashStatic;
+      _: Record<string, unknown>;
       require: (packageOrPath: string) => any;
     };
     config: CodeGenConfig;
@@ -691,14 +674,18 @@ declare class SchemaParser {
   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;
@@ -756,23 +743,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 = {
@@ -843,8 +813,7 @@ interface GenerateApiParamsFromSpecLiteral extends Partial<GenerateApiConfigurat
 }
 type GenerateApiParams = GenerateApiParamsFromPath | GenerateApiParamsFromUrl | GenerateApiParamsFromSpecLiteral;
 type BuildRouteParam = {
-  /** {bar} */
-  $match: string;
+  /** {bar} */$match: string;
   name: string;
   required: boolean;
   type: "string";
@@ -855,9 +824,7 @@ type BuildRouteParam = {
   in: "path" | "query";
 };
 type BuildRoutePath = {
-  /** /foo/{bar}/baz */
-  originalRoute: string;
-  /** /foo/${bar}/baz */
+  /** /foo/{bar}/baz */originalRoute: string; /** /foo/${bar}/baz */
   route: string;
   pathParams: BuildRouteParam[];
   queryParams: BuildRouteParam[];
@@ -919,7 +886,7 @@ type SchemaTypeEnumContent = {
   type: string;
   value: string;
 };
-interface ParsedSchema<C$1> {
+interface ParsedSchema<C> {
   $parsedSchema: boolean;
   schemaType: string;
   type: string;
@@ -927,7 +894,7 @@ interface ParsedSchema<C$1> {
   name: string;
   description?: string;
   allFieldsAreOptional?: boolean;
-  content: C$1;
+  content: C;
   isExtractedRequestParams?: boolean;
   isExtractedRequestBody?: boolean;
   isExtractedResponseBody?: boolean;
@@ -965,7 +932,7 @@ declare enum RequestContentKind {
   FORM_DATA = "FORM_DATA",
   IMAGE = "IMAGE",
   OTHER = "OTHER",
-  TEXT = "TEXT",
+  TEXT = "TEXT"
 }
 interface RequestResponseInfo {
   contentTypes: string[];
@@ -1066,7 +1033,7 @@ declare enum SCHEMA_TYPES {
   COMPLEX_ANY_OF = "anyOf",
   COMPLEX_ALL_OF = "allOf",
   COMPLEX_NOT = "not",
-  COMPLEX_UNKNOWN = "__unknown",
+  COMPLEX_UNKNOWN = "__unknown"
 }
 type MAIN_SCHEMA_TYPES = SCHEMA_TYPES.PRIMITIVE | SCHEMA_TYPES.OBJECT | SCHEMA_TYPES.ENUM;
 type ExtractingOptions = {
@@ -1087,20 +1054,14 @@ type ExtractingOptions = {
 };
 interface GenerateApiConfiguration {
   apiConfig: {
-    /** base url from schema */
-    baseUrl: string;
-    /** document title */
-    title: string;
-    /** document version */
-    version: string;
-    /** description split into lines */
-    description: string[];
-    /** flag that description is present */
+    /** base url from schema */baseUrl: string; /** document title */
+    title: string; /** document version */
+    version: string; /** description split into lines */
+    description: string[]; /** flag that description is present */
     hasDescription: boolean;
   };
   config: {
-    /** path to swagger schema */
-    input: string;
+    /** path to swagger schema */input: string;
     /**
      * generate separated files for http client, data contracts, and routes
      * @default false
@@ -1111,10 +1072,8 @@ interface GenerateApiConfiguration {
      * may be set to `false` to skip writing content to disk; in this case
      * the `files` array on the return value will contain the generated contents.
      */
-    output: string | false;
-    /** url to swagger schema */
-    url: string;
-    /** swagger schema JSON */
+    output: string | false; /** url to swagger schema */
+    url: string; /** swagger schema JSON */
     spec: unknown;
     /**
      * file name for the generated API module
@@ -1127,95 +1086,57 @@ interface GenerateApiConfiguration {
      */
     templates: string;
     templatePaths: {
-      /** `templates/base` */
-      base: string;
-      /** `templates/default` */
-      default: string;
-      /** `templates/modular` */
-      modular: string;
-      /** usage path if `--templates` option is not set */
-      original: string;
-      /** custom path to templates (`--templates`) */
+      /** `templates/base` */base: string; /** `templates/default` */
+      default: string; /** `templates/modular` */
+      modular: string; /** usage path if `--templates` option is not set */
+      original: string; /** custom path to templates (`--templates`) */
       custom: string | null;
-    };
-    /** authorisation token for private swagger schema access */
-    authorizationToken?: string;
-    /** generate additional information about request responses and error typings */
+    }; /** authorisation token for private swagger schema access */
+    authorizationToken?: string; /** generate additional information about request responses and error typings */
     generateResponses: boolean;
     /**
      * use "default" response status code as success response.
      * some swagger schemas treat "default" as a successful response.
      */
-    defaultResponseAsSuccess: boolean;
-    /** generate type definitions for API routes */
-    generateRouteTypes: boolean;
-    /** generate an API client */
-    generateClient: boolean;
-    /** generate all "enum" types as union types (T1 | T2 | TN) */
-    generateUnionEnums: boolean;
-    /** parsed swagger schema */
-    swaggerSchema: object;
-    /** original swagger schema */
-    originalSchema: object;
-    /** map of schema component references */
-    componentsMap: Record<string, SchemaComponent>;
-    /** flag indicating the schema was converted from Swagger 2.0 */
-    convertedFromSwagger2: boolean;
-    /** determines which path index should be used for routes separation */
-    moduleNameIndex: number;
-    /** use the first tag for the module name */
-    moduleNameFirstTag: boolean;
-    /** extra templates */
+    defaultResponseAsSuccess: boolean; /** generate type definitions for API routes */
+    generateRouteTypes: boolean; /** generate an API client */
+    generateClient: boolean; /** generate all "enum" types as union types (T1 | T2 | TN) */
+    generateUnionEnums: boolean; /** parsed swagger schema */
+    swaggerSchema: object; /** original swagger schema */
+    originalSchema: object; /** map of schema component references */
+    componentsMap: Record<string, SchemaComponent>; /** flag indicating the schema was converted from Swagger 2.0 */
+    convertedFromSwagger2: boolean; /** determines which path index should be used for routes separation */
+    moduleNameIndex: number; /** use the first tag for the module name */
+    moduleNameFirstTag: boolean; /** extra templates */
     extraTemplates: {
       name: string;
       path: string;
-    }[];
-    /** extract request params to data contract */
-    extractRequestParams: boolean;
-    /** unwrap the data item from the response */
-    unwrapResponseData: boolean;
-    /** sort data contracts in alphabetical order */
-    sortTypes: boolean;
-    /** sort routes in alphabetical order */
-    sortRoutes: boolean;
-    /** ability to send HttpClient instance to Api constructor */
-    singleHttpClient: boolean;
-    /** prefix string value for type names */
-    typePrefix: string;
-    /** suffix string value for type names */
-    typeSuffix: string;
-    /** prefix string value for enum keys */
-    enumKeyPrefix: string;
-    /** suffix string value for enum keys */
-    enumKeySuffix: string;
-    /** fix up small errors in the swagger source definition */
-    patch: boolean;
-    /** remove output directory before generating */
-    cleanOutput: boolean;
-    /** output debug messages */
+    }[]; /** extract request params to data contract */
+    extractRequestParams: boolean; /** unwrap the data item from the response */
+    unwrapResponseData: boolean; /** sort data contracts in alphabetical order */
+    sortTypes: boolean; /** sort routes in alphabetical order */
+    sortRoutes: boolean; /** ability to send HttpClient instance to Api constructor */
+    singleHttpClient: boolean; /** prefix string value for type names */
+    typePrefix: string; /** suffix string value for type names */
+    typeSuffix: string; /** prefix string value for enum keys */
+    enumKeyPrefix: string; /** suffix string value for enum keys */
+    enumKeySuffix: string; /** fix up small errors in the swagger source definition */
+    patch: boolean; /** remove output directory before generating */
+    cleanOutput: boolean; /** output debug messages */
     debug: boolean;
     /**
      * generate array types as Array<Type>
      * @default false
      */
-    anotherArrayType: boolean;
-    /** extract request body type to data contract */
-    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 */
-    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 */
+    anotherArrayType: boolean; /** extract request body type to data contract */
+    extractRequestBody: boolean; /** generated http client type */
+    httpClientType: "axios" | "fetch"; /** generate readonly properties */
+    addReadonly: boolean; /** customise primitive type mappings */
+    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 */
     extractResponses: boolean;
     /**
      * prefix string value needed to fix invalid type names
@@ -1236,52 +1157,38 @@ interface GenerateApiConfiguration {
      * generate js api module with declaration file
      * @default false
      */
-    toJS: boolean;
-    /** disable throwing on a non-successful response */
+    toJS: boolean; /** disable throwing on a non-successful response */
     disableThrowOnError: boolean;
     /**
      * output only errors to console
      * @default false
      */
-    silent: boolean;
-    /** hooks for customising the generation process */
-    hooks: Partial<Hooks>;
-    /** use enum names as values */
-    enumNamesAsValues: boolean;
-    /** package version */
-    version: string;
-    /** ts compiler configuration object (for --to-js option) */
-    compilerTsConfig: Record<string, unknown>;
-    /** enum key resolver name */
-    enumKeyResolverName: string;
-    /** type name resolver name */
-    typeNameResolverName: string;
-    /** specific argument name resolver name */
+    silent: boolean; /** hooks for customising the generation process */
+    hooks: Partial<Hooks>; /** use enum names as values */
+    enumNamesAsValues: boolean; /** package version */
+    version: string; /** ts compiler configuration object (for --to-js option) */
+    compilerTsConfig: Record<string, unknown>; /** enum key resolver name */
+    enumKeyResolverName: string; /** type name resolver name */
+    typeNameResolverName: string; /** specific argument name resolver name */
     specificArgNameResolverName: string;
     /**
      * custom ts->* translator
      * do not use constructor args, just send class reference
      */
-    customTranslator?: new () => Translator;
-    /** internal constants */
-    constants: typeof constants_d_exports;
-    /** code generation constructs for TypeScript */
+    customTranslator?: new () => Translator; /** internal constants */
+    constants: typeof constants_d_exports; /** code generation constructs for TypeScript */
     Ts: CodeGenConstruct;
     /**
      * swagger schema type -> typescript type
      * https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
      */
-    primitiveTypes: PrimitiveTypeStruct;
-    /** built-in template info */
+    primitiveTypes: PrimitiveTypeStruct; /** built-in template info */
     templateInfos: {
       name: string;
       fileName: string;
-    }[];
-    /** supported template file extensions */
-    templateExtensions: string[];
-    /** range of HTTP status codes treated as success */
-    successResponseStatusRange: [number, number];
-    /** custom schema parsers */
+    }[]; /** supported template file extensions */
+    templateExtensions: string[]; /** range of HTTP status codes treated as success */
+    successResponseStatusRange: [number, number]; /** custom schema parsers */
     schemaParsers?: {
       complexOneOf?: MonoSchemaParser;
       complexAllOf?: MonoSchemaParser;
@@ -1293,21 +1200,17 @@ interface GenerateApiConfiguration {
       primitive?: MonoSchemaParser;
       discriminator?: MonoSchemaParser;
       array?: MonoSchemaParser;
-    };
-    /** internal options for templates */
+    }; /** internal options for templates */
     internalTemplateOptions: {
       addUtilRequiredKeysType: boolean;
-    };
-    /** resolver for component type names */
-    componentTypeNameResolver: ComponentTypeNameResolver;
-    /** generated file names */
+    }; /** resolver for component type names */
+    componentTypeNameResolver: ComponentTypeNameResolver; /** generated file names */
     fileNames: {
       dataContracts: string;
       routeTypes: string;
       httpClient: string;
       outOfModuleApi: string;
-    };
-    /** Record<templateName, templateContent> */
+    }; /** Record<templateName, templateContent> */
     templatesToRender: {
       api: string;
       dataContracts: string;
@@ -1319,16 +1222,11 @@ interface GenerateApiConfiguration {
       typeDataContract: string;
       enumDataContract: string;
       objectFieldJsDoc: string;
-    };
-    /** map of duplicate route names */
-    routeNameDuplicatesMap: Map<string, string>;
-    /** name of the main exported class */
-    apiClassName: string;
-    /** configuration for fetching swagger schema requests */
-    requestOptions?: Partial<RequestInit>;
-    /** extra configuration for extracting type names operations */
-    extractingOptions: Partial<ExtractingOptions>;
-    /** update configuration object during generation */
+    }; /** map of duplicate route names */
+    routeNameDuplicatesMap: Map<string, string>; /** name of the main exported class */
+    apiClassName: string; /** configuration for fetching swagger schema requests */
+    requestOptions?: Partial<RequestInit>; /** extra configuration for extracting type names operations */
+    extractingOptions: Partial<ExtractingOptions>; /** update configuration object during generation */
     update: (update: Partial<GenerateApiConfiguration["config"]>) => void;
   };
   modelTypes: ModelType[];
@@ -1346,8 +1244,7 @@ interface GenerateApiConfiguration {
   requestOptions?: Partial<RequestInit>;
   utils: {
     formatDescription: (description: string, inline?: boolean) => string;
-    internalCase: (value: string) => string;
-    /** @deprecated */
+    internalCase: (value: string) => string; /** @deprecated */
     classNameCase: (value: string) => string;
     pascalCase: (value: string) => string;
     getInlineParseContent: (rawTypeData: SchemaComponent["rawTypeData"], typeName?: string) => string;
@@ -1360,16 +1257,13 @@ interface GenerateApiConfiguration {
     fmtToJSDocLine: (line: string, params?: {
       eol?: boolean;
     }) => string;
-    _: lodash0.LoDashStatic;
+    _: typeof es_toolkit0 & typeof es_toolkit_compat0;
     require: (path: string) => unknown;
   };
 }
 type FileInfo = {
-  /** @example myFilename */
-  fileName: string;
-  /** @example .d.ts */
-  fileExtension: string;
-  /** content of the file */
+  /** @example myFilename */fileName: string; /** @example .d.ts */
+  fileExtension: string; /** content of the file */
   fileContent: string;
 };
 interface GenerateApiOutput {
@@ -1381,7 +1275,7 @@ interface GenerateApiOutput {
     content: string;
     withPrefix: boolean;
   }) => void;
-  renderTemplate: (templateContent: string, data: Record<string, unknown>, etaOptions?: Partial<eta0.EtaConfig>) => Promise<string> | string;
+  renderTemplate: (templateContent: string, data: Record<string, unknown>, etaOptions?: Partial<eta.EtaConfig>) => Promise<string> | string;
   getTemplate: (params: {
     fileName?: string;
     name?: string;
@@ -1453,15 +1347,10 @@ declare class CodeGenConfig {
   sortTypes: boolean;
   sortRoutes: boolean;
   templatePaths: {
-    /** `templates/base` */
-    base: string;
-    /** `templates/default` */
-    default: string;
-    /** `templates/modular` */
-    modular: string;
-    /** usage path if `--templates` option is not set */
-    original: string;
-    /** custom path to templates (`--templates`) */
+    /** `templates/base` */base: string; /** `templates/default` */
+    default: string; /** `templates/modular` */
+    modular: string; /** usage path if `--templates` option is not set */
+    original: string; /** custom path to templates (`--templates`) */
     custom: string;
   };
   /** Record<templateName, templateContent> */
@@ -1774,14 +1663,15 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
         TypeWithGeneric: (typeName: unknown, genericArgs: unknown[]) => string;
         Tuple: (values: unknown[]) => string;
       };
-      formatDescription: (description: any, inline: any) => any;
-      internalCase: typeof internalCase;
+      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;
@@ -1803,7 +1693,7 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
         eol?: boolean | undefined;
       }) => string;
       NameResolver: typeof NameResolver;
-      _: lodash0.LoDashStatic;
+      _: Record<string, unknown>;
       require: (packageOrPath: string) => any;
     };
   };